pythondictxml

A. python配合前端写简单接口（加前端vue代码）

服务器端：

# 开发人员: hanhan丶

# 开发时间: 2020/11/12 14:36

import flask, json                           #Flask 一个轻量级的web框架

from flask_corsimport *

server = flask.Flask(__name__)      # __name__代表当前的python文件。把当前的python文件当做一个服务启动

CORS(server, supports_credentials=True)     # 解决跨域

@server.route('/login', methods=['post'])

# 第一个参数就是路径,第二个参数支持的请求方式，不写的话默认是get，

# 加了@server.route才是一个接口，不然就是一个普通函数

def login():

user = flask.request.values.to_dict()

for itemin user:

items = json.loads(item)

loginName = items.get("loginName")

password = items.get("password")

if loginNameand password:

res = {"code":0, "msg":"请求成功", "data": {"loginName": loginName, "password": password}}

else:

res = {'msg':'调用失败'}

# json.mps 序列化时对中文默认使用的ascii编码，输出中文需要设置ensure_ascii=False

        return json.mps(res, ensure_ascii=False)

if __name__ =='__main__':

# port可以指定端口，默认端口是5000

    # host默认是服务器，默认是127.0.0.1

    # debug=True 修改时不关闭服务

    server.run(debug=True)

前端：

<template>

  <div>

    账号：<input type="text" v-model="loginName">

    <br>

     密码：<input type="text" v-model="password">

    <br>

    <br>

    <br>

    <button @click="btn">点击</button>

  </div>

</template>

<script>

import axios from "axios";

export default {

  data() {

    return {

      loginName: "",

      password: ""

    };

  },

  methods: {

    getDate() {

      axios({

        headers: {

          "X-Requested-With": "XMLHttpRequest",

          "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"

        },

        url: "http://127.0.0.1:5000/login",

        method: "post",

        data: {

          loginName: this.loginName,

          password: this.password

        }

      }).then(res => {

        console.log(res);

      });

    },

    btn() {

      this.getDate();

    }

  }

};

</script>

<style>

</style>

B. python lxml etree怎么甩

lxml是Python语言中处理XML和HTML功能最丰富，最易于使用的库。

lxml是libxml2和libxslt两个C库的Python化绑定，它的独特之处在于兼顾了这些库的速度和功能完整性，同时还具有Python API的简介。兼容ElementTree API,但是比它更优越。

用libxml2编程就像是一个异于常人的陌生人的令人惊恐的拥抱，它看上去可以满足你一切疯狂的梦想，但是你的内心深处一直在警告你，你有可能会以最糟糕的方式遭殃，所以就有了lxml。

这是一个用lxml.etree来处理XML的教程，它简单的概述了ElementTree API的主要概念，同时有一些能让你的程序生涯更轻松的简单的提高。


首先是导入lxml.etree的方式:

fromlxmlimportetree

为了协助代码的可移植性，本教程中的例子很明显可以看出，一部分API是lxml.etree在ElementTree API（由Fredrik Lundh 的ElementTree库定义）的基础上的扩展。

Element是ElementTree API的主要容器类，大部分XML tree的功能都是通过这个类来实现的，Element的创建很容易：

root=etree.Element("root")

element的XML tag名通过tag属性来访问

>>>printroot.tag
root

许多Element被组织成一个XML树状结构，创建一个子element并添加进父element使用append方法：

>>>root.append(etree.Element("和耐child1"))

还有一个更简短更有效的方法：the SubElement，它的参数和element一样，但是需要父element作为第一个参数：

>>>child2=etree.SubElement(root,"child2")
>>>child3=etree.SubElement(root,"child3")

可以序列化你创建的树：

>>>print(etree.tostring(root,pretty_print=True))
<root>
<child1/>
<child2/>
<child3/>
</root>

为了更方便直胡棚野观的访问这些子节点，element模仿了正常的Python链：

>>>child=root[0]>>>print(child.tag)
child1
>>>print(len(root))
>>>root.index(root[1])#lxml.etreeonly!
>>>children=list(root)>>>forchildinroot:...print(child.tag)child1child2
child3
>>>root.insert(0,etree.Element("child0"))>>>start裤喊=root[:1]>>>end=root[-1:]>>>print(start[0].tag)child0>>>print(end[0].tag)child3

还可以根据element的真值看其是否有孩子节点：

ifroot:#thisnolongerworks!
print("Therootelementhaschildren")

用len(element)更直观，且不容易出错：

>>>print(etree.iselement(root))#testifit'ssomekindofElement
True
>>>iflen(root):#testifithaschildren
...print("Therootelementhaschildren")
Therootelementhaschildren

还有一个重要的特性，原文的句子只可意会，看例子应该是能看懂什么意思吧。

>>>forchildinroot:...print(child.tag)child0child1child2child3>>>root[0]=root[-1]#移动了element>>>forchildinroot:...print(child.tag)child3child1child2>>>l=[0,1,2,3]>>>l[0]=l[-1]>>>l[3,1,2,3]
>>>rootisroot[0].getparent()#lxml.etreeonly!.etree,'sstandardlibrary:>>>fromimportdeep>>>element=etree.Element("neu")>>>element.append(deep(root[1]))>>>print(element[0].tag)child1>>>print([c.tagforcinroot])['child3','child1','child2']

XML支持属性，创建方式如下：

>>>root=etree.Element("root",interesting="totally")
>>>etree.tostring(root)
b'<rootinteresting="totally"/>'

属性是无序的键值对，所以可以用element类似于字典接口的方式处理：

>>>print(root.get("interesting"))
totally
>>>print(root.get("hello"))
None
>>>root.set("hello","Huhu")
>>>print(root.get("hello"))
Huhu
>>>etree.tostring(root)
b'<rootinteresting="totally"hello="Huhu"/>'
>>>sorted(root.keys())
['hello','interesting']
>>>forname,valueinsorted(root.items()):
...print('%s=%r'%(name,value))
hello='Huhu'
interesting='totally'

