syncpython

A. python里，怎麼才能刷新一個tcp socket的緩沖區,類似於文件的fflush效果

1. 試試 sync 命令。
sync writes any data buffered in memory out to disk.
但不清楚是不是將緩沖區給清空了。

2. sync不行的話用 awk 吧，awk里的語法同C語言，可以直接使用C語句。
echo "" | awk '{fflush()}'

B. 深入解析Python中的線程同步方法

深入解析Python中的線程同步方法
同步訪問共享資源
在使用線程的時候，一個很重要的問題是要避免多個線程對同一變數或其它資源的訪問沖突。一旦你稍不留神，重疊訪問、在多個線程中修改（共享資源）等這些操作會導致各種各樣的問題；更嚴重的是，這些問題一般只會在比較極端（比如高並發、生產伺服器、甚至在性能更好的硬體設備上）的情況下才會出現。
比如有這樣一個情況：需要追蹤對一事件處理的次數
counter = 0

def process_item(item):
global counter
... do something with item ...
counter += 1
如果你在多個線程中同時調用這個函數，你會發現counter的值不是那麼准確。在大多數情況下它是對的，但有時它會比實際的少幾個。
出現這種情況的原因是，計數增加操作實際上分三步執行:
解釋器獲取counter的當前值計算新值將計算的新值回寫counter變數
考慮一下這種情況：在當前線程獲取到counter值後，另一個線程搶佔到了CPU，然後同樣也獲取到了counter值，並進一步將counter值重新計算並完成回寫；之後時間片重新輪到當前線程（這里僅作標識區分，並非實際當前），此時當前線程獲取到counter值還是原來的，完成後續兩步操作後counter的值實際只加上1。
另一種常見情況是訪問不完整或不一致狀態。這類情況主要發生在一個線程正在初始化或更新數據時，另一個進程卻嘗試讀取正在更改的數據。
原子操作
實現對共享變數或其它資源的同步訪問最簡單的方法是依靠解釋器的原子操作。原子操作是在一步完成執行的操作，在這一步中其它線程無法獲得該共享資源。
通常情況下，這種同步方法只對那些只由單個核心數據類型組成的共享資源有效，譬如，字元串變數、數字、列表或者字典等。下面是幾個線程安全的操作：
讀或者替換一個實例屬性讀或者替換一個全局變數從列表中獲取一項元素原位修改一個列表（例如：使用append增加一個列表項）從字典中獲取一項元素原位修改一個字典（例如：增加一個字典項、調用clear方法）
注意，上面提到過，對一個變數或者屬性進行讀操作，然後修改它，最終將其回寫不是線程安全的。因為另外一個線程會在這個線程讀完卻沒有修改或回寫完成之前更改這個共享變數/屬性。
鎖
鎖是Python的threading模塊提供的最基本的同步機制。在任一時刻，一個鎖對象可能被一個線程獲取，或者不被任何線程獲取。如果一個線程嘗試去獲取一個已經被另一個線程獲取到的鎖對象，那麼這個想要獲取鎖對象的線程只能暫時終止執行直到鎖對象被另一個線程釋放掉。
鎖通常被用來實現對共享資源的同步訪問。為每一個共享資源創建一個Lock對象，當你需要訪問該資源時，調用acquire方法來獲取鎖對象（如果其它線程已經獲得了該鎖，則當前線程需等待其被釋放），待資源訪問完後，再調用release方法釋放鎖：
lock = Lock()

lock.acquire() #: will block if lock is already held
... access shared resource
lock.release()

注意，即使在訪問共享資源的過程中出錯了也應該釋放鎖，可以用try-finally來達到這一目的：
lock.acquire()
try:
... access shared resource
finally:
lock.release() #: release lock, no matter what

在Python 2.5及以後的版本中，你可以使用with語句。在使用鎖的時候，with語句會在進入語句塊之前自動的獲取到該鎖對象，然後在語句塊執行完成後自動釋放掉鎖：
from __future__ import with_statement #: 2.5 only

with lock:
... access shared resource

acquire方法帶一個可選的等待標識，它可用於設定當有其它線程佔有鎖時是否阻塞。如果你將其值設為False，那麼acquire方法將不再阻塞，只是如果該鎖被佔有時它會返回False:
if not lock.acquire(False):
... 鎖資源失敗
else:
try:
... access shared resource
finally:
lock.release()

