• 要刪除指定位置的元素，用pop(i)方法，其中i是索引位置：
• 可以獲取倒數第2個、倒數第3個L[-2]、L[-3]

• tuple所謂的“不變”是說，tuple的每個元素，指向永遠不變。即指向’a’，就不能改成指向’b’，指向一個list，就不能改成指向其他物件，但指向的這個list本身是可變的！
• Python規定，只有1個元素的tuple定義時必須加一個逗號,，來消除歧義: t = (1,)

• dict的儲存不是按照list的方式順序排列，迭代出的結果順序很可能不一樣
• 和list比較，dict有以下幾個特點：
  
  • 查詢和插入的速度極快，不會隨著key的增加而變慢；
  • 需要佔用大量的記憶體，記憶體浪費多。
• 而list相反：
  
  • 查詢和插入的時間隨著元素的增加而增加；
  • 佔用空間小，浪費記憶體很少。
• 所以，dict是用空間來換取時間的一種方法。

• 要建立一個set，需要提供一個list作為輸入集合：s = set([1, 2, 3])
• 易錯點：
  
  • a = ‘abc’
  • b = a.replace(‘a’, ‘A’)
  • 我們呼叫a.replace(‘a’,’A’)時，實際上呼叫方法replace是作用在字串物件’abc’上的，而這個方法雖然名字叫replace，但卻沒有改變字串’abc’的內容。相反，replace方法建立了一個新字串’Abc’並返回，如果我們用變數b指向該新字串，就容易理解了，變數a仍指向原有的字串’abc’，但變數b卻指向新字串’Abc’了
  • 所以，對於不變物件來說，呼叫物件自身的任意方法，也不會改變該物件自身的內容。相反，這些方法會建立新的物件並返回，這樣，就保證了不可變物件本身永遠是不可變的。

• 預設引數一定要用不可變物件，如果是可變物件，程式執行時會有邏輯錯誤！
• 要注意定義可變引數和關鍵字引數的語法：
  
  • *args是可變引數，args接收的是一個tuple；
  • **kw是關鍵字引數，kw接收的是一個dict。
• 以及呼叫函式時如何傳入可變引數和關鍵字引數的語法：
  
  • 可變引數既可以直接傳入：func(1,2,3)，又可以先組裝list或tuple，再通過* args傳入：func(*(1, 2, 3))；
  • 關鍵字引數既可以直接傳入：func(a=1,b=2)，又可以先組裝dict，再通過* kw傳入：func(*{‘a’: 1, ‘b’: 2})。
• 使用* args和** kw是Python的習慣寫法，當然也可以用其他引數名，但最好使用習慣用法。
• 命名的關鍵字引數是為了限制呼叫者可以傳入的引數名，同時可以提供預設值。
• 定義命名的關鍵字引數在沒有可變引數的情況下不要忘了寫分隔符*，否則定義的將是位置引數。

• L[a：b：c]:在list L中[a,b)的元素中每隔c個元素取一個組成新的list並返回
  
  • a不寫預設是list首，b不寫預設是list尾，a、b均不寫，代表整個list
• 倒數切片L[-a:-b:c]：在list L中[-a,-b]的元素中每隔c（步長）個元素取一個組成新的list並返回,注意：倒數第一個是-1
• 步長c不能為0，但是可以為負數，即從右到左提取元素。使用一個負數作為步長時，必須讓開始點(開始索引)大於結束點。
• eg：numbers = [1,2,3,4,5,6,7,8,9,10]
• print(numbers[6:3:-1]) 輸出：[7, 6, 5]
• tuple( )和string‘ ’也支援slice切片操作，切片後返回的是tuple( )和string‘ ’

• from collections import Iterable
• isinstance(‘abc’,Iterable) #str是否可以迭代

• Python內建的enumerate函式可以把一個list變成索引-元素對，這樣就可以在for迴圈中同時迭代索引和元素本身：
• for i,j in enumerate([1,2,3]):
• print(i,j)

• 通過next()函式獲得generator的下一個返回值
• 使用for迴圈，generator可以迭代

• L = [1]
• while True:
  
  • yield L
  • L.append(0)
  • L = [L[i-1] + L[i] for i in range(len(L))]

• next方法：返回迭代器的下一個元素
• iter方法：返回迭代器物件本身

• eg: list = [map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])]

• eg: reduce(add, [1, 3, 5, 7, 9]) 累加

• Python的functools模組提供了很多有用的功能，其中一個就是偏函式（Partial function）。
• 當函式的引數個數太多，需要簡化時，使用functools.partial可以建立一個新的函式，這個新函式可以固定住原函式的部分引數，從而在呼叫時更簡單。
• 建立偏函式時，實際上可以接收函式物件、*args和**kw這3個引數：
  
  • eg：int2 = functools.partial(int, base=2)
  • int2(‘10010’)
  • 相當於：
  • kw = { ‘base’: 2 }
  • int(‘10010’, **kw)
  • eg：max2 = functools.partial(max, 10)
  • max2(5, 6, 7)
  • 相當於：
  • args = (10, 5, 6, 7)
  • max(*args)

• def fn(self, name=’world’): # 先定義函式
• print(‘Hello, %s.’ % name)
• Hello = type(‘Hello’, (object,), dict(hello=fn)) # 建立Hello class
• type()函式依次傳入3個引數：
• class的名稱；
• 繼承的父類集合，注意Python支援多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；
• class的方法名稱與函式繫結，這裡把函式fn繫結到方法名hello上。

• from types import MethodType
• s.set_age = MethodType(set_age, s) # 給例項繫結一個方法

• def set_score(self, score):
  
  • self.score = score
• Student.set_score = set_score # 給class繫結方法

• eg：ForkingMixIn（多程序模型）、ThreadingMixIn（多執行緒模型）