如果需要获得一个类似dict的对象，可以使用attrib属性：

>>>attributes=root.attrib
>>>print(attributes["interesting"])
totally
>>>print(attributes.get("no-such-attribute"))
None
>>>attributes["hello"]="GutenTag"
>>>print(attributes["hello"])
GutenTag
>>>print(root.get("hello"))
GutenTag

既然attrib是element本身支持的类似dict的对象，这就意味着任何对element的改变都会影响attrib，反之亦然。这还意味着只要element的任何一个attrib还在使用，XML树就一直在内存中。通过如下方法，可以获得一个独立于XML树的attrib的快照：

>>>d=dict(root.attrib)
>>>sorted(d.items())
[('hello','GutenTag'),('interesting','totally')]

C. 后端编程Python3-数据库编程

对大多数软件开发者而言，术语数据库通常是指RDBMS（关系数据库管理系统）, 这些系统使用表格（类似于电子表格的网格），其中行表示记录，列表示记录的字段。表格及其中存放的数据是使用sql （结构化査询语言）编写的语句来创建并操纵的。Python提供了用于操纵SQL数据库的API（应用程序接口），通常与作为标准的SQLite 3数据库一起发布。

另一种数据库是DBM （数据库管理器），其中存放任意数量的键-值项。Python 的标准库提供了几种DBM的接口，包括某些特定于UNIX平台的。DBM的工作方式 与Python中的字典类似，区别在于DBM通常存放于磁盘上而不是内存中，并且其键与值总是bytes对象，并可能受到长度限制。本章第一节中讲解的shelve模块提供了方便的DBM接口，允许我们使用字符串作为键，使用任意（picklable）对象作为值。

如果可用的 DBM 与 SQLite 数据库不够充分，Python Package Index, pypi.python.org/pypi中提供了大量数据库相关的包，包括bsddb DBM ("Berkeley DB")，对象-关系映射器，比如SQLAlchemy （www.sqlalchemy.org）,以及流行的客户端/服务器数据的接口，比如 DB2、Informix、Ingres、MySQL、ODBC 以及 PostgreSQL。

本章中，我们将实现某程序的两个版本，该程序用于维护一个DVD列表，并追踪每个DVD的标题、发行年份、时间长度以及发行者。该程序的第一版使用DBM （通过shelve模块）存放其数据，第二版则使用SQLite数据库。两个程序都可以加载与保存简单的XML格式，这使得从某个程序导出DVD数据并将其导入到其他程序成为可能。与DBM版相比，基于SQL的程序提供了更多一些的功能，并且其数据设计也稍干净一些。

12.1 DBM数据库

shelve模块为DBM提供了一个wrapper,借助于此，我们在与DBM交互时，可以将其看做一个字典，这里是假定我们只使用字符串键与picklable值，实际处理时， shelve模块会将键与值转换为bytes对象(或者反过来)。

由于shelve模块使用的是底层的DBM,因此，如果其他计算机上没有同样的DBM,那么在某台计算机上保存的DBM文件在其他机器上无法读取是可能的。为解决这一问题，常见的解决方案是对那些必须在机器之间可传输的文件提供XML导入与导出功能，这也是我们在本节的DVD程序dvds-dbm.py中所做的。

对键，我们使用DVD的标题；对值，则使用元组，其中存放发行者、发行年份以及时间。借助于shelve模块，我们不需要进行任何数据转换，并可以把DBM对象当做一个字典进行处理。

程序在结构上类似于我们前面看到的那种菜单驱动型的程序，因此，这里主要展示的是与DBM程序设计相关的那部分。下面给出的是程序main()函数中的一部分， 忽略了其中菜单处理的部分代码。

db = None

try:

db = shelve.open(filename, protocol=pickle.HIGHEST_PROTOCOL)

finally:

if db is not None:

db.dose()

这里我们已打开(如果不存在就创建)指定的DBM文件，以便于对其进行读写操作。每一项的值使用指定的pickle协议保存为一个pickle,现有的项可以被读取， 即便是使用更底层的协议保存的，因为Python可以计算出用于读取pickle的正确协议。最后，DBM被关闭——其作用是清除DBM的内部缓存，并确保磁盘文件可以反映出已作的任何改变，此外，文件也需要关闭。

该程序提供了用于添加、编辑、列出、移除、导入、导出DVD数据的相应选项。除添加外，我们将忽略大部分用户接口代码，同样是因为已经在其他上下文中进行了展示。

def add_dvd(db):

title = Console.get_string("Title", "title")

if not title:

return

director = Console.get_string("Director", "director")

if not director:

return

year = Console.get_integer("Year", "year",minimum=1896,

maximum=datetime,date.today().year)