你可以使用locked方法來檢查一個鎖對象是否已被獲取，注意不能用該方法來判斷調用acquire方法時是否會阻塞，因為在locked方法調用完成到下一條語句（比如acquire）執行之間該鎖有可能被其它線程佔有。
if not lock.locked():
#: 其它線程可能在下一條語句執行之前佔有了該鎖
lock.acquire() #: 可能會阻塞

簡單鎖的缺點
標準的鎖對象並不關心當前是哪個線程佔有了該鎖；如果該鎖已經被佔有了，那麼任何其它嘗試獲取該鎖的線程都會被阻塞，即使是佔有鎖的這個線程。考慮一下下面這個例子：
lock = threading.Lock()

def get_first_part():
lock.acquire()
try:
... 從共享對象中獲取第一部分數據
finally:
lock.release()
return data

def get_second_part():
lock.acquire()
try:
... 從共享對象中獲取第二部分數據
finally:
lock.release()
return data

示例中，我們有一個共享資源，有兩個分別取這個共享資源第一部分和第二部分的函數。兩個訪問函數都使用了鎖來確保在獲取數據時沒有其它線程修改對應的共享數據。
現在，如果我們想添加第三個函數來獲取兩個部分的數據，我們將會陷入泥潭。一個簡單的方法是依次調用這兩個函數，然後返回結合的結果：

def get_both_parts():
first = get_first_part()
seconde = get_second_part()
return first, second

這里的問題是，如有某個線程在兩個函數調用之間修改了共享資源，那麼我們最終會得到不一致的數據。最明顯的解決方法是在這個函數中也使用lock:
def get_both_parts():
lock.acquire()
try:
first = get_first_part()
seconde = get_second_part()
finally:
lock.release()
return first, second

然而，這是不可行的。裡面的兩個訪問函數將會阻塞，因為外層語句已經佔有了該鎖。為了解決這個問題，你可以通過使用標記在訪問函數中讓外層語句釋放鎖，但這樣容易失去控制並導致出錯。幸運的是，threading模塊包含了一個更加實用的鎖實現：re-entrant鎖。
Re-Entrant Locks (RLock)

RLock類是簡單鎖的另一個版本，它的特點在於，同一個鎖對象只有在被其它的線程佔有時嘗試獲取才會發生阻塞；而簡單鎖在同一個線程中同時只能被佔有一次。如果當前線程已經佔有了某個RLock鎖對象，那麼當前線程仍能再次獲取到該RLock鎖對象。
lock = threading.Lock()
lock.acquire()
lock.acquire() #: 這里將會阻塞

lock = threading.RLock()
lock.acquire()
lock.acquire() #: 這里不會發生阻塞

RLock的主要作用是解決嵌套訪問共享資源的問題，就像前面描述的示例。要想解決前面示例中的問題，我們只需要將Lock換為RLock對象，這樣嵌套調用也會OK.
lock = threading.RLock()

def get_first_part():
... see above

def get_second_part():
... see above

def get_both_parts():
... see above

這樣既可以單獨訪問兩部分數據也可以一次訪問兩部分數據而不會被鎖阻塞或者獲得不一致的數據。
注意RLock會追蹤遞歸層級，因此記得在acquire後進行release操作。
Semaphores

信號量是一個更高級的鎖機制。信號量內部有一個計數器而不像鎖對象內部有鎖標識，而且只有當佔用信號量的線程數超過信號量時線程才阻塞。這允許了多個線程可以同時訪問相同的代碼區。
semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter減小

... 訪問共享資源
semaphore.release() #: counter增大

當信號量被獲取的時候，計數器減小；當信號量被釋放的時候，計數器增大。當獲取信號量的時候，如果計數器值為0，則該進程將阻塞。當某一信號量被釋放，counter值增加為1時，被阻塞的線程（如果有的話）中會有一個得以繼續運行。
信號量通常被用來限制對容量有限的資源的訪問，比如一個網路連接或者資料庫伺服器。在這類場景中，只需要將計數器初始化為最大值，信號量的實現將為你完成剩下的事情。
max_connections = 10

semaphore = threading.BoundedSemaphore(max_connections)

