Python

MyError

儘可能使用內置的錯誤類型。

另一種處理錯誤的方式

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

捕獲到錯誤後繼續 raise 拋出，由於當前函數不知道如何處理，因此繼續向上級調用者拋出。

assert

斷言，格式以下

def fun(n):
    assert n != 0, "n is zero"
    print('fun')
fun(0)

AssertionError: n is zero

能夠用 -O 參數關掉assert，好比， python -O test.py ，那麼assert語句就至關於pass了

logging

和assert比，logging不會拋出錯誤，並且能夠輸出到文件

pdb

單步調試，好的IDE PyCharm

單元測試

一個測試類，須要繼承自unittest.TestCase。類裏面的以test開頭的方法就是測試方法，不以test開頭的方法不被認爲是測試方法，測試的時候不會被執行。

unittest.TestCase提供了一些內置的判斷，好比assertEqual()

setUp()、tearDown()。沒測，估計是在測試類運行先後結束的時候分別調用的。

IO

一般的格式

try:
    f = open('E:/t.txt', 'r')
    print(f.read())
finally:
    if f:
        f.close()

和Java同樣，打開了記得關閉，爲了防止打開文件出錯，後面的close執行不到，因此用try catch這種方式，r 表示讀文件。

Python還提供一種更簡潔的方式，效果和上面的同樣。

with open("E:/t.txt", "r") as f:
    print(f.read())

read()方法會一次性讀取所有內容，若是內容有好幾個G，內存就爆了，因此，用read(size)屢次反覆調用是更合理的方法

readline()能夠每次讀取一行內容，調用readlines()一次讀取全部內容並按行返回list

讀取二進制文件（圖片，視屏等）， rb

with open("E:/t.PNG", "rb") as f:
    print(f.read())

讀取GBK編碼的文件

with open("E:/t.txt", "r", encoding='gbk') as f:
    print(f.read())

忽略錯誤（好比編碼錯誤）

with open("E:/t.txt", "r", encoding='gbk', errors="ignore") as f:
    print(f.read())

寫文件。參數有 w ，二進制文件寫 wb。操做系統每每不會馬上把數據寫入磁盤，而是放到內存緩存起來，空閒的時候再慢慢寫入。只有調用close()方法時，操做系統才保證把沒有寫入的數據所有寫入磁盤。忘記調用close()的後果是數據可能只寫了一部分到磁盤，剩下的丟失了。因此，仍是用with語句來得保險

StringIO

從內存中讀寫str，區別於從文件讀寫

from io import StringIO
# 讀
f = StringIO("Hello World\nLearn Python")  # 初始化一個StringIO
while True:
    s = f.readline()
    if s == "":
        break
    print(s)

# 寫
f = StringIO()
f.write("Hello Python")  # write方法會返回寫入的字符數，好比這裏是12
print(f.getvalue())

StringIO操做的只能是str，若是要操做二進制數據，就須要使用BytesIO。

操做文件和目錄

import os
os.name  # nt
os.environ  # 打印出環境變量
os.environ.get("PATH")  # 經過get加上key來獲取

操做文件和目錄的函數一部分放在os模塊中，一部分放在os.path模塊中

os.path.abspath('.')  # 獲取絕對路徑，有點像pwd
os.mkdir("E:/testdir")  # 建立目錄
os.rmdir("E:/testdir")  # 刪除目錄

把兩個路徑合成一個時，不要直接拼字符串，而要經過os.path.join()函數，這樣能夠正確處理不一樣操做系統的路徑分隔符

一樣的道理，要拆分路徑時，也不要直接去拆字符串，而要經過os.path.split()函數，這樣能夠把一個路徑拆分爲兩部分，後一部分老是最後級別的目錄或文件名

os.path.splitext()能夠直接讓你獲得文件擴展名

os.path.splitext("E:/t.txt")  # ('E:/t', '.txt') 獲得一個tuple

重命名 os.rename

刪除文件 os.remove

複製文件沒有提供，能夠用IO來實現，shutil模塊也提供了copyfile()的函數

序列化

Python中的序列化叫作pickling，反序列化叫作unpickling，Python提供pickle模塊來實現序列化

序列化：

import pickle
d = dict(name = "kobe", num = 24)
with open("D:/t.txt", "wb") as f:
    pickle.dump(d, f)  # 序列化後保存到文件中

文件中的內容是這樣的一堆亂七八糟的東西:

(dp0
S'num'
p1
I24
sS'name'
p2
S'kobe'
p3
s.

反序列化

with open("D:/t.txt", "rb") as f:
    p = pickle.load(f)  # load反序列化出對象
print(p)  # {'num': 24, 'name': 'kobe

反序列化出來的對象跟原來的那個不是同一個對象，只是內容相同而已

pickle可能會在不一樣版本的Python中不兼容，因此，最好只用這個保存不重要的數據。反序列化不了也不要緊。。。（因此，就是本身玩玩就好

JSON

爲了在不一樣的編程語言之間傳遞對象，必須把對象序列化成標準格式。好比XML，JSON，最好是JSON，由於JSON表示出來就是一個字符串，能夠被全部語言讀取。也能夠方便地存儲到磁盤或者經過網絡傳輸。JSON不只是標準格式，而且比XML更快，並且能夠直接在Web頁面中讀取，很是方便。

總之，JSON大法好，嗯。

import json
# dumps返回一個標準的json字符串
print(json.dumps(d))  # {"num": 24, "name": "kobe"}
# dump把json字符串寫到文件中
with open("D:/t.txt", "w") as f:
    json.dump(d, f)

# 一樣有個load方法把json數據反序列化
with open("D:/t.txt", "r") as f:
    j = json.load(f)
    print(j)

類的序列化

就像Java中序列化一個對象須要他的類實現了某些接口。Python中也不能直接序列化，除了那些原本就支持的數據類型，自定義類的話，要本身寫個轉換方法。好比

class Player(object):
    def __init__(self, name, team, age):
        self.name = name
        self.team = team
        self.age = age

def player2dict(p):
    return {
        "name":p.name,
        "age":p.age,
        "team":p.team
    }
p = Player("kobe", "Lakers", 35)
print(json.dumps(p, default=player2dict))  # {"age": 35, "name": "kobe", "team": "Lakers"}

或者偷懶，寫成這樣：

json.dumps(p, default=lambda o:o.__dict__)

一般class的實例都有一個__dict__屬性，它就是一個dict，用來存儲實例變量。也有少數例外，好比定義了__slots__的class。

反序列化也要寫一個函數轉換，object_hook負責把dict轉換成player

class Player(object):
    def __init__(self, name, team, age):
        self.name = name
        self.team = team
        self.age = age

def player2dict(p):
    return {
        "name":p.name,
        "age":p.age,
        "team":p.team
    }
p = Player("kobe", "Lakers", 35)
str = json.dumps(p, default=lambda o:o.__dict__)  # {"age": 35, "name": "kobe", "team": "Lakers"}
def dict2player(d):
    return Player(d["name"], d["age"], d["team"])
s = json.loads(str, object_hook=dict2player)
print(s)  # <__main__.Player object at 0x03B901F0>

進程和線程

線程是最小的執行單元，而進程由至少一個線程組成。如何調度進程和線程，徹底由操做系統決定，程序本身不能決定何時執行，執行多長時間

Windows下啓動子進程

from multiprocessing import Process
import os

def fun(name):
    print("Run child proc %s (%s)..." % (name, os.getpid()))

if __name__=="__main__":
    print("parent proc %s." % os.getpid())
    p = Process(target=fun, args=("test", ))
    print("child proc will start")
    p.start()
    p.join()
    print("child proc end.")

parent proc 14780.
child proc will start
Run child proc test (15192)...
child proc end.

注意：這玩意原本用vs code直接F5，是不會執行fun函數的，可是在終端 py test.py 是能夠的！

Pool

若是要啓動大量的子進程，能夠用進程池的方式批量建立子進程

from multiprocessing import Pool
import os, time, random

def task(name):
    print("Run task %s (%s)" % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print("task %s run %0.2f seconds" % (name, end - start))

if __name__ == "__main__":
    print("parent proc %s " % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(task, args = (i,))
    print("waiting for all subprocess done...")
    p.close()
    p.join()
    print("all subprocess done")

parent proc 10660
waiting for all subprocess done...
Run task 0 (13592)
Run task 1 (5020)
Run task 2 (5180)
Run task 3 (7012)
task 2 run 1.03 seconds
Run task 4 (5180)
task 1 run 2.06 seconds
task 3 run 2.30 seconds
task 0 run 2.78 seconds
task 4 run 1.98 seconds
all subprocess done

對Pool對象調用join()方法會等待全部子進程執行完畢，調用join()以前必須先調用close()，調用close()以後就不能繼續添加新的Process了。

task 0，1，2，3是馬上執行的，而task 4要等待前面某個task完成後才執行，這是由於Pool的默認大小在個人電腦上是4，所以，最多同時執行4個進程。這是Pool有意設計的限制，並非操做系統的限制。

進程的通訊

Python的multiprocessing模塊包裝了底層的機制，提供了Queue、Pipes等多種方式來交換數據

from multiprocessing import Process, Queue
import os, time, random

def write(q):
    print("write process (%s)" % os.getpid())
    for i in ["kobe", "tracy", "nash"]:
        print("put %s to queue" % i)
        q.put(i)
        time.sleep(random.random())

def read(q):
    print("read process (%s)" % os.getpid())
    while True:
        v = q.get(True)
        print("get %s from queue" % v)

if __name__ == "__main__":
    q = Queue()
    wp = Process(target=write, args=(q,))
    rp = Process(target=read, args=(q,))
    wp.start()
    rp.start()
    wp.join()
    rp.terminate()

rp是死循環，因此不能用join()來等待結束，只能直接殺死他

write process (6576)
put kobe to queue
read process (6032)
get kobe from queue
put tracy to queue
get tracy from queue
put nash to queue
get nash from queue

多線程

Python的標準庫提供了兩個模塊：_thread和threading，_thread是低級模塊，threading是高級模塊，對_thread進行了封裝。絕大多數狀況下，咱們只須要使用threading這個高級模塊

啓動一個線程就是把一個函數傳入並建立Thread實例，而後調用start()開始執行

import time, threading

def loop():
    print('thread %s is running' % threading.current_thread().name)
    for i in range(5):
        print('thread %s >>> %s ' % (threading.current_thread().name, i))
        time.sleep(1)
    print('thread %s ended' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='loopThread')  # 建立Thread對象，賦值要運行的函數，以及線程名字
t.start()  # 開始
t.join()  # 等待結束
print('thread %s ended' % threading.current_thread().name)

thread MainThread is running...
thread loopThread is running
thread loopThread >>> 0 
thread loopThread >>> 1 
thread loopThread >>> 2 
thread loopThread >>> 3 
thread loopThread >>> 4 
thread loopThread ended
thread MainThread ended

Lock

多線程和多進程最大的不一樣在於，多進程中，同一個變量，各自有一份拷貝存在於每一個進程中，互不影響，而多線程中，全部變量都由全部線程共享，因此，任何一個變量均可以被任何一個線程修改

嗯。只要有線程，就會要討論同步的問題

基本使用方式就這樣

lock = threading.Lock()  # 獲取Lock對象
n = 0
def count():
    for i in range(100):
        lock.acquire()  # 獲取鎖，放到須要數據同步的地方
        try:
            global n  # 關鍵代碼寫在try catch中
            n = n + 1
            print("thread %s runing count >>> n = %s \n" % (threading.current_thread().name, n))
        finally:
            lock.release()  # 記得在finally裏面釋放鎖

Python的線程雖然是真正的線程，但解釋器執行代碼時，有一個GIL鎖：Global Interpreter Lock，任何Python線程執行前，必須先得到GIL鎖，而後，每執行100條字節碼，解釋器就自動釋放GIL鎖，讓別的線程有機會執行。這個GIL全局鎖實際上把全部線程的執行代碼都給上了鎖，因此，多線程在Python中只能交替執行，即便100個線程跑在100核CPU上，也只能用到1個核

Python解釋器因爲設計時有GIL全局鎖，致使了多線程沒法利用多核。多線程的併發在Python中就是一個美麗的夢

分佈式進程

在Thread和Process中，應當優選Process，由於Process更穩定，並且，Process能夠分佈到多臺機器上，而Thread最多隻能分佈到同一臺機器的多個CPU上。

Python的multiprocessing模塊不但支持多進程，其中managers子模塊還支持把多進程分佈到多臺機器上。一個服務進程能夠做爲調度者，將任務分佈到其餘多個進程中，依靠網絡通訊。因爲managers模塊封裝很好，沒必要了解網絡通訊的細節，就能夠很容易地編寫分佈式多進程程序。

這玩意在Linux下運行沒有問題。windows下面不行。

網絡編程

TCP/IP

IP協議負責把數據從一臺計算機經過網絡發送到另外一臺計算機。數據被分割成一小塊一小塊，而後經過IP包發送出去。因爲互聯網鏈路複雜，兩臺計算機之間常常有多條線路，所以，路由器就負責決定如何把一個IP包轉發出去。IP包的特色是按塊發送，途徑多個路由，但不保證能到達，也不保證順序到達。

TCP協議則是創建在IP協議之上的。TCP協議負責在兩臺計算機之間創建可靠鏈接，保證數據包按順序到達。TCP協議會經過握手創建鏈接，而後，對每一個IP包編號，確保對方按順序收到，若是包丟掉了，就自動重發。

許多經常使用的更高級的協議都是創建在TCP協議基礎上的，好比用於瀏覽器的HTTP協議、發送郵件的SMTP協議等。

模塊

面向對象

靜態語言 vs 動態語言

面相對象高級編程

元類

錯誤、調試、測試

IO

序列化

進程和線程

多線程

分佈式進程

網絡編程