ration = Console.get_integer("Duration (minutes)", "minutes“, minimum=0, maximum=60*48)

db[title] = (director, year, ration)

db.sync()

像程序菜单调用的所有函数一样，这一函数也以DBM对象(db)作为其唯一参数。该函数的大部分工作都是获取DVD的详细资料，在倒数第二行，我们将键-值项存储在DBM文件中,DVD的标题作为键，发行者、年份以及时间(由shelve模块pickled在一起)作为值。

为与Python通常的一致性同步，DBM提供了与字典一样的API，因此，除了 shelve.open() 函数(前面已展示)与shelve.Shelf.sync()方法(该方法用于清除shelve的内部缓存，并对磁盘上文件的数据与所做的改变进行同步——这里就是添加一个新项)，我们不需要学习任何新语法。

def edit_dvd(db):

old_title = find_dvd(db, "edit")

if old_title is None:

return

title = Console.get.string("Title", "title", old_title)

if not title:

return

director, year, ration = db[old_title]

...

db[title]= (director, year, ration)

if title != old_title:

del db[old_title]

db.sync()

为对某个DVD进行编辑，用户必须首先选择要操作的DVD,也就是获取DVD 的标题，因为标题用作键，值则用于存放其他相关数据。由于必要的功能在其他场合 (比如移除DVD)也需要使用，因此我们将其实现在一个单独的find_dvd()函数中，稍后将査看该函数。如果找到了该DVD,我们就获取用户所做的改变，并使用现有值作为默认值，以便提高交互的速度。(对于这一函数，我们忽略了大部分用户接口代码， 因为其与添加DVD时几乎是相同的。)最后，我们保存数据，就像添加时所做的一样。如果标题未作改变，就重写相关联的值；如果标题已改变，就创建一个新的键-值对， 并且需要删除原始项。

def find_dvd(db, message):

message = "(Start of) title to " + message

while True:

matches =[]

start = Console.get_string(message, "title")

if not start:

return None

for title in db:

if title.lower().startswith(start.lower()):

matches.append(title)

if len(matches) == 0:

print("There are no dvds starting with", start)

continue

elif len(matches) == 1:

return matches[0]

elif len(matches) > DISPLAY_LIMIT:

print("Too many dvds start with {0}; try entering more of the title".format(start)

continue

else:

matches = sorted(matches, key=str.lower)

for i, match in enumerate(matches):

print("{0}: {1}".format(i+1, match))

which = Console.get_integer("Number (or 0 to cancel)",

"number", minimum=1, maximum=len(matches))

return matches[which - 1] if which != 0 else None

为尽可能快而容易地发现某个DVD,我们需要用户只输入其标题的一个或头几个字符。在具备了标题的起始字符后，我们在DBM中迭代并创建一个匹配列表。如果只有一个匹配项，就返回该项；如果有几个匹配项(但少于DISPLAY_LIMIT, 一个在程序中其他地方设置的整数)，就以大小写不敏感的顺序展示所有这些匹配项，并为每一项设置一个编号，以便用户可以只输入编号就可以选择某个标题。(Console.get_integer()函数可以接受0,即便最小值大于0,以便0可以用作一个删除值。通过使用参数allow_zero=False, 可以禁止这种行为。我们不能使用Enter键，也就是说，没有什么意味着取消，因为什么也不输入意味着接受默认值。)

def list_dvds(db):

start =”"

if len(db)> DISPLAY.LIMIT:

start = Console.get_string(“List those starting with [Enter=all]”， "start”)

print()

for title in sorted(db, key=str.lower):

if not start or title.Iower().startswith(start.lower()):

director, year, ration = db[title]

print("{title} ({year}) {ration} minute{0}, by "

"{director}".format(Util.s(ration),**locals()))

列出所有DVD (或者那些标题以某个子字符串引导)就是对DBM的所有项进行迭代。

Util.s()函数就是简单的s = lambda x: "" if x == 1 else "s",因此，如果时间长度不是1分钟，就返回"s"。

def remove_dvd(db):

title = find_dvd(db, "remove")

if title is None:

return

ans = Console.get_bool("Remove {0}?".format(title), "no")

if ans:

del db[title]

db.sync()

要移除一个DVD,首先需要找到用户要移除的DVD,并请求确认，获取后从DBM中删除该项即可。

到这里，我们展示了如何使用shelve模块打开(或创建)一个DBM文件，以及如何向其中添加项、编辑项、对其项进行迭代以及移除某个项。

遗憾的是，在我们的数据设计中存在一个瑕疵。发行者名称是重复的，这很容易导致不一致性，比如，发行者Danny DeVito可能被输入为"Danny De Vito",用于 一个电影；也可以输入为“Danny deVito",用于另一个。为解决这一问题，可以使用两个DBM文件，主DVD文件使用标题键与(年份，时间长度，发行者ID)值; 发行者文件使用发行者ID (整数)键与发行者名称值。下一节展示的SQL数据库 版程序将避免这一瑕疵，这是通过使用两个表格实现的，一个用于DVD,另一个用于发行者。

12.2 SQL数据库

大多数流行的SQL数据库的接口在第三方模块中是可用的，Python带有sqlite3 模块(以及SQLite 3数据库)，因此，在Python中，可以直接开始数据库程序设计。SQLite是一个轻量级的SQL数据库，缺少很多诸如PostgreSQL这种数据库的功能， 但非常便于构造原型系统，并且在很多情况下也是够用的。

为使后台数据库之间的切换尽可能容易，PEP 249 (Python Database API Specification v2.0)提供了称为DB-API 2.0的API规范。数据库接口应该遵循这一规范，比如sqlite3模块就遵循这一规范，但不是所有第三方模块都遵循。API规范中指定了两种主要的对象，即连接对象与游标对象。表12-1与表12-2中分别列出了这两种对象必须支持的API。在sqlite3模块中，除DB-API 2.0规范必需的之外，其连接对象与游标对象都提供了很多附加的属性与方法。

DVD程序的SQL版本为dvds.sql.py,该程序将发行者与DVD数据分开存储，以 避免重复，并提供一个新菜单，以供用户列出发行者。该程序使用的两个表格在图12-1

def connect(filename):

create= not os.path.exists(filename)

db = sqlite3.connect(filename)

if create:

cursor = db.cursor()

cursor.execute("CREATE TABLE directors ("

"id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, "

"name TEXT UNIQUE NOT NULL)")

cursor.execute("CREATE TABLE dvds ("

"id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, "

"title TEXT NOT NULL, "

"year INTEGER NOT NULL,"

"ration INTEGER NOT NULL, "

"director_id INTEGER NOT NULL, ”

"FOREIGN KEY (director_id) REFERENCES directors)")

db.commit()

return db

sqlite3.connect()函数会返回一个数据库对象，并打开其指定的数据库文件。如果该文件不存在，就创建一个空的数据库文件。鉴于此，在调用sqlite3.connect()之前，我们要注意数据库是否是准备从头开始创建，如果是，就必须创建该程序要使用的表格。所有査询都是通过一个数据库游标完成的，可以从数据库对象的cursor()方法获取。

注意，两个表格都是使用一个ID字段创建的，ID字段有一个AUTOINCREMENT 约束——这意味着SQLite会自动为ID字段赋予唯一性的数值，因此，在插入新记录时，我们可以将这些字段留给SQLite处理。

SQLite支持有限的数据类型——实际上就是布尔型、数值型与字符串——但使用数据'‘适配器”可以对其进行扩展，或者是扩展到预定义的数据类型(比如那些用于日期与datetimes的类型)，或者是用于表示任意数据类型的自定义类型。DVD程序并不需要这一功能，如果需要，sqlite3模块的文档提供了很多详细解释。我们使用的外部键语法可能与用于其他数据库的语法不同，并且在任何情况下，只是记录我们的意图，因为SQLite不像很多其他数据库那样需要强制关系完整性，sqlite3另一点与众不同的地方在于其默认行为是支持隐式的事务处理，因此，没有提供显式的“开始事务” 方法。

def add_dvd(db):

title = Console.get_string("Title", "title")

if not title:

return

director = Console.get_string("Director", "director")

if not director:

return

year = Console.get_integer("Year", "year”, minimum=1896,

maximum=datetime.date.today().year)

ration = Console.get_integer("Duration (minutes)", "minutes",

minimum=0,maximum=60*48)

director_id = get_and_set_director(db, director)

cursor = db.cursor()

cursor.execute("INSERT INTO dvds ”

"(title, year, ration, director_id)"

"VALUES (?, ?, ?, ?)",

(title, year, ration, director_id))

db.commit()

这一函数的开始代码与dvds-dbm.py程序中的对应函数一样，但在完成数据的收集后，与原来的函数有很大的差别。用户输入的发行者可能在也可能不在directors表格中，因此，我们有一个get_and_set_director()函数，在数据库中尚无某个发行者时， 该函数就将其插入到其中，无论哪种情况都返回就绪的发行者ID,以便在需要的时候插入到dvds表。在所有数据都可用后，我们执行一条SQL INSERT语句。我们不需要指定记录ID,因为SQLite会自动为我们提供。

在査询中，我们使用问号(？)作为占位符，每个?都由包含SQL语句的字符串后面的序列中的值替代。命名的占位符也可以使用，后面在编辑记录时我们将看到。尽管避免使用占位符(而只是简单地使用嵌入到其中的数据来格式化SQL字符串)也是可能的，我们建议总是使用占位符，并将数据项正确编码与转义的工作留给数据库模块来完成。使用占位符的另一个好处是可以提高安全性，因为这可以防止任意的SQL 被恶意地插入到一个査询中。

def get_and_set_director(db, director):

director_id = get_director_id(db, director)

if directorjd is not None:

return director_id

cursor = db.cursor()

cursor.execute("lNSERT INTO directors (name) VALUES (?)”,(director,))

db.commit()

return get_director_id(db, director)

这一函数返回给定发行者的ID,并在必要的时候插入新的发行者记录。如果某个记录被插入，我们首先尝试使用get_director_id()函数取回其ID。

def get_director_id(db, director):

cursor = db.cursor()

cursor.execute("SELECT id FROM directors WHERE name=?",(director,))

fields = cursor.fetchone()

return fields[0] if fields is not None else None

get_director_id()函数返回给定发行者的ID,如果数据库中没有指定的发行者，就返回None。我们使用fetchone()方法，因为或者有一个匹配的记录，或者没有。(我们知道，不会有重复的发行者，因为directors表格的名称字段有一个UNIQUE约束，在任何情况下，在添加一个新的发行者之前，我们总是先检査其是否存在。)这种取回方法总是返回一个字段序列(如果没有更多的记录，就返回None)。即便如此，这里我们只是请求返回一个单独的字段。

def edit_dvd(db):

title, identity = find_dvd(db, "edit")

if title is None:

return

title = Console.get_string("Title","title", title)

if not title:

return

cursor = db.cursor()

cursor.execute("SELECT dvds.year, dvds.ration, directors.name"

“FROM dvds, directors "

"WHERE dvds.director_id = directors.id AND "

"dvds.id=:id", dict(id=identity))

year, ration, director = cursor.fetchone()

director = Console.get_string("Director", "director", director)

if not director:

return

year = Console,get_integer("Year","year", year, 1896,datetime.date.today().year)

ration = Console.get_integer("Duration (minutes)", "minutes",

ration, minimum=0, maximum=60*48)

director_id = get_and_set_director(db, director)

cursor.execute("UPDATE dvds SET title=:title, year=:year,"

"ration=:ration, director_id=:directorjd "

"WHERE id=:identity", locals())

db.commit()

要编辑DVD记录，我们必须首先找到用户需要操纵的记录。如果找到了某个记录，我们就给用户修改其标题的机会，之后取回该记录的其他字段，以便将现有值作为默认值，将用户的输入工作最小化，用户只需要按Enter键就可以接受默认值。这里，我们使用了命名的占位符(形式为:name),并且必须使用映射来提供相应的值。对SELECT语句，我们使用一个新创建的字典；对UPDATE语句，我们使用的是由 locals()返回的字典。

我们可以同时为这两个语句都使用新字典，这种情况下，对UPDATE语句，我们可以传递 dict(title=title, year=year, ration=ration, director_id=director_id, id=identity))，而非 locals()。

在具备所有字段并且用户已经输入了需要做的改变之后，我们取回相应的发行者ID (如果必要就插入新的发行者记录)，之后使用新数据对数据库进行更新。我们采用了一种简化的方法，对记录的所有字段进行更新，而不仅仅是那些做了修改的字段。

在使用DBM文件时，DVD标题被用作键，因此，如果标题进行了修改，我们就需要创建一个新的键-值项，并删除原始项。不过，这里每个DVD记录都有一个唯一性的ID,该ID是记录初次插入时创建的，因此，我们只需要改变任何其他字段的值， 而不需要其他操作。

def find_dvd(db, message):

message = "(Start of) title to " + message

cursor = db.cursor()

while True: .

start = Console.get_stnng(message, "title")

if not start:

return (None, None)

cursor.execute("SELECT title, id FROM dvds "

"WHERE title LIKE ? ORDER BY title”，

(start +"%",))

records = cursor.fetchall()

if len(records) == 0:

print("There are no dvds starting with", start)

continue

elif len(records) == 1:

return records[0]

elif len(records) > DISPLAY_LIMIT:

print("Too many dvds ({0}) start with {1}; try entering "

"more of the title".format(len(records),start))

continue

else:

for i, record in enumerate(records):

print("{0}:{1}".format(i + 1, record[0]))

which = Console.get_integer("Number (or 0 to cancel)",

"number", minimum=1, maximum=len(records))

return records[which -1] if which != 0 else (None, None)

这一函数的功能与dvdsdbm.py程序中的find_dvd()函数相同，并返回一个二元组 (DVD标题，DVD ID)或(None, None),具体依赖于是否找到了某个记录。这里并不需要在所有数据上进行迭代，而是使用SQL通配符(%),因此只取回相关的记录。

由于我们希望匹配的记录数较小，因此我们一次性将其都取回到序列的序列中。如果有不止一个匹配的记录，但数量上又少到可以显示，我们就打印记录，并将每条记录附带一个数字编号，以便用户可以选择需要的记录，其方式与在dvds-dbm.py程序中所做的类似：

def list_dvds(db):

cursor = db.cursor()

sql = ("SELECT dvds.title, dvds.year, dvds.ration, "

"directors.name FROM dvds, directors "

"WHERE dvds.director_id = directors.id")

start = None

if dvd_count(db) > DISPLAY_LIMIT:

start = Console.get_string("List those starting with [Enter=all]", "start")

sql += " AND dvds.title LIKE ?"

sql += ” ORDER BY dvds.title"

print()

if start is None:

cursor.execute(sql)

else:

cursor.execute(sql, (start +"%",))

for record in cursor:

print("{0[0]} ({0[1]}) {0[2]} minutes, by {0[3]}".format(record))

要列出每个DVD的详细资料，我们执行一个SELECT査询。该査询连接两个表，如果记录(由dvd_count()函数返回)数量超过了显示限制值,就将第2个元素添加到WHERE 分支，之后执行该査询，并在结果上进行迭代。每个记录都是一个序列，其字段是与 SELECT査询相匹配的。

def dvd_count(db):

cursor = db.cursor()

cursor.execute("SELECT COUNT(*) FROM dvds")

return cursor.fetchone()[0]

我们将这几行代码放置在一个单独的函数中，因为我们在几个不同的函数中都需要使用这几行代码。

我们忽略了 list_directors()函数的代码，因为该函数在结构上与list_dvds()函数非常类似，只不过更简单一些，因为本函数只列出一个字段(name)。

def remove_dvd(db):

title, identity = find_dvd(db, "remove")

if title is None:

return

ans = Console.get_bool("Remove {0}?".format(title), "no")

if ans:

cursor = db.cursor()

cursor.execute("DELETE FROM dvds WHERE id=?", (identity,))

db.commit()

在用户需要删除一个记录时，将调用本函数，并且本函数与dvds-dbm.py程序中 相应的函数是非常类似的。

到此，我们完全查阅了 dvds-sql.py程序，并且了解了如何创建数据库表格、选取 记录、在选定的记录上进行迭代以及插入、更新与删除记录。使用execute()方法，我们可以执行底层数据库所支持的任意SQL语句。

SQLite提供了比我们这里使用的多得多的功能，包括自动提交模式（以及任意其他类型的事务控制），以及创建可以在SQL查询内执行的函数的能力。提供一个工厂函数并用于控制对每个取回的记录返回什么（比如，一个字典或自定义类型，而不是字段序列）也是可能的。此外，通过传递“:memory:”作为文件名，创建内存中的SQLite 数据库也是可能的。

以上内容部分摘自视频课程05后端编程Python22 数据库编程，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。

D. Python 常用的标准库以及第三方库有哪些

我也来几个吧
standard libs:

itertools http://docs.python.org/2/library/itertools.html

functools http://docs.python.org/2/library/functools.html 学好python有必要掌握上面这两个库吧，
re 正则
subprocess http://docs.python.org/2/library/subprocess.html 调用shell命令的神器
pdb 调试
traceback 调试
pprint 漂亮的输出
logging 日志
threading和multiprocessing 多线程
urllib/urllib2/httplib http库，httplib底层一点，推荐第三方的库requests
os/sys 系统，环境相关
Queue 队列
pickle/cPickle 序列化工具
hashlib md5, sha等hash算法
cvs
json/simplejson python的json库，据so上的讨论和benchmark，simplejson的性能要高于json
timeit 计算代码运行的时间等等
cProfile python性能测量模块
glob 类似与listfile，可以用来查找文件
atexit 有一个注册函数，可用于正好在脚本退出运行前执行一些代码
dis python 反汇编，当对某条语句不理解原理时，可以用dis.dis 函数来查看代码对应的python 解释器指令等等。

3th libs:

paramiko https://github.com/paramiko/paramiko ssh python 库
selenium https://pypi.python.org/pypi/selenium 浏览器自动化测试工具selenium的python 接口
lxml http://lxml.de/ python 解析html,xml 的神器
mechanize https://pypi.python.org/pypi/mechanize/ Stateful programmatic web browsing

pycurl https://pypi.python.org/pypi/pycurl cURL library mole for Python
Fabric http://docs.fabfile.org/en/1.8/
Fabric is a Python (2.5 or higher) library and command-line tool for
streamlining the use of SSH for application deployment or systems
administration tasks.

xmltodict https://github.com/martinblech/xmltodict xml 转 dict，真心好用
urllib3 和 requests: 当然其实requests就够了 Requests: HTTP for Humans
flask http://flask.pocoo.org/python web 微框架
ipdb 调试神器，同时推荐ipython！结合ipython使用
redis redis python接口
pymongo mongodbpython接口
PIL http://www.pythonware.com/procts/pil/ python图像处理
mako http://www.makotemplates.org/ python模版引擎
numpy ， scipy 科学计算
matplotlib 画图

scrapy 爬虫
django/tornado/web.py/web2py/uliweb/flask/twisted/bottle/cherrypy.等等 python web框架/服务器
sh 1.08 — sh v1.08 documentation 用来运行shell 模块的 极佳选择

暂时记得这么多吧，不过都是我自己常用的库 :) 。。欢迎补充

UPDATE:
A curated list of awesome Python frameworks, libraries and software.

vinta/awesome-python · GitHub

几乎所有很赞的 python 库，和框架都在这个列表里。

其他的 awesome list：
bayandin/awesome-awesomeness · GitHub

E. Python 常用的标准库以及第三方库有哪些

Python常用库大全，看看有没有你需要的。
环境管理
管理 Python 版本和环境的工具
p – 非常简单的交互式 python 版本管理工具。
pyenv – 简单的 Python 版本管理工具。
Vex – 可以在虚拟环境中执行命令。
virtualenv – 创建独立 Python 环境的工具。
virtualenvwrapper- virtualenv 的一组扩展。
包管理
管理包和依赖的工具。
pip – Python 包和依赖关系管理工具。
pip-tools – 保证 Python 包依赖关系更新的一组工具。
conda – 跨平台，Python 二进制包管理工具。
Curdling – 管理 Python 包的命令行工具。
wheel – Python 分发的新标准，意在取代 eggs。
包仓库
本地 PyPI 仓库服务和代理。
warehouse – 下一代 PyPI。
Warehousebandersnatch – PyPA 提供的 PyPI 镜像工具。
devpi – PyPI 服务和打包/测试/分发工具。
localshop – 本地 PyPI 服务（自定义包并且自动对 PyPI 镜像）。
分发
打包为可执行文件以便分发。
PyInstaller – 将 Python 程序转换成独立的执行文件（跨平台）。
dh-virtualenv – 构建并将 virtualenv 虚拟环境作为一个 Debian 包来发布。
Nuitka – 将脚本、孝高模块、包编译成可执行文件或扩展模块。
py2app – 将 Python 脚本变为独立软件包（Mac OS X）。
py2exe – 将 Python 脚本变为独立软件包（Windows）。
pynsist – 一个用来创建 Windows 安装程序的工具，可以在安装程序中打包 Python本身。
构建工具
将源码编译成软件。
buildout – 一个构建系统，从多个组件来创建，组装和部署应用。
BitBake – 针对嵌入式 Linux 的类似 make 的构建工具。
fabricate – 对任何语言自动找到依赖关系的构建工具。
PlatformIO – 多平台命令行构建工具。
PyBuilder – 纯 Python 实现的持续化构建工具。
SCons – 软件构建工具。
交互式解析器
交互式 Python 解析器。
IPython – 功能丰富的工具，非常有效的使用交互式 Python。
bpython- 界面丰富的 Python 解析器。
ptpython – 高级交互式Python解析器， 构建于python-prompt-toolkit 之上。
文件
文件管理和 MIME（多用途的网际邮件扩充协议）类型检测。
imghdr – （Python 标准库）检测图片类型。
mimetypes – （Python 标准库）将文件名映射为 MIME 类型。
path.py – 对 os.path 进行封装的模块。
pathlib – （Python3.4+ 标准库）跨平台的、面向对象的路径操作库。
python-magic- 文件类型检测的第三方库 libmagic 的 Python 接口。
Unipath- 用面向对象的方式操作文件和目录
watchdog – 管理文件系统事件的 API 和 shell 工具
日期和时间
操作日期和时间的类库。
arrow- 更好的 Python 日期时间操作类库。
Chronyk – Python 3 的类库，用于解析手写格式的时间和日期。
dateutil – Python datetime 模块的扩展。
delorean- 解肢携决 Python 中有关日期处理的棘手问题的库。
moment – 一个用来处理时间和日期的Python库。灵感来自于Moment.js。
PyTime – 一个简单易用的Python模历慎伏块，用于通过字符串来操作日期/时间。
pytz – 现代以及历史版本的世界时区定义。将时区数据库引入Python。
when.py – 提供用户友好的函数来帮助用户进行常用的日期和时间操作。
文本处理
用于解析和操作文本的库。
通用
chardet – 字符编码检测器，兼容 Python2 和 Python3。
difflib – (Python 标准库)帮助我们进行差异化比较。
ftfy – 让Unicode文本更完整更连贯。
fuzzywuzzy – 模糊字符串匹配。
Levenshtein – 快速计算编辑距离以及字符串的相似度。
pangu.py – 在中日韩语字符和数字字母之间添加空格。
pyfiglet -figlet 的 Python实现。
shortuuid – 一个生成器库，用以生成简洁的，明白的，URL 安全的 UUID。
unidecode – Unicode 文本的 ASCII 转换形式 。
uniout – 打印可读的字符，而不是转义的字符串。
xpinyin – 一个用于把汉字转换为拼音的库。

F. 用python怎么实现json和xml的互转

ajax是属于template里面的一个异步请求而已，如果你在views里面传回来是你说的“实体对像（models）”的话，我就有点搞不明白了。。。

不知道你在那个view方法直接return的是什么？
如果使用json处理对象的话请使用：
from django.http import HttpResponse
from models import mymodels

import simplejson

...
def ajax(request):
a = mymodels.objects.all()[0]
'''
此处假设a中有name、age参数
model对象是不能直接作为json可以处理,必须先转换为dict类型
'''
result = {}
result['name'] = a.name
result['age'] = a.age
result = simplejson.mps(result)
return HttpResponse(result)

此时用ajax访问这个试图返回的内容就是：

上面这种办法不是很好，建议先写一个template模板专门来显示此model内容。

假设模板ajax.html的内容为：
===================ajax.html===============
name: }<br />
age: }
=======================================

