兩本不錯的書：

《Python參考手冊》：對Python各個標準模組，特性介紹的比較詳細。

《Python核心程式設計》：介紹的比較深入，關鍵是，對Python很多高階特性都有介紹。

一個開原始碼：openstack，關於雲端計算的，用Python寫的，可以重點學習一下。

套接字程式設計：

1、 函式的功能基本和c類似，唯一不同的地方在於當發生錯誤時，它不是通過返回值來告知的，而是通過觸發異常，所以udp中的bind, recvfrom, sendto必須要進行捕捉異常。

2、 套接字在垃圾收集的時候也會關閉。

3、 獲取網絡卡的IP：    

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

return socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0X8915, struct.pack('256s', ethname[:15]))[20:24])

字串的使用：

1、 Python的字串是不可以改變的。但是你可以操作字串以形成新的字串。

2、 字串中刪除一個字串。沒有直接提供這個方法，但是replace可以實現：

"abc def".replace(" ", "")

同樣的功能還有一個方法：translate。它的原有作用是將字串中的某個字元替換為另外一個字元，注意，不是字串。它的第一個引數是一個轉換表。第二個引數是要刪除的字串。我們可以利用第二個引數del

translate可能更高效一點。另外，它的第二個引數可以使一個字串，含有多個字元，這樣就會刪除多個。

注意：translate方法不會對這個字串操作，而是返回一個新的字串。

3、 strip方法：去除字串兩側的空格，返回新的字串。這個功能非常有用。

4、 str中有一個函式，format，非常強大，有時間一定要看一下。

5、 endswitch：檢查字串是否已某字串結尾。startswith：檢查是否已某字串開頭。

6、 partition：它將字串按指定的字串分為三個部分，返回一個元組。第一個是指定字串前面內容，第二個是指定字串，第三個是指定字串後面的內容。用於字串解析非常好用。

7、 split：將字串按照某指定字串分割成多個子字串，返回一個分割後的列表。

8、 join：將一個字串列表中的各個字串連線起來，中間插入指定的字串。

9、 find的返回值不是false和true，所以不可以直接用於if判斷。需要判斷if s.find(‘’) >= 0:

10、 基於字典的格式化：

a) sh = '''

b) python -m compileall -fl ../src;

c) python -m compileall -fl ../src/micbase;

d) mkdir %(packname)s;

e) mdkir %(packname)s;

f) ''' % {'packname':sys.argv[1], }

g) print(sh)

h) 

內建函式：

正則表示式

1、 為什麼要學習正則：主要是為了處理字串更加方便，特別是為後面進行程式碼生成做儲備。

2、 match是匹配字串的開頭是否匹配，而search是檢視字串任意起始位置是否滿足。

3、 sub可以對字串中模式匹配的部分進行替換

4、 split：可以對字串進行分割，這裡是根據模式分割。

函式的使用：

1、 函式的作用域：函式中定義一個變數，如果和全域性變數重名，則全域性變數名稱就會被覆蓋，也就是，這裡對這個變數的更改，不會更改全域性變數。但是，如果直接使用的話，是會使用全域性變數的。同時，如果想要修改全域性變數，需要制定是全域性變數：global a

2、 xrange用法和range一樣，不過更為高效，因為他不會在記憶體中建立列表。所以，它只能用於迴圈。

3、 如果函式沒有return語句，則他的返回值為None。

4、 關於函式的入參判斷：如果如此為空，可能會發生異常。當異常發生後，可能會出現一種情況，一個事情做到了一半，就沒有在進行下去，可能會造成記憶體洩露。這個問題如何解決？按照C的方式，每個入參都做判斷是可以解決的，但是這樣太麻煩了。而且看很多開原始碼頁沒有這樣來做。是不是有更好的方法？換一種思路，在呼叫之前確保不為空。在看看開源的程式碼是怎麼做的。特別是openstack。

5、 可變入參：*args, **kwargs表示可變入參。

deffuntest(a, b, c):

print(a, b, c)

deffun2(*args, **kwargs):

funtest(*args, **kwargs)

fun2(1,2,3)

也可以這樣定義：

fun2(a, *args, **kwargs)

如何從可變引數中解析出引數的值？

在fun2中新增列印：可以發現，其實args是一個元組，kwargs是一個字典。

分析：呼叫fun2(1,2,3)，會把a賦值給a，2賦值給元組args，{‘c’=3}賦值給kwargs.

