深入理解python的,了解python

本文目錄一覽：

• 1、深入理解Python reduce函數
• 2、深入理解python中的排序sort
• 3、深入解析Python中的線程同步方法
• 4、深入理解Python中的*重複運算符

深入理解Python reduce函數

例如上面的例子，實現一個整形集合的累加。假設lst = [1,2,3,4,5],實現累加的方式有很多：

第一種：用sum函數。

sum(lst)

第二種：循環方式。

def customer_sum(lst):

result = 0

for x in lst:

result+=x

return result

def customer_sum(lst):

result = 0

while lst:

temp = lst.pop(0)

result+=temp

return result

if name ==” main “:

lst = [1,2,3,4,5]

print customer_sum(lst)

第三種：遞推求和

def add(lst,result):

if lst:

temp = lst.pop(0)

temp+=result

return add(lst,temp)

else:

return result

if name ==” main “:

lst = [1,2,3,4,5]

print add(lst,0)

第四種：reduce方式

lst = [1,2,3,4,5]

print reduce(lambda x,y:x+y,lst)

lst = [1,2,3,4,5]

print reduce(lambda x,y:x+y,lst,0)

def add(x,y):

return x+y

print reduce(add, lst)

def add(x,y):

return x+y

print reduce(add, lst,0)

有一個序列集合，例如[1,1,2,3,2,3,3,5,6,7,7,6,5,5,5],統計這個集合所有鍵的重複個數，例如1出現了兩次，2出現了兩次等。大致的思路就是用字典存儲，元素就是字典的key,出現的次數就是字典的value。方法依然很多

第一種：for循環判斷

def statistics(lst):

dic = {}

for k in lst:

if not k in dic:

dic[k] = 1

else:

dic[k] +=1

return dic

lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]

print(statistics(lst))

第二種：比較取巧的，先把列表用set方式去重，然後用列表的count方法

def statistics2(lst):

m = set(lst)

dic = {}

for x in m:

dic[x] = lst.count(x)

lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]

print statistics2(lst)

第三種：用reduce方式

def statistics(dic,k):

if not k in dic:

dic[k] = 1

else:

dic[k] +=1

return dic

lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]

print reduce(statistics,lst,{})

或者

d = {}

d.extend(lst)

print reduce(statistics,d)

通過上面的例子發現,凡是要對一個集合進行操作的，並且要有一個統計結果的，能夠用循環或者遞歸方式解決的問題，一般情況下都可以用reduce方式實現。

深入理解python中的排序sort

進行一個簡單的升序排列直接調用sorted()函數，函數將會返回一個排序後的列表：

sorted函數不會改變原有的list，而是返回一個新的排好序的list

如果你想使用就地排序，也就是改變原list的內容，那麼可以使用list.sort()的方法，這個方法的返回值是None。

另一個區別是，list.sort()方法只是list也就是列表類型的方法，只可以在列表類型上調用。而sorted方法則是可以接受任何可迭代對象。

list.sort()和sorted()函數都有一個key參數，可以用來指定一個函數來確定排序的一個優先級。比如，這個例子就是根據大小寫的優先級進行排序：

key參數的值應該是一個函數，這個函數接受一個參數然後返回以一個key，這個key就被用作進行排序。這個方法很高效，因為對於每一個輸入的記錄只需要調用一次key函數。

一個常用的場景就是當我們需要對一個複雜對象的某些屬性進行排序時：

再如：

前面我們看到的利用key-function來自定義排序，同時Python也可以通過operator庫來自定義排序，而且通常這種方法更好理解並且效率更高。

operator庫提供了 itemgetter(), attrgetter(), and a methodcaller()三個函數

同時還支持多層排序

list.sort()和sorted()都有一個boolean類型的reverse參數，可以用來指定升序和降序排列，默認為false，也就是升序排序，如果需要降序排列，則需將reverse參數指定為true。

排序的穩定性指，有相同key值的多個記錄進行排序之後，原始的前後關係保持不變

我們可以看到python中的排序是穩定的。

我們可以利用這個穩定的特性來進行一些複雜的排序步驟，比如，我們將學生的數據先按成績降序然後年齡升序。當排序是穩定的時候，我們可以先將年齡升序，再將成績降序會得到相同的結果。

傳統的DSU(Decorate-Sort-Undecorate)的排序方法主要有三個步驟：

因為元組是按字典序比較的，比較完grade之後，會繼續比較i。

添加index的i值不是必須的，但是添加i值有以下好處：

現在python3提供了key-function，所以DSU方法已經不常用了

python2.x版本中，是利用cmp參數自定義排序。

python3.x已經將這個方法移除了，但是我們還是有必要了解一下cmp參數

cmp參數的使用方法就是指定一個函數，自定義排序的規則，和java等其他語言很類似

也可以反序排列

python3.x中可以用如下方式：

深入解析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

[/data/web/test_python]$ python multhread_threading.py

61

[/data/web/test_python]$ python multhread_threading.py

[/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

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

[/data/web/test_python]$ python multhread_threading.py

深入理解Python中的*重複運算符

深入理解Python中的*重複運算符

在python中有個特殊的符號「*」，可以用做數值運算的乘法算子，也是用作對象的重複算子，但在作為重複算子使用時一定要注意

注意的是：*重複出來的各對象具有同一個id，也就是指向在內存中同一塊地址，在對各個對象進行操作是一定要注意。

舉例來說：

alist = [range(3)]*4

alist

[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

上面初始化一個二層列表用來模擬矩陣，該矩陣式4X3的，為描述方便，這裡記矩陣為A。

現在我想給A11賦值為1，用下面的代碼：

alist[0][0]=1

那我們想要的結果應該是：

[[1, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

可是很不幸，我們得到的是：

[[1, 1, 2], [1, 1, 2], [1, 1, 2], [1, 1, 2]]

這是怎麼回事呢，為什麼給A21賦值，其他的Ai1為什麼都跟着變了呢？

原因是這樣的：

文章開始的時候我們已經說過了，*重複出來的各對象具有同一個id，也就是指向在內存中同一塊地址，在對各個對象進行操作是一定要注意。

我們再初始化的時候用了重複算子”*”，這個操作符在對對象進行重複操作時，會將重複的所有對象都指向同一塊內存地址，所有當你改變其中的一個值時，其他的值自然也會更新，用python的話進行解釋就是下面的命令及輸出：

id(alist[0])

18858192

id(alist[1])

18858192

id(alist[2])

18858192

id(alist[3])

18858192

看到了吧，id都是一樣滴，也就是說這4個list是同一個「list」。

既然這樣那我們想要模擬一個矩陣怎麼辦呢，除了有專門的numpy包之外，你當然可以給上層list逐個的append新的list，例如：

blist=[]

for i in range(4):

blist.append([j for j in range(3)])

blist

[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

這樣，我們再試試上面的賦值操作：

blist[0][0]=1

blist

[[1, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

總結

以上就是本文關於深入理解Python中的*重複運算符的全部內容，希望對大家有所幫助。