views视图如下:

from django.http import HttpResponse
from models import mymodels
from django.shortcuts import render_to_response

...
def ajax(request):
a = mymodels.objects.all()[0]
return render_to_response("ajax.html",)

此时用ajax访问这个视图返回的内容就是:

name: Jim Green
age: 14

以上的代码可能会有错误，因为是随手写的，希望能够帮到你

＝＝＝＝修改了一下＝＝＝＝
模板文件名打错了。。。
修改了一下就到了楼上的下面了，楼上你也太没水准了。直接复制

=====修改＝＝＝＝＝

使用model.__dict__属性可以获得字典，希望能帮到你
你的串号我已经记下，采纳后我会帮你制作

G. Python 适合大数据量的处理吗

python可以处理大数据，python处理大数据不一定是最优的选择。适合大数据处理。而不是大数据量处理。 如果大数据量处理，需要采用并用结构，比如在hadoop上使用python，或者是自己做的分布式处理框架。

python的优势不在于运行效率，而在于开发效率和高可维护性。针对特定的问题挑选合适的工具，本身也是一项技术能力。

Python处理数据的优势（不是处理大数据）：

1. 异常快捷的开发速度，代码量巨少

2. 丰富的数据处理包，不管正则也好，html解析啦，xml解析啦，用起来非常方便