如果你不傳任何初始化參數，計數器的值會被初始化為1.
Python的threading模塊提供了兩種信號量實現。Semaphore類提供了一個無限大小的信號量，你可以調用release任意次來增大計數器的值。為了避免錯誤出現，最好使用BoundedSemaphore類，這樣當你調用release的次數大於acquire次數時程序會出錯提醒。
線程同步

鎖可以用在線程間的同步上。threading模塊包含了一些用於線程間同步的類。
Events

一個事件是一個簡單的同步對象，事件表示為一個內部標識(internal flag)，線程等待這個標識被其它線程設定，或者自己設定、清除這個標識。
event = threading.Event()

#: 一個客戶端線程等待flag被設定
event.wait()

#: 服務端線程設置或者清除flag
event.set()
event.clear()

一旦標識被設定，wait方法就不做任何處理（不會阻塞），當標識被清除時，wait將被阻塞直至其被重新設定。任意數量的線程可能會等待同一個事件。
Conditions

條件是事件對象的高級版本。條件表現為程序中的某種狀態改變，線程可以等待給定條件或者條件發生的信號。
下面是一個簡單的生產者/消費者實例。首先你需要創建一個條件對象：

#: 表示一個資源的附屬項
condition = threading.Condition()
生產者線程在通知消費者線程有新生成資源之前需要獲得條件：
#: 生產者線程
... 生產資源項
condition.acquire()
... 將資源項添加到資源中
condition.notify() #: 發出有可用資源的信號
condition.release()
消費者必須獲取條件（以及相關聯的鎖），然後嘗試從資源中獲取資源項：
#: 消費者線程
condition.acquire()
while True:
...從資源中獲取資源項
if item:
break
condition.wait() #: 休眠，直至有新的資源
condition.release()
... 處理資源

wait方法釋放了鎖，然後將當前線程阻塞，直到有其它線程調用了同一條件對象的notify或者notifyAll方法，然後又重新拿到鎖。如果同時有多個線程在等待，那麼notify方法只會喚醒其中的一個線程，而notifyAll則會喚醒全部線程。
為了避免在wait方法處阻塞，你可以傳入一個超時參數，一個以秒為單位的浮點數。如果設置了超時參數，wait將會在指定時間返回，即使notify沒被調用。一旦使用了超時，你必須檢查資源來確定發生了什麼。
注意，條件對象關聯著一個鎖，你必須在訪問條件之前獲取這個鎖；同樣的，你必須在完成對條件的訪問時釋放這個鎖。在生產代碼中，你應該使用try-finally或者with.
可以通過將鎖對象作為條件構造函數的參數來讓條件關聯一個已經存在的鎖，這可以實現多個條件公用一個資源：
lock = threading.RLock()
condition_1 = threading.Condition(lock)
condition_2 = threading.Condition(lock)

互斥鎖同步
我們先來看一個例子：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, threading

# 假定這是你的銀行存款:
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 先存後取，結果應該為0:
global balance
balance = balance + n
balance = balance - n

