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簡單的布爾邏輯。