3. 内部类型使用成本巨低，不需要额外怎么操作（java，c++用个map都很费劲）

4. 公司中，很大量的数据处理工作工作是不需要面对非常大的数据的

5. 巨大的数据不是语言所能解决的，需要处理数据的框架（hadoop， mpi）虽然小众，但是python还是有处理大数据的框架的，或者一些框架也支持python。

(7)pythondictxml扩展阅读：

Python处理数据缺点：

Python处理大数据的劣势：

1、python线程有gil，通俗说就是多线程的时候只能在一个核上跑，浪费了多核服务器。在一种常见的场景下是要命的：并发单元之间有巨大的数据共享或者共用（例如大dict）。

多进程会导致内存吃紧，多线程则解决不了数据共享的问题，单独的写一个进程之间负责维护读写这个数据不仅效率不高而且麻烦

2、python执行效率不高，在处理大数据的时候，效率不高，这是真的，pypy（一个jit的python解释器，可以理解成脚本语言加速执行的东西）能够提高很大的速度，但是pypy不支持很多python经典的包，例如numpy。

3. 绝大部分的大公司，用java处理大数据不管是环境也好，积累也好，都会好很多。

参考资料来源：网络-Python

H. 如何安装python中的parsel

python-parsel

Parsel是一个使用XPath和CSS选择器（可选地与正则表达式结合）从HTML和XML提取数据的库