args和kwargs的順序不可顛倒。

args和kwargs可能同時都有值。這樣，要獲取指定的入參，首先根據看args中有沒有，然後根據字串看kwargs中是否存在。

如何建一個元組或者字典通過引數傳遞給一個函式？

deffuntest(a, b, c):

print(a, b, c)

d = {'a':1, 'b':2,'c':3}

l = (1,2,3)

funtest(*l)

funtest(**d)

*和**在Python中可以實現這個功能。這樣會很靈活的。

*和**也可以單獨出現。但是，如果同時出現，*必須在**之前。

6、 預設引數或者可選引數，引數順序：呼叫時，可以指定預設引數中填充那個。

deffuntest(a, b=1, c=2):

print(a, b, c)

funtest(1, c=5, b=6)

其實，即便定義為：deffuntest(a, b, c)，也可以通過funtest(1, c=5, b=6)的形式呼叫。

7、 引數組：*args, **kwargs就是引數組，通過元組和字典將產生攜帶進來。這個特性有助於更為動態的程式碼生成。

8、 可變長度引數：

9、 函式的引數中如果有一個是元組，可以這樣：

deffun(a, (b, c)):

print(a, b, c)

fun(1, (1,2))

10、 關於回撥，可以使用閉包，生成器，以及物件的__call__屬性。都可以封裝狀態。

閉包的使用：

1、 將組成函式的語句和語句的執行環境打包在一起形成的物件，成為閉包。

2、 2.7之前的閉包不支援關鍵字nonlocal。3.0之後才支援。所以2.7前的閉包不可以使用nonlocal。

3、 這樣他就不可以對執行環境中的變數進行更改。

字典的使用：

1、 字典的刪除：直接使用del dict[k]可能會引發異常；首先判斷k是否存在則效率有些低；使用異常使程式結構看起來不好。一個好的方法是pop(k, default v)。這個刪除一個k項，並且返回。如果不存在返回預設的v。如果不加預設值，則會引發異常。

2、 直接使用字典下標獲取字典的值可能會引發一場。使用get方法則不會，如果不存在會返回none。另外，還可以設定不存在的預設值。

3、 通過字典格式化字串：print “value is %(key)s” % kvdict

4、 items方法返回一個列表，列表中的元素是一個元組，第一個是key，第二個是value。比較好用的方法。

5、 iteritems:返回的是一個迭代器。如果想要迭代這個字典，iteritems會比items更高效一點。

6、 iterkeys則返回的是key的迭代器。keys返回的是key的list。

7、 values返回值的列表，itervalues返回的是vlaue的迭代器

8、 popitem會隨機彈出（同時刪除）一個項，則對於想要處理所有的元素，並且刪除所有的元素是有幫助的。但是，如果沒用元素的話，會丟擲異常。

9、 viewitems，viewkeys，viewvalues：這三個函式返回的是一個view物件。這個類似於檢視。分別表示（key, value）pair的列表，key的列表，value的列表。一個優點是，如果字典發生變化，view會同步發生變化。在迭代過程中，字典不允許改變，否則會報異常。

10、 字典的鍵值比較規則：如果是內建型別（int，str，tuple）,則是以他們的值作為鍵值；如果是自定義物件，則是以物件的地址作為鍵值。——這一點沒有完全證實。——最新的發現：物件的比較，內建型別，是因為他們都重寫了預設的object的__eq__等方法，所以可以比較內容。自定義物件，沒有重寫，所以，他們的比較可能會不一樣。object預設的比較是什麼？目前還不明確，後面再補充吧。可能就是地址（或者物件的唯一標識），而不是物件的內容。涉及到字典，它不是使用的單純的比較，而是使用的__hash__，它返回的是一個hash值，字典就是根據這個hash只來散佈物件的。

列表的使用：

1、 列表的刪除：不可以在遍歷的過程中刪除連結串列，這樣會得到不可預知的後果。可以使用列表的過濾，來獲得新的列表。

2、 列表的過濾：

deffilterFun(node):#這個函式做了兩個事情哎。

            node.cycleCount = node.cycleCount - 1

return node.cycleCount < 0

        timeoutList = filter(filterFun, timerList)

對timerList中的每個節點執行函式filterFun，根據filterFun返回的結果，為真的項組成一個新的列表。

3、 map: kvlist = map(lambda x:x.strip(), kvlist)。同時，map可以接受多個列表，這個時候，函式也會接受多個引數，分別表示列表的每一個元素:kvlist = map(lambda x,y:x+y, [1,2,3], [4,5,6])