• l(l:list) 顯示整個.py檔案
• n 單步執行
• p + 變數名 檢視變數名
• c 繼續執行程式
• q 退出pdb

• doctest嚴格按照Python互動式命令列的輸入和輸出來判斷測試結果是否正確。
• 只有測試異常的時候，可以用…表示中間一大段煩人的輸出。
• 當模組正常匯入時，doctest不會被執行。
• 只有在命令列直接執行且自定義的doctest部分有問題，才執行doctest。
• 所以，不必擔心doctest會在非測試環境下執行。

• 如果這裡不加r,地址當中的這個符號“\”必須寫成轉義字元的形式,也就是’\’
• 總結下就是：’C:\’ 和 r’C:\’ 輸出是一樣的

• 獲取某個具體的環境變數：os.environ.get(‘path’)

• json.dumps()方法返回一個str，內容就是標準的JSON。
  
  • 例如：
  • import json
  • d = dict(name=’Bob’, age=20, score=88)
  • json.dumps(d)
  • 輸出：’{“age”: 20, “score”: 88, “name”: “Bob”}’
  • JSON語法規定key（age、score、name）必須要用雙引號
• json.dump()方法可以直接把JSON寫入一個file-like Object。

• 最常用：json.loads()把JSON的字串反序列化為python物件
  
  • 例如：
  • json_str = ‘{“age”: 20, “score”: 88, “name”: “Bob”}’
  • json.loads(json_str)
  • 輸出：{‘age’: 20, ‘score’: 88, ‘name’: ‘Bob’}
• json.load()，從file-like Object中讀取字串並反序列化為python物件

• 多程序通訊 Pipe、Queue
• process.start()、process.join()、process.terminate()
• 獲取cpu核數：queue.put()、queue.get()
• multiprocessing.cpu_count()

• Python的threading模組有個current_thread()函式，它返回當前執行緒的例項
• 多執行緒不加鎖同時修改一個全域性變數，會由於執行緒中斷出現錯誤
• 解決方案:但加鎖後，多執行緒相當於轉變成單執行緒，而且由於加鎖操作使效率上：多執行緒<單執行緒
• 通過threading.Lock()建立一個鎖；
• 執行前獲取鎖：lock.acquire()；
• 執行完，釋放鎖lock.release()
• Python的執行緒雖然是真正的執行緒，但直譯器執行程式碼時，有一個GIL鎖：Global Interpreter Lock，任何Python執行緒執行前，必須先獲得GIL鎖，然後，每執行100條位元組碼，直譯器就自動釋放GIL鎖，讓別的執行緒有機會執行。這個GIL全域性鎖實際上把所有執行緒的執行程式碼都給上了鎖，所以，多執行緒在Python中只能交替執行，即使100個執行緒跑在100核CPU上，也只能用到1個核。
• Python直譯器由於設計時有GIL全域性鎖，導致了多執行緒無法利用多核。多執行緒的併發在Python中就是一個美麗的夢。
• IO操作不鎖定GIL，這時其他執行緒可以正常執行
• Python雖然不能利用多執行緒實現多核任務，但可以通過多程序實現多核任務。多個Python程序有各自獨立的GIL鎖，互不影響。

• 一個ThreadLocal變數雖然是全域性變數，但每個執行緒都只能讀寫自己執行緒的獨立副本，互不干擾。
• 把threadlocal看成全域性dict，每個執行緒用自己作為key訪問value，所以互不干擾

• 多程序下，windows下建立程序代價大（linux、unix下有fork，windows沒有）
• 多執行緒下，任意一個執行緒掛掉，會導致整個程序崩潰（所有執行緒共享程序的記憶體），即穩定性不夠
• 計算密集型任務VSIO密集型任務
• 計算密集型任務的特點是要進行大量的計算，消耗CPU資源。這種計算密集型任務雖然也可以用多工完成，但是任務越多，花在任務切換的時間就越多，CPU執行任務的效率就越低，所以，要最高效地利用CPU，計算密集型任務同時進行的數量應當等於CPU的核心數。
• IO密集型，涉及到網路、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和記憶體的速度）。對於IO密集型任務，任務越多，CPU效率越高。
• 非同步IO

分散式程序(詳見部落格)

• 用multiprocessing.managers裡的BaseManager來通過網路進行分散式通訊

正則表示式：re模組

• eg：’00\d’可以匹配’007’

• eg：’\w\w\d’可以匹配’py3’

• eg：’py.’可以匹配’pyc’、’pyo’、’py!’等等

• eg：\s+ 匹配至少一個空格

• eg：[0-9a-zA-Z_]可以匹配一個數字、字母或者下劃線

• eg:re.split(r’\s+’, ‘a b c’)
• [‘a’, ‘b’, ‘c’]

• eg：匹配區號和號碼 m = re.match(r’^(\d{3})-(\d{3,8})$’, ‘010-12345’)

• eg： re.match(r’^(\d+)(0*)$’, ‘102300’).groups()
• (‘102300’, ”)
• \d+採用貪婪匹配，直接把後面的0全部匹配了，結果0*只能匹配空字串了
• 讓\d+採用非貪婪匹配（也就是儘可能少匹配），才能把後面的0匹配出來，加個?即可
• re.match(r’^(\d+?)(0*)$’, ‘102300’).groups()
• (‘1023’, ‘00’)

• start_response(‘200 OK’,[(‘Content-Type’,’text/html’)])
• body = ‘< h1>hello,%s！< /h1>’ % (environ[‘PATH_INFO’][1:] or ‘web’)
• return [body.encode(‘utf-8’)]

• yield from + 協程任務
• 將協程任務的值包含到當前協程任務的返回值裡，即可以連線兩個協程任務的值