一、安装

官网：https://pypi.org/project/parsel/

pip安装：pip install parsel 默认安装的是最新版

pip install parsel=1.6.0 目前官方最新版本

PyCharm：File =》Setting =》Project：sintemple =》 Project：Interpreter =》点击右上角的加号（或者按快捷键Alt+Insert）=》在输入框中输入parsel，会出现一个只有parsel的一列，点击选择它 =》Install Package 等待安装完成就可以了（注：其中Specify version选中可以在下拉框中选择版本）

————————————————

三、csstranslator

TranslatorMixin

This mixin adds support to CSS pseudo elements via dynamic dispatch.Currently supported pseudo-elements are ::text and ::attr(ATTR_NAME).

①. xpath_attr_functional_pseudo_element(xpath, function)

Support selecting attribute values using ::attr() pseudo-element

②. xpath_element(selector)

③. xpath_pseudo_element(xpath, pseudo_element)

Dispatch method that transforms XPath to support pseudo-element

④. xpath_text_simple_pseudo_element(xpath)

Support selecting text nodes using ::text pseudo-element

XPathExpr(path=’’, element=’*’, condition=’’, star_prefix=False)

GenericTranslator

HTMLTranslator(xhtml=False)

四、utils

extract_regex(regex, text, replace_entities=True)