如果函式為None，則相當於函式zip：

zip([1,2,3], [4,5,6])

[(1,4),(2,5),(3,6)]

4、 生成器表示式：l = [node for node in xrange(5) if node - 3 < 0]:這個的這個方法一定程度上可以替代過濾器和map。

生成器表示式定義：

[expr for iter_var in iterable if cond_expr]

l = [2 for x in xrange(5)]#結果是生成一個含有5個2的列表

5、 print(reduce(lambda x,y: x*y, [2 for x in xrange(38)]))

上面的這個語句是計算2的38次方的值。它用到的是二元函式reduce。它第一次呼叫是將第一個和第二個元素做入參，後面用他們的結果做x，新的元素做y，最後返回值。

另外，在獲取一個38個2的列表也可以使用：[2] * 38。這可能更可讀一點。

6、 enumerate:對列表處理，返回的是列表的索引以及節點。

for index, node inenumerate(timerList):

if timerId == node.timerId and timerEvent == node.timerEvent:

del timerList[index]

7、 列表的分片：[1,2,3,4]，l[1:-1]表示從索引從1到倒數第一個，不包含倒數第一個。如果要從某位置到最後，則應該：[1:]

8、 l[i:j:k]:表示切片，從i到j，步長為k。

9、 l[i:j]:表示從i到j，不包括索引j。

排序

1、 list自己提供了排序的函式：sort。

2、 sort的引數：

a) cmp是一個比較函式，輸入兩個元素，比較大小，返回值為-1，0，1.

b) key也是一個函式，入參為一個元素，返回這個元素的關鍵字。

c) reverse是一個標誌位，表示升序還是降序。預設False是升序，True表示降序。

3、使用key和reverse的效能，優於cmp函式。時間是cmp函式的一半。

迭代的使用：

1、 迭代比直接使用列表遍歷效率根據高。比如字典的keys函式返回的列表，以及iterkeys返回的迭代器。

2、 reversed() 內建函式將返回一個反序訪問的迭代器.引數必須為序列。

3、 enumerate：返回一個迭代器：有索引值。

4、 for  eachLine  in  myFile  替 換   for  eachLine  in myFile.readlines() :

5、 注意：在迭代的過程中不可以更改序列，否則會引發問題，導致迭代出錯。

6、 可以自己定義一個類，可以迭代使用。不過需要定義方法：__iter__，next。

7、 filter(function, iterable)：可以對迭代使用過濾器。

生成器的使用：

1、 yield關鍵字可以阻塞住函式的執行，並且儲存當前的執行環境，整個包被稱為生成器。

2、 生成器可以通過呼叫生成器函式來建立。生成器函式是指包含關鍵字yield的函式。

3、 生成器可以通過.next()來執行。每呼叫一次，就執行程式碼，直到遇到yield關鍵字停止，並且返回yield關鍵字後面的表示式的值。

4、 可以通過呼叫send()函式來發送訊息到生成器中。a = yield l：表示將send的入參賦值給a。

5、 throw：允許客戶端傳入要丟擲的任何異常。

6、 和throw相同，只不過是要丟擲一個特定的異常：GeneratorExit。

7、 send只接受一個引數，但是可以通過傳遞元組的方式傳遞多個引數。

8、 類的方法也可以返回生成器，因為他本質上就是一個函式。

9、 在生成器使用的時候，如何獲取它自身的send和nex函式？通過send二次傳入是有些風險的，非常可能造成交叉引用，無法垃圾回收造成記憶體洩露。

10、 第一次，必須呼叫next來啟動生成器。

裝飾器的使用：

1、 裝飾器本質上來說就是函式（或者是可呼叫物件），他們接受函式物件。裝飾器僅僅用來裝飾或者修飾函式的包裝，返回一個修改後的函式物件，並將其賦值原來的標示符，並永久失去對原有函式的訪問。

2、 什麼是帶引數的裝飾器？其實就是一個函式，這個函式可以返回一個裝飾器，同時這個函式可以接受引數。

3、 不帶引數的裝飾器要返回一個函式，這個函式就是用來替換原有的標示符的。

defdecofun(fun):

def_mydeco(*args, **kwargs):

print('before fun!')

        ret = fun(*args, **kwargs)

print('after fun', ret)

return ret

return _mydeco#新的函式，用於替換原有標示符

