資訊專欄INFORMATION COLUMN
摘要：線程是程序執(zhí)行時的最小單位，它是進程的一個執(zhí)行流。經(jīng)過這一道關(guān)卡處理，會增加執(zhí)行的開銷。每個對象都會被分配一個代，而被分配更年輕代的對象是優(yōu)先被處理的。引用循環(huán)垃圾回收器會定時尋找這個循環(huán)，并將其回收。
您可以關(guān)注公眾號《Python數(shù)據(jù)結(jié)構(gòu)》了解更多知識。i = i+1 和 i += 1
對于不可變數(shù)據(jù)類型（str、int、tuple）
由于本身是不可變數(shù)據(jù)類型，執(zhí)行后都會生產(chǎn)新的對象
x = 1 print(id(x)) # 1510566928 x += 1 print(id(x)) # 1510566960 --------------------------- x = 1 print(id(x)) # 1510566954 x = x + 1 print(id(x)) # # 1510566998
可變數(shù)據(jù)類型情況（list、dict）
可以看到 使用 += 并不會改變對象的內(nèi)存地址
x = [1, 2] print(id(x)) # 2701823038387 x = x + [3, 4] print(id(x)) # 2701823038334 ------------------ x = [1, 2] print(id(x)) # 2701823038344 x += [3, 4] print(id(x)) # 2701823038344
注意
n = n + n 作用域問題內(nèi)部為[1, 2, 1, 2], 外部仍為[1, 2]
def num(n):
n = n + n
x = [1, 2]
num(x)
print(x) # [1, 2]
--------------------
def num(n):
n += n
x = [1, 2]
num(x)
print(x) # [1, 2, 1, 2]
內(nèi)建函數(shù)
zip
key = [key for key in dict(zip(("a","b","c","d","e"),(1,2,3,4,5))) ]
print(key)
--------------------------------------------------------
["a", "b", "c", "d", "e"]
A0 = dict(zip(("a","b","c","d","e"),(1,2,3,4,5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]
-------------------------------------------------------------
A0 = {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}
A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A2 = []
A3 = [1, 3, 2, 5, 4]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
閉包
作用——保存局部信息不被銷毀。
def num2(n):
i = 1
def num_in():
nonlocal i
i = i + n
print(i)
return num_in
i = 0
start = num2(3)
while i<5:
start()
i += 1
匿名函數(shù)(lambda)
與正常寫法相比，使用匿名函數(shù)相當簡潔
map() 遍歷所有
a = [1, 2, 3]
x = []
for each in a:
x.append(each+1)
print(x)
### 使用map(func, iterable)
print(list(map(lambda x: x+1, a)))
reduce(func, seq) 積累每次計算的值
def num(x, y):
return x + y
print(reduce(num, [1, 2, 3, 4]))
--------------------------
print(reduce(lambda x, y: x*y, [1, 2, 3, 4]))
filter(func, iterable) 過濾滿足條件的值
print(list(filter(lambda x: x%2==0,range(10))))進程和線程的區(qū)別
進程是資源（CPU、內(nèi)存等）分配的基本單位，它是程序執(zhí)行時的一個實例。
線程是程序執(zhí)行時的最小單位，它是進程的一個執(zhí)行流。
進程有自己的獨立地址空間，每啟動一個進程，系統(tǒng)就會為它分配地址空間，建立數(shù)據(jù)表來維護代碼段、堆棧段和數(shù)據(jù)段，這種操作非常昂貴
線程是共享進程中的數(shù)據(jù)的，使用相同的地址空間，因此CPU切換一個線程的花費遠比進程要小很多，同時創(chuàng)建一個線程的開銷也比進程要小很多
進程實現(xiàn)
from multiprocessing import Pool
import time
import random
import os
def work(msg):
start = time.time()
print("work{}開始執(zhí)行,id為{}".format(msg, os.getpid()))
time.sleep(random.random()*2)
stop = time.time()
print("work{}耗時{}.".format(msg, stop-start))
p = Pool()
for i in range(10):
# 非堵塞運行
p.apply_async(work, args=(i,))
# 堵塞進行
# p.apply(work, args=(i,))
print("開始")
p.close()
p.join()
print("結(jié)束")
線程實現(xiàn)
import threading
import os
from time import sleep
def sorry(i):
print("say sorry {}".format(i))
sleep(1)
if __name__ == "__main__":
for i in range(1,10):
t = threading.Thread(target=sorry, args=(i,))
t.start()
協(xié)程
協(xié)程之前我們明白Python的進程和線程，這里我們來說一下協(xié)程
子程序切換不是線程切換，而是由程序自身控制
沒有線程切換的開銷，和多線程比，線程數(shù)量越多，協(xié)程的性能優(yōu)勢就越明顯
不需要多線程的鎖機制，因為只有一個線程，也不存在同時寫變量沖突，在協(xié)程中控制共享資源不加鎖
協(xié)程實現(xiàn)
def custumer():
r = ""
while True:
n = yield r # 接受send的值 返出yield的值
if not n:
return
print("custer {}".format(n))
r = "done"
def produce(c):
c.send(None) # 啟動
n = 0
while n < 5:
n += 1
print("custer {}".format(n))
r = c.send(n)
print("custer return {}".format(r))
c.close()
c = custumer()
produce(c)
GIL
Python并不支持真正意義上的多線程。Python中提供了多線程包，但是如果你想通過多線程提高代碼的速度，使用多線程包并不是個好主意。Python中有一個被稱為Global Interpreter Lock（GIL）的東西，它會確保任何時候你的多個線程中，只有一個被執(zhí)行。線程的執(zhí)行速度非常之快，會讓你誤以為線程是并行執(zhí)行的，但是實際上都是輪流執(zhí)行。經(jīng)過GIL這一道關(guān)卡處理，會增加執(zhí)行的開銷。這意味著，如果你想提高代碼的運行速度，使用threading包并不是一個很好的方法。copy
不過還是有很多理由促使我們使用threading包的。如果你想同時執(zhí)行一些任務，而且不考慮效率問題，那么使用這個包是完全沒問題的，而且也很方便。但是大部分情況下，并不是這么一回事，你會希望把多線程的部分外包給操作系統(tǒng)完成（通過開啟多個進程），或者是某些調(diào)用你的Python代碼的外部程序（例如Spark或Hadoop），又或者是你的Python代碼調(diào)用的其他代碼（例如，你可以在Python中調(diào)用C函數(shù)，用于處理開銷較大的多線程工作）。
Python拷貝分為深拷貝和淺拷貝
淺拷貝對子對象不拷貝，深拷貝全部拷貝
l1 = [1, 2, [3, 4]] l2 = copy.copy(l1) l1.append(5) l1[2].append(5) # 子對象 改變 print(l1) print(l2) -------------- [1, 2, [3, 4, 5], 5] [1, 2, [3, 4, 5]]
深拷貝完是兩個完全不相干的對象
l1 = [1, 2, [3, 4]] l2 = copy.deepcopy(l1) l1.append(5) l1[2].append(5) print(l1) print(l2) -------------- [1, 2, [3, 4, 5], 5] [1, 2, [3, 4]]垃圾回收機制
引用計數(shù)
import sys # 請在Python解釋器下運行 為 2 創(chuàng)建一次 調(diào)用一次 str1 = "hello world" print(sys.getrefcount(str1))
分代技術(shù)
Python默認定義了三代對象集合，索引數(shù)越大，對象存活時間越長 Python中使用了某些啟發(fā)式算法（heuristics）來加速垃圾回收。例如，越晚創(chuàng)建的對象更有可能被回收。對象被創(chuàng)建之后，垃圾回收器會分配它們所屬的代（generation）。每個對象都會被分配一個代，而被分配更年輕代的對象是優(yōu)先被處理的。
引用循環(huán)
垃圾回收器會定時尋找這個循環(huán)，并將其回收。舉個例子，假設(shè)有兩個對象o1和o2，而且符合o1.x == o2和o2.x == o1這兩個條件。如果o1和o2沒有其他代碼引用，那么它們就不應該繼續(xù)存在。但它們的引用計數(shù)都是1。is和==
# is 比較的是內(nèi)存地址 == 比較內(nèi)容和數(shù)據(jù)類型 a = [1, 2, 3] b = a print(a is b) print(a == b) c = copy.deepcopy(a) print(a is c) print(a == c) ------------- True True False True文件操作 read,readline和readlines
read 讀取整個文件 readline 讀取下一行,使用生成器方法 readlines 讀取整個文件到一個迭代器以供我們遍歷遞歸輸出文件
import os
def print_directory_contents(sPath):
for sChild in os.listdir(sPath):
sChildPath = os.path.join(sPath, sChild)
if os.path.isdir(sChildPath):
print_directory_contents(sChildPath)
else:
print(sChildPath)
print_directory_contents("F:GZmxgController")
Fibonacci數(shù)列
def fab(n):
a, b = 0, 1
while n:
yield b
a, b = b, a+b
n -= 1
內(nèi)存管理
小整數(shù)緩存池
a = 1 b = 1 print(a is b) # True
短字符串
# True a = "good" b = "good" print(a is b) # False a = "very good morning" b = "very good morning" print(a is b) # False a = [] b = [] print(a is b)函數(shù)調(diào)用
函數(shù)賦值會開辟新空間，即[] 和 [3, 2, 1]內(nèi)存地址不一樣，前者引用，后者覆蓋
def f(x, l=[]):
for i in range(x):
l.append(i*i)
print(l)
f(2) # [0, 1]
f(3,[3,2,1]) # [3, 2, 1, 0, 1, 4] # 自己多帶帶開辟
f(3) # [0, 1, 0, 1, 4] # 和f(2)共用
三目
if/else
# 若果 a>b 成立 就輸出 a-b 否則 a+b h = a-b if a>b else a+band/or