Extract a list of unicode strings from the given text/encoding using the following policies: * if the regex contains a named group called “extract” that will be returned * if the regex contains multiple numbered groups, all those will be returned (flattened) * if the regex doesn’t contain any group the entire regex matching is returned

flatten(sequence) → list

Returns a single, flat list which contains all elements retrieved from the sequence and all recursively contained sub-sequences (iterables). Examples: >>> [1, 2, [3,4], (5,6)] [1, 2, [3, 4], (5, 6)] >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, (8,9,10)]) [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10] >>> flatten([“foo”, “bar”]) [‘foo’, ‘bar’] >>> flatten([“foo”, [“baz”, 42], “bar”]) [‘foo’, ‘baz’, 42, ‘bar’]

iflatten(sequence) → Iterator

Similar to .flatten(), but returns iterator instead

shorten(text, width, suffix=’…’)

Truncate the given text to fit in the given width.

————————————————

原文链接：网页链接

I. 为什么在python中是ioc / di不常见

1. 其实我不认为直接投资/ IoC是在Python。什么是却是直接投资/ IoC。
想想看：什么是一个DI容器呢？它可以让你
连线连成应用程序...
...在
我们有“接线合”及“
脚本
动态
所以，一个DI容器不过是一个解释的动态脚本语言。实际上，另一种方式是：一个典型的Java / .NET的DI容器不过是一个蹩脚的解释器一个非常糟糕的动态脚本语言与对接丑陋，往往基于XML的语法。
当你在Python程序，你为什么会想要一个丑陋的，坏的脚本语言，当你有一个美丽的 CodeGo.net，辉煌的脚本语言在您的处置？其实，这是一个更普遍的问题：当您在几乎任何语言进行编程，为什么你想，当你有Jython和IronPython的在您的处置一个丑陋的，坏的脚本语言？
因此，要概括一下：DI / IOC的做法是一样重要的在Python中，因为它是在Java中，对于完全相同的原因。该DI / IOC的但是，是建立在语言和经常如此轻巧的消失。 （这里有一个比喻：在组装，子程序调用是一个相当大的交易-你要保存你的局部变量和寄存器保存返回地址的指令指针更改为你所呼叫的子程序，安排它跳回你的子程序当它完成时，把那里的被叫方可以找到他们，等IOW：在组装，“子程序调用”是一种设计模式，和之前有类似的Fortran语言，其中有建于子程序调用，人们建立自己的自己的“子程序你会说，子程序调用是”在Python中，只是你不'子程序
BTW：对于什么样子采取DI其逻辑的例子来看看吉rad的Bracha的新话编程语言以及他的着作的主题：
构造函数是有害的
注入死刑
禁止对导入（续）
2.
部分原因是模块系统工作在Python的方式。你可以得到一种“单身”free的，只是从一个模块中导入它。定义一个对象的实际实例中的一个模块，然后任何客户端端代码可以导入并真正得到一个工作，全面构建/填充对象。
这是相对于Java的，在那里你不导入对象的实际情况。你总是有自己实例化它们，（排序的IoC / DI样式的方法）。您可以减轻不必自己所拥有的静态（或实际工厂类）实例化一切的trouble，但你仍然招致实际创建新的每项资源开销
3.
使得Django的控制反转的。例如，数据库服务器被选中的配置文件，然后提供相应的数据库封装实例的数据库客户端端。
不同的是，Python有一流的类型。数据类型，包括类，都是自己的对象。如果你想要一个特定的类，只是这个类。例如：
if config_dbms_name == 'postgresql':
import psycopg
self.database_interface = psycopg
elif config_dbms_name == 'mysql':
...