def run_thread(n):
# 循環次數一旦多起來，最後的數字就變成非0
for i in range(100000):
change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t3 = threading.Thread(target=run_thread, args=(9,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print balance

結果 :

[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
61
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
24

上面的例子引出了多線程編程的最常見問題：數據共享。當多個線程都修改某一個共享數據的時候，需要進行同步控制。
線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個線程要更改共享數據時，先將其鎖定，此時資源的狀態為「鎖定」，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成「非鎖定」，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。

threading模塊中定義了Lock類，可以方便的處理鎖定：
#創建鎖mutex = threading.Lock()
#鎖定mutex.acquire([timeout])
#釋放mutex.release()

其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在超時後通過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。
使用互斥鎖實現上面的例子的代碼如下：
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 獲取鎖，確保只有一個線程操作這個數
muxlock.acquire()
global balance
balance = balance + n
balance = balance - n
# 釋放鎖，給其他被阻塞的線程繼續操作
muxlock.release()

def run_thread(n):
for i in range(10000):
change_it(n)

加鎖後的結果，就能確保數據正確：
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0

C. Python 之測試環境db自動同步

多套測試環境，如何做基線的資料庫級別的同步更新？

工作中測試環境有多套時，為保證基礎環境配置的一致性，就需要所有測試環境的資料庫結構保持一致。

例如：A需求在 beta1 環境進行測試，且A需求提測單中有新增表的 sql，B需求在 beta2 環境進行測試，由於A需求比B需求先發布上線，此時在B需求測試過程中發布時需要將主幹的代碼合並到當前需求分支(集成測試的需要，可以提前檢測出已上線的需求是否對當前在測的需求有影響)，代碼合並後對應的相關配置也得跟上，否則程序運行時會報錯，所以就需要在 beta2 環境更新 beta1 環境A需求新增表的sql。

因為每一次的發布上線都會做資料庫級別的同步更新，如果只是兩、三個測試環境，使用人工來手動更新也是可以的，如果測試環境多且資料庫更新的內容量大，依然使用人工手動更新，效率就會十分低下，同時也會造成一些人為操作的錯誤。這時自動化同步更新資料庫就顯得猶為重要了。在效率和正確率上都是完勝手工更新的。

由代碼實現部分可以看出，有了這個自動同步的自動化腳本，在資料庫更新時，只需要傳入更新的 sql 語句就可一鍵自動同步多套測試環境的資料庫信息了，十分高效。

D. python 同步和非同步的區別

可以使用切片獲取部分數據；
元組的值一旦設置：
{}表示字典，[]是數組，()是元組；
數組的值可以改變區別如下，不可更改，不可使用切片

E. python - Poetry介紹

一、簡介
Poetry 是一個Python 中的好用的包管理工具。在 Python 中，打包系統和依賴管理非常復雜：一個項目經常要同時創建多個文件，例如：

setup.py
requirements.txt
setup.cfg
MANIFEST.in
Pipfile
基於此， poetry 將所有的配置都放置在一個 toml 文件中，包括：依賴管理、構建、打包、發布等，可謂是簡單方便。

二、安裝
Poetry 要求 Python 版本為 2.7 或者 3.5+。Poetry 官方提供了一個腳本，可以快速方便地進行安裝。

osx / linux / bashonwindows 安裝：

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/install-poetry.py | python -
windows powershell 安裝：

(Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/install-poetry.py -UseBasicParsing).Content | python -
Poetry 會被安裝在系統中的如下位置：

$HOME/.local/bin Unix系統
%APPDATA%PythonScripts Windows系統
然後把路徑添加到系統變數 PATH 中，即可使用 poetry 命令調用：

poetry --version

卸載：

python install-poetry.py --uninstall
POETRY_UNINSTALL=1 python install-poetry.py
如果你想要改變安裝的默認路徑，可以設置 POETRY_HOME ：

POETRY_HOME=/etc/poetry python install-poetry.py
除了官方的安裝腳本，也可以使用 pipx 或者 pip 進行安裝：

pipx install poetry
pipx upgrade poetry
pipx uninstall poetry
pip install --user poetry

更新：

poetry self update

三、基礎使用
在已有項目中執行：

poetry init
該命令創建了一個pyproject.toml 文件。你可以手動修改 pyproject.toml 文件添加依賴，然後運行：

poetry install
也可以執行 add 命令安裝具體某個模塊並自動添加到 pyproject.toml：

$ poetry add xxxx
默認情況下，poetry會在 {cache-dir}/virtualenvs 下創建虛擬環境，你也可以手動修改該配置項，或者在 pyproject.toml 配置[virtualenvs.in-project] 在你的項目目錄中創建虛擬環境。

你可以使用 run 命令在虛擬環境中運行腳本：

poetry run python your_script.py
或者直接激活你的虛擬環境，新建一個 shell 運行：

poetry shell
只安裝dependencies ：

poetry install --no-root
更新所有鎖定版本的依賴：

poetry update

四、命令選項
全局選項：

--verbose (-v|vv|vvv): "-v" 正常輸出, "-vv" 詳細輸出 "-vvv" debug
--help (-h) : 幫助信息
--quiet (-q) : 不輸出任何信息
--ansi: 強制 ANSI 輸出
--no-ansi: 禁止ANSI 輸出
--version (-V): 顯示版本
--no-interaction (-n): 禁止交互詢問

NEW：

poetry new my-package
創建項目模板，項目結構如下所示：

my-package
├── pyproject.toml
├── README.md
├── my_package
│ └── init .py
└── tests
└── init .py

init：創建pyproject.toml文件 。

install：讀取pyproject.toml並安裝依賴，它具有如下這些選項：

--without: 忽略依賴
--with: 安裝可選的依賴
--only: 只安裝指定的依賴
--default: 只安裝默認的依賴
--sync: 同步鎖定的版本至環境中
--no-root: 不安裝根依賴包
--dry-run: 輸出操作但不執行
--extras (-E): 安裝額外的包

update：升級包

poetry update
不指定任何包時，更新所有，也可以指定升級包：

poetry update requests toml
它具有如下選項：

--dry-run : 輸出操作但不執行
--no-dev : 不按照開發依賴
--lock : 只更新鎖定不安裝

add： 添加依賴並安裝

限制范圍：

poetry add penlum@^2.0.5
poetry add "penlum>=2.0.5"
它具有如下選項：

--group (-D): 分組
--editable (-e): 添加到編輯模式
--extras (-E): 添加額外的依賴
--optional: 添加至可選依賴
--python: 指定python版本
--platform: 指定操作系統
--source: 使用源名稱安裝
---allow-prereleases: 接受 prereleases 安裝
--dry-run: 輸出操作但不執行
--lock: 只更新鎖定不安裝

remove：移除依賴

它具有如下選項：

--group (-D): 分組
--dry-run : 輸出操作但不執行

show：列出所有的可安裝的包

如果你想看具體某個包的信息：

poetry show penlum

name : penlum
version : 1.4.2
description : Python datetimes made easy

dependencies:

--without: 忽略依賴
--with: 同時顯示
--only: 只顯示指定的依賴
--default: 只顯示默認的
--no-dev: 不顯示開發的依賴
--tree: 以樹狀形式顯示
--latest (-l): 展示最新的版本
--outdated (-o): 顯示最新版本，但僅適用於過時的軟體包

build：構建

publish：發布

config：配置項

使用方法：

poetry config [options] [setting-key] [setting-value1] ... [setting-valueN]
它具有如下選項：

--unset: 刪除配置項
--list: 展示現在的配置

run：在虛擬環境中執行命令

shell：激活虛擬環境

check：檢查pyproject.toml文件

search：搜索遠程包

lock：鎖定版本

version：顯示版本

export：導出鎖定的文件為其他的格式

poetry export -f requirements.txt --output requirements.txt
它具有如下選項：

--format (-f): 轉換的格式，暫時只支持requirements.txt
--output (-o): 輸出文件名字
--dev: 包括開發的依賴
--extras (-E): 額外的依賴
--without-hashes: 忽略哈希
--with-credentials: 包括合格證書

env：與虛擬環境進行交互

cache：緩存

顯示緩存列表：

poetry cache list
清除緩存：

poetry cache clear pypi --all

plugin：插件

安裝插件：

poetry plugin add poetry-plugin
顯示插件列表：

poetry plugin show
移除插件：

poetry plugin remove poetry-plugin

source： 倉庫源

添加源：

poetry source add pypi-test https://test.pypi.org/simple/
顯示倉庫源列表：

poetry source show
移除：

poetry source remove pypi-test

五、配置
你可以運行config命令進行配置，或者直接修改config.toml文件，這個文件通常位於：

macOS: ~/Library/Application Support/pypoetry
Windows: C:Users<username>AppDataRoamingpypoetry
Unix~/.config/pypoetry
可以使用--local命令對具體項目進行配置：

poetry config virtualenvs.create false --local
配置項：

cache-dir緩存目錄
installer.parallel並行安裝
virtualenvs.create如果不存在，則新建一個虛擬環境
virtualenvs.in-project在項目根目錄創建虛擬環境
virtualenvs.path虛擬環境路徑
virtualenvs.options.always-復制源文件還是創建鏈接到虛擬環境
virtualenvs.options.system-site-packages虛擬環境獲得系統包的許可權
repositories.<name>設置一個新的可選倉庫

六、依賴配置
依賴的配置有很多種寫法：

版本限制：

尖括弧：^1.2 代表 >=1.2.0 <2.0.0
波浪號：~1.2.3 代表 >=1.2.3 <1.3.0
星號：1.* 代表 >=1.0.0 <2.0.0

使用git倉庫：

[tool.poetry.dependencies]
requests = { git = " https://github.com/requests/requests.git " }
使用本地路徑：

[tool.poetry.dependencies]

my-package = { path = "../my-package/", develop = false }

my-package = { path = "../my-package/dist/my-package-0.1.0.tar.gz" }
使用URL：

[tool.poetry.dependencies]

my-package = { url = " https://example.com/my-package-0.1.0.tar.gz " }
python限制：

[tool.poetry.dependencies]
pathlib2 = { version = "^2.2", python = "~2.7" }
環境限制：

[tool.poetry.dependencies]
pathlib2 = { version = "^2.2", markers = "python_version ~= ƈ.7' or sys_platform == 'win32'" }

組合：

[tool.poetry.dependencies]
foo = [
{version = "<=1.9", python = "^2.7"},
{version = "^2.0", python = "^3.4"}
]

如果限制很多，寫成一行不方便閱讀，可以寫成多行：

[tool.poetry.group.dev.dependencies]
black = {version = "19.10b0", allow-prereleases = true, python = "^3.6", markers = "platform_python_implementation == 'CPython'"}
寫成多行後：

[tool.poetry.group.dev.dependencies.black]
version = "19.10b0"
allow-prereleases = true
python = "^3.6"
markers = "platform_python_implementation == 'CPython'"

分組功能：

[tool.poetry.group.test.dependencies]
pytest = "^6.0.0"
pytest-mock = "*"
例如以上，就建立了一個test的組合的依賴。

下面這兩種寫法是等價的：

[tool.poetry.dev-dependencies]
pytest = "^6.0.0"
pytest-mock = "*"
或者：

[tool.poetry.group.dev.dependencies]
pytest = "^6.0.0"
pytest-mock = "*"
以上兩種寫法都聲明了一個dev的組的依賴。

聲明組合是可選的，這在具體的環境中有的特定的用途時很有用：

[tool.poetry.group.docs]
optional = true

[tool.poetry.group.docs.dependencies]
mkdocs = "*"

添加依賴到組中：

poetry add pytest --group test

同步依賴，只使用poetry.lock中的依賴，移除其他不是必須的依賴：

poetry install --sync

七、環境管理
Poetry可以為項目使用獨立的虛擬環境，而不是使用系統安裝的。

切換環境：

poetry env use /full/path/to/python
poetry env use python3.7
poetry env use system
顯示當前激活的環境信息：

poetry env info
運行命令會輸出如下信息：

Virtual environment
Python: 3.7.1
Implementation: CPython
Path: /path/to/poetry/cache/virtualenvs/test-O3eWbxRl-py3.7
Valid: True

System
Platform: darwin
OS: posix
Python: /path/to/main/python
列出所有的虛擬環境列表：

poetry env list
刪除環境：

poetry env remove /full/path/to/python
poetry env remove python3.7
poetry env remove 3.7
poetry env remove test-O3eWbxRl-py3.7

F. 後端編程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 資料庫編程，更多實操示例請參照視頻講解。跟著張員外講編程，學習更輕松，不花錢還能學習真本領。

G. 怎麼用Python 保存並關閉一個打開狀態的txt文檔

你用C語言也有些困難。

這要看編輯器當時的數據在什麼地方。如果還在編輯器內部。基本上沒有辦法保存下來。

不過，如果已經保存了。只是沒有關閉。直接殺進程就好了。 殺完了。所有handle都釋放，也不存在什麼鎖，或者是狀態關閉了。

建議先用sync命令，將內容從操作系統的緩存里寫到磁碟中再操作。

H. 如何用python實現雙列表同步賦值

答：可以使用Python中的for循環進行列表的賦值，for循環的格式為:

for iterating_var in sequence:

statements(s)

對應代碼如下所示。

I. 如何在Windows通過NTP協議實現伺服器時間同步（python或C實現）

（知道不能發鏈接。）
1.獲取NTP伺服器時間。在pypi找ntplib。有範例。
2.設置windows系統時間。有很多方法。最簡單的可以直接用date命令。也可以用win32API SetSystemTime，這個精度控制好一些，可以設置到ms。

如果要定期對時，設置計劃任務即可。