@decofun

deffuntest():#funtest被替換為decofun

print('now in funtest!')

return1

funtest()

4、 裝飾器是可以重疊的，那麼他們的順序怎麼樣：

a) @decofun2

b) @decofun

c) deffuntest():

d) print('now in funtest!')

e) return1

f) 原理是，funtest首先被decofun包裝，然後再被decofun2包裝。也就是，呼叫的時候，首先呼叫的是最上面的裝飾器（也就是decofun2）的函式前面部分，然後再呼叫decofun的函式前面部分，之後再呼叫funtest。funtest返回後，首先呼叫的是decofun的函式後面部分，再呼叫decofun2後面部分。類似於一個棧的結構。

5、 裝飾器不要濫用。如果一個裝飾器只用了一次，要考慮他存在的必要了。

6、 攜帶引數的裝飾器：

7、 defdecoarg(arg):

a) defdecofun3(fun):

b) def_mydeco(*args, **kwargs):

c) print('decoarg before fun!', arg)

d)             ret = fun(*args, **kwargs)

e) print('decoarg after fun', ret)

f) return ret

g) return _mydeco

h) return decofun3

8、 裝飾器用到的一個最重要的技術，就是閉包。裝飾器函式返回的其實就是一個閉包。

9、 裝飾器也可以修飾類的__方法：

classtestc:

def__init__(self):

self.i = 1

@decoarg(1)

@decofun2

@decofun

def__call__(self):

print('i is %d' % self.i)

注意：裝飾器修飾類方法是無法被子類繼承的（或者說子類的方法是沒有被修飾的）。因為他本質上就是一個函式。

10、 裝飾器也可以使物件，比如：

a) class obj:

b)     def __init__(self, fun):

c)         self.fun = fun

d) 

e)     def __call__(self, *args, **kwargs):

f)         print('decofun before fun!', args, kwargs)

g)         ret = self.fun(*args, **kwargs)

h)         print('decofun after fun', ret)

i)         return ret

j) @objdeco

k) def funtest(a, b=2):

l)     print('funtest1 a , b =', a, b)

a) 這種方法看起來複雜了，但是可能會在有時候會比較有用。

11、 裝飾器可以修飾類。這個時候裝飾器接收的是一個類名，而返回的也是這個類名。它可以為這個類新增一些屬性或者進行一些操作。

協程的使用：

1、 協程（coroutine）是一個可以掛起，回覆，並且有多個進入點的函式。

2、 

XML的使用：

1、 處理xml訊息包比較好用的模組是xml.etree.ElementTree。

2、 Element執行xml的根節點。

3、 elem.find(path):查詢根節點下面路徑為path的子節點。

4、 elem.findall(path):同樣的子節點可能有多個，這裡會返回一個列表。

5、 elem.findtext(path):獲取指定路徑子節點的內容，這個我們會經常使用。

6、 elem.get(key);獲取屬性的值。

7、 上面如果沒用，則返回none

8、 elem.append:新增自節點。

9、 elem.tag：返回tag值，也就是name。

10、 elem.text:返回內容。

11、 elem.attrib:返回屬性的字典。

12、 SubElement：生成一個節點，自動新增為父節點的子節點。

13、 tostring：轉化為xml文字字串。但是不包括xml頭。如果編碼方式為UTF-8或者GB2312,gb2312都會產生xml頭；如果是utf-8,則不會產生xml頭

14、 fromstring：從字串轉化為ElementTree物件。和XML同樣的功能。

15、 elem.set();設定屬性值

time的使用：

1、 time.sleep()函式函式具有c下sleep函式功能，單位為秒，但是可以接受浮點數。這樣可以表示毫秒。

2、 ti = datetime.datetime.now()可以顯示當前的時間，包括當前的微秒也可以顯示出來。兩個的差值可以表示時間 的間隔：microsecondLong = timeLong.seconds * 1000000 + timeLong.microseconds。差值的成員是seconds和microseconds

3、 

OO的使用：

1、 如果不想讓成員變數或者方法被外部使用（也就是private特性），可以以__雙下劃線開通。

2、 屬性不但可以定義在init中，也可以定義在任意的方法中通過self定義。不過最好在init中定義。

3、 Python也可以實現抽象基類，也就是介面：

4、 __str__屬性可以將物件轉換為字串，也就是呼叫print(object)是會列印的字串。

5、 __call__(魔法方法)可以將物件作為函式來