再后来的代码可以通过书面表单创建一个数据库接口：
my_db_connection = self.database_interface()
# Do stuff with database.

取而代之的样板工厂的函数，Java和C ++的需要，Python做它与普通的代码一行或两行。这是函数性命令式编程的力量。
4.
在我看来，这样的事情依赖注入是一个刚性的，当代码过于沉重的主体轻易改变，你会发现自己不得不挑了小部分，定义接口为他们，然后让人们改变行为症状通过该插入这些接口的对象。这一切都很好，但最好避免在首位那种。
这也是一个静态类型语言的症状。当你要表达抽象的唯一工具是继承，那么这就是几乎什么无处不在。话虽如此，C ++是非常类似的，但从来没有拿起迷恋建设者和接口无处不在的Java开发人员做了。这是很容易得到过度旺盛能够以灵活且可扩展的，很少真正的好处写了太多的通用代码的成本的梦想。我认为这是一个文化的东西。
通常情况下，我认为Python的人来选择合适的工具来完成工作，这是一个连贯的和简单的整体，而不是一个真正的工具（一个可能的插件），可以做什么，但提供了可能的配置排列让人眼花缭乱。还是有可互换的零件在必要时，但不需要定义固定接口，由于鸭打字和语言的相对简单的灵活性大表单主义。
5.
避风港'的Python在好几年，但我会说，它更多的是与它是一个动态类型的语言比什么都重要。举个简单的例子，在Java中，如果我想测试写信给标准输出适当地我DI和传递任何的PrintStream捕捉写入的文字并进行验证。当我在Ruby中我的工作，但是，我可以动态替换“看跌期权”的方法在标准输出做验证，留出来的图片。如果我创建一个抽象的唯一原因是测试类，“它（认为文件系统操作或Java中的时钟），那么直接投资/ IoC创建的解决方案。
6.
我回来“约尔格・W米塔格”回答：“DI / IOC的Python是如此轻巧的消失”。
要备份此看一看在Martin Fowler的例子移植从Java到Python：Python的：Design_Patterns：Inversion_of_Control
正如您可以从上面的链接，一个“容器”在Python中看到可以写成8行代码：
class Container:
def __init__(self, system_data):
for component_name, component_class, component_args in system_data:
if type(component_class) == types.ClassType:
args = [self.__dict__[arg] for arg in component_args]
self.__dict__[component_name] = component_class(*args)
else:
self.__dict__[component_name] = component_class

7.
IoC和ruby，这是我的想法，为什么它没有被广泛流传
更新：
我不支持那个网站了，链接不工作，但可以在这里阅读
8.
其实，这是很容易写出足够干净的代码与DI（我不知道，会不会被/ Python的停留，然后，但无论如何:)），例如我其实perefer这样编码：
def polite(name_str):
return "dear " + name_str
def rude(a):
return name_str + ", you, moron"
def greet(name_str, call=polite):
print "Hello, " + call(name_str) + "!"

_
>>greet("Peter")
Hello, dear Peter!
>>greet("Jack", rude)
Hello, Jack, you, moron!

是的，这可以看作是函数/类只是一个简单的表单，但它确实工作。所以，也许Python的默认附带的电池足够在这里了。
P.S.我也贴这种幼稚的做法一个更大的示例在动态评估在Python简单的布尔逻辑。