兩本不錯的書：

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

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

一個開源代碼：openstack，關于云計算的，用Python寫的，可以重點學習一下。

套接字編程：

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

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

3、?獲取網卡的IP：

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

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

字符串的使用：

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

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

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

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

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)

內建函數：

string.capitalize()

把字符串的第一個字符大寫

string.center(width)

返回一個原字符串居中,并使用空格填充至長度width的新串

string.count(str,?beg=0,?end=len(string))

返回?str在string里面出現的次數，如果beg或者end指返回指定范圍內str出現的次數

string.decode(encoding='UTF-8',?errors='strict')

以?encoding指定的編碼格式解碼string，如果出錯默認報ValueError的異常，除非errors指定的是'ignore'或'replace'

string.encode(encoding='UTF-8',?errors='strict')

以?encoding指定的編碼格式編碼string，如果出錯默認報ValueError的異常，?除非errors指定的是'ignore'或者'repl

string.endswith(obj,?beg=0,?end=len(string))

檢查字符串是否以?obj結束，如果beg或者end指定則檢定的范圍內是否以obj結束，?如果是，?返回True,否則返回Fa

string.expandtabs(tabsize=8)

把字符串?string中的tab符號轉為空格，?默認格數tabsize是8.

string.find(str,?beg=0,?end=len(string))

檢測?str是否包含在string中，如果beg和end指定范則檢查是否包含在指定范圍內，如果是返回開始的索引值，返回-1

string.index(str,?beg=0,?end=len(string))

跟find()方法一樣，?只不過如果str不在string中會報一個異

string.isalnum()

a,?b,?c??R如果string至少有一個字符并且所有字符都是字母或數字回True,否則返回False

string.isalpha()

a,?b,?c??如果string至少有一個字符并且所有字符都是字母則返回T否則返回False

string.isdecimal()

b,?c,?d?如果string只包含十進制數字則返回True否則返回False.

string.isdigit()

b,?c?如果string只包含數字則返回True否則返回False.

string.islower()

b,?c?如果string中包含至少一個區分大小寫的字符，并且所有這些(大小寫的)字符都是小寫，則返回True，否則返回False

string.isnumeric()

b,?c,?d?如果string中只包含數字字符，則返回True，否則返回False

string.isspace()

b,?c?如果string中只包含空格，則返回True，否則返回False.

string.istitle()

b,?c?如果string是標題化的(見title())則返回True，否則返回False

string.isupper()

b,?c?如果string中包含至少一個區分大小寫的字符，?并且所有這些(區分大小寫的)字符都是大寫，則返回True，否則返回False

string.join(seq)

Merges?(concatenates)以string作為分隔符，將seq中所有的元素(的字符串表示)合并為一個新的字符串

string.ljust(width)

返回一個原字符串左對齊,并使用空格填充至長度width的新字符串

string.lower()

轉換?string中所有大寫字符為小寫.

string.lstrip()

截掉?string左邊的空格

string.partition(str)

e?有點像find()和split()的結合體,從str出現的第一個位置起,把?字?符?串string分?成?一?個3元?素?的?元?組(string_pre_str,str,string_post_str),如果string中不包含str則string_pre_str?==?string.

string.replace(str1,?str2,??num=string.count(str1))

把?string中的str1替換成str2,如果num指定，????????則替換不超過num次.

string.rfind(str,?beg=0,end=len(string))

類似于?find()函數，不過是從右邊開始查找.

string.rindex(?str,?beg=0,end=len(string))

類似于?index()，?不過是從右邊開始.

string.rjust(width)

返回一個原字符串右對齊,并使用空格填充至長度width的新字符串

string.rpartition(str)

e??類似于partition()函數,不過是從右邊開始查找.

string.rstrip()

刪除?string字符串末尾的空格.

string.split(str="",?num=string.count(str))

以?str為分隔符切片string，如果num有指定值，則僅分隔num個子字符串

string.splitlines(num=string.count('\n'))

b,?c按照行分隔，?返回一個包含各行作為元素的列表，?如果num指定則僅切片num個行.

string.startswith(obj,?beg=0,end=len(string))

b,?e檢查字符串是否是以obj開頭，是則返回True，否則返回False。如果beg和end指定值，則在指定范圍內檢查.

string.strip([obj])

在?string上執行lstrip()和rstrip()

string.swapcase()

翻轉?string中的大小寫

string.title()

b,?c???返回"標題化"的string,就是說所有單詞都是以大寫開始，其余字母均為小寫(見istitle())

string.translate(str,?del="")

根據str給出的表(包含256個字符)轉換string的字符,要過濾掉的字符放到del參數中

string.upper()

轉換?string中的小寫字母為大寫

string.zfill(width)

返回長度為?width的字符串，原字符串string右對齊，前面填充0

正則表達式

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

returnnode.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?

生成器表達式定義：

[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:對列表處理，返回的是列表的索引以及節點。

forindex,?nodeinenumerate(timerList):

iftimerId?==?node.timerIdandtimerEvent?==?node.timerEvent:

deltimerList[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??inmyFile.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)

returnret

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)returnret

g)return_mydeco

h)returndecofun3

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也可以實現抽象基類，也就是接口

5、?__call__(魔法方法)可以將對象作為函數來調用。給它一個入參就可以。:4、?__str__屬性可以將對象轉換為字符串，也就是調用print(object)是會打印的字符串。

def__call__(self,?protoVer):

returnapi.protoModules[protoVer].TimeTicks(

(time.time()-self.birthday)*100

)

它的作用：比較常用的是作為回調，因為他可以保存狀態信息。它和閉包類似，可能比閉包的可讀性要好一點。

6、?對象實例是否可以刪除？

7、?Python參考手冊要好好看一下。

8、?python的static方法使用的是裝飾器語法：@staticmethod.

9、?對類的調用還有一個方法：CALSS.method(object)。

10、?子類中，如果想調用父類的方法，可以通過：

parent.method(self).

不過還有更好的方法：

super(child,?self).foo()//注意：這里是根據子類的類型獲取父類的方法。它的好處是不用明顯給出基類的類型。

11、?cls：類方法的第一個參數。通常表示類的類型，可以通過cls()來生成實例。

a)@classmethod

b)defspawn(cls,?*args,?**kwargs):

c)"""Return?a?new?:class:`Greenlet`?object,?scheduled?to?start.

d)

e)?????????The?arguments?are?passed?to?:meth:`Greenlet.__init__`.

f)?????????"""

g)g?=?cls(*args,?**kwargs)

h)g.start()

i)returng

12、?繼承，如果子類定義了__init__函數，子類的init函數不會默認調用父類的init函數，需要手動調用：parent.__init__。這一點是和c++有區別的。如果子類沒有定義__init__，則子類會調用父類的__init__。這里可以發現，其實，子類如果定義了init函數，是對父類的init的一個覆蓋。

13、?super注意：！！！它只能用在新式的類定義中。什么是新式的？原來只是基類定義時繼承object！！！。

14、?繼承如何繼承方法：只要繼承一個類，就會繼承這個類所有的方法，包括__init__,__del__。但是如果子類重寫某方法，就會覆蓋父類的方法，不會再調用父類的方法了。如果想調用父類的方法，可以通過super的方式調用。

15、?繼承如何繼承屬性：只要不覆蓋父類__init__方法，或者調用了父類的__init__方法，就會繼承父類__init__屬性的方法。繼承后也可以更改這些屬性。

16、?父類如何防止被繼承：方法或者屬性以__開頭，則可以防止被繼承。

17、?根據我的經驗，其實可以以一種本質的方式理解Python的繼承：Python的類就是一些方法的集合，繼承一個類就是繼承這個類的所有的方法。如果在子類中定義一個方法，其實是更改了這個類的符號。而屬性，則可以在所有的方法中定義，只要調用了定義屬性的方法，調用父類，則是繼承父類的屬性，調用子類定義屬性的方法，則是定義子類的方法。

18、?property：

a)?classc(object):

b)def__init__(self):

c)self._num?=1

d)@property

e)defnum(self):

f)returnself._num?*10

g)@num.setter

h)defnum(self,?v):

i)self._num?=?v

j)@num.deleter

k)defnum(self):

l)pass

m)o?=?c()

n)?print(o.num)

o)o.num?=20

p)?print(o.num)

q)?這樣的好處是，可以在操作屬性時，不用顯示為方法調用，更加可讀。同時又可以統一入口。：注意，它也必須繼承object才可以。

19、?OO中的垃圾回收：Python的垃圾回收使用的是符號引用計數。那么，如果在一個函數中申請一個對象，然后返回它的一個屬性或者方法，這個時候對象的符號引用已經去掉，對象是否會釋放？

a)?classchild(parent):

b)def__init__(self):

c)self.i?=8888

d)

e)deffoo(self):

f)print('-----------------------')

g)

h)def__del__(self):

i)print('now?in?del?child')

j)super(child,self).__del__()

第一種情況，返回的是屬性

k)def?refun():

l)o?=?child()

m)return?o.i

n)I=?refun()

o)這個時候，對象o會馬上釋放。因為o.i其實就是一個對象的引用，和o沒有關系

第二種情況，返回的是方法

a)def?refun():

b)o?=?child()

c)return?o.foo

d)foo?=?refun()

e)這個時候，對象o要等到foo釋放的時候再釋放，因為foo中包含了o的引用(foo的入參self)

20、?對于對象的屬性，如果屬性是可讀寫的，則第一步沒有必要用@property修飾。可以直接使用。后面如果有需要，在進行修飾。這樣既減少了工作，修改時，也不會對原有代碼進行改動。

模塊的使用：

1、?如果不想將模塊的某些函數和變量被別的模塊使用，可以以單下劃線開頭。這樣import?*是沒有的，但是使用import?mode，然后mode._fun仍然可以調用。在class中是以雙下劃線開頭的。

2、?使用from。。。import導入的符號，應該是本地符號，更改的話，無法更改模塊中的值。可以通過mode.name=來修改。

3、?__init__.py的作用：可以這樣理解：包也是一個對象，這個py就是這個包的構造函數。導入這個包，就會自動的執行__init__.py。如果在這個py中導入其他符號，import這個包并且加*也會導入這個符號。

4、?import?*無法導入模塊中以_開頭的符號。但是，不用*是可以的。

5、?import的本質也是創建一個符號，指向一個對象的引用。這個符號和被import的模塊的符號是沒有關系的。和c的extern不一樣。extern可以更改變量的值，但是，這在Python中是不可以的。

fromsrctestimportitest,outitest,?setitest

importsrctest

#?itest?=?9#這個地方其實改變的是本模塊中符號的引用，無法更改srctest中對應符號。

#srctest.itest?=?9#這個可以更改srctest中的itest

setitest(9)#這個可以更改srctest中的itest，但是改變不了當前模塊的itest，也就是，這種設置是無法同步的。

print(itest)#打印當前模塊的itest

printitest()#打印srctest中的itest

Python的設計哲學：看似不方便的背后，其實有Python的設計哲學。便捷性很多時候都是模塊性的大敵。在軟件開發中，模塊間的最短路徑未必是最合理路徑，而且往往是最不合理路徑。它會破壞軟件原有的交互原則。

Python這樣設計的理由應該是，盡量將數據和對數據的操作放在一起。如果數據會擴散，那么，就將數據設計為只讀的。這樣有助于提高程序模塊的內聚性(全局變量是內聚性的大敵)，降低耦合性。降低程序的復雜性(數據只讀，調試根據方便)。

srctest.itest是可以改變itest的值的，說明我們可以通過改變這個對象的屬性來改變對象(模塊也是對象)。

可能有一點小題大做。

6、?兩個模塊不可以雙向import。那萬一兩個模塊都要互相調用對方怎么辦？Python的設計哲學告訴你，這不是一個好的實踐，所以這樣不行。應該怎么弄？一個模塊調用另外一個模塊，如果被調用模塊想調用調用模塊的方法，通過回調的形式。這樣可以保證，模塊間的連接都是單向的。

日志的使用：

1、?日志的標準模塊logging基本可以滿足我的工作。

2、?設置log的初始化工作：

logging.basicConfig(

filename?="test.log",

format?="[%(asctime)s-%(levelname)s]?%(message)s?[%(filename)s,%(lineno)d]",

level?=logging.INFO,

datefmt?="%F?%T")

3、?除此之外，一個比較強大的功能就是過濾功能：可以針對級別，文件，行號等等很多的東西進行過濾。

4、

自省的使用：

1、?type()可以查看對象的類型。這就是自省。也就是可以看看自己是什么類型。這個功能在動態語言中非常有用。

2、?getattr函數：這是個非常有用的函數，它可以根據字符串，從模塊，類，對象實例中獲取屬性和方法的應用并且調用。這個功能非常類似于c語言的函數指針，以及c++中的成員函數的指針。

1)從模塊中獲取函數和成員

importtestfun

tf?=?getattr(testfun,'test')

tstr=?getattr(testfun,'str')

2)從類中獲取屬性和方法

classtest():

tst?=?2

def__init__(self):

self.abc?=1

defmethod(self):

print('in?test.method',self)

def__test(self):

print('in?test')

tm?=?getattr(test,'method’)#獲取類方法method函數指針。因為沒有實例，所以調用必須用下面的方法：

t?=?test()

tm(t)#申請一個實例，并且作為第一個參數傳進去。

tm?=?getattr(test,'__test’)#這里會報錯，也就是無法獲取私有方法。

tabc?=?getattr(test,'abc’)#這是錯誤的。無法獲取。

ttst?=?getattr(test,'tst’)#這是可以的。。

3)從對象實例中獲取屬性和方法

t?=?test()

tm=?getattr(t,'method')

tm()#可以這樣調用，而不用傳入t實例。

tabc?=?getattr(test,'abc’)#可以獲取實例的屬性。

3、?callable：函數表示某個對象是否可以調用。它和getattr結合起來，可以獲取一個對象中的所有的method列表：

methods?=?[method?for?method?in?dir[object]?if?callable(getattr(object,?method))]

4、?自省也叫放射。

5、?exec(‘print?“test”‘)：可以執行字符串代碼。這個特性有助于動態執行代碼，可以用于機器學習，自動生成代碼。

exec的參數可以使一個打開的文件對象，string，code?object。

code?object可以通過函數

類似的方法：execfile(filename[,?globals[,?locals]])。

6、?可以更改類的方法，將它指向一個新的方法。如下：

a)?classctest():

b)deftest(self):

c)print('c?test?test')

d)?deftestfun():

e)print('test?fun?!')

f)c=?ctest()

g)c.test?=?testfun

h)c.test()

對象c的方法test被替換為新的方法：testfun。這個特性有助于根據動態的代碼實現，但是往往會增加代碼的透明性。

類似的，setattr也可以實現這樣的功能。delattr可以刪除屬性。

setattr(c,'test',?testfun)

delattr(c,'test')

c.test()#這里調用的其實就是ctest的test方法。也就是說，delattr會首先刪除setattr設置的屬性，如果在調用一次delattr，才會刪除c的test方法。但是如果多調用幾次setattr，也只要調用一次delattr即可刪除。所以，要刪除一個方法，最多調用兩次delattr。

這個特性可以用于動態更改代碼。也可用于補丁。

setattr無法對Python的c擴展模塊進行操作。

7、?如何判斷一個變量是否存在：

‘v’?in?dir()

‘v’?in?locals.key()

配置文件讀取的使用：

1、?使用模塊ConfigParser。實例如下：

conf?=ConfigParser()

conf.read("snmp_agent.ini")

print(conf.get("main","log_level"))

print(conf.getint("main","ne_agent_port"))

print(conf.get("main",?"ne_agent_qip"))

異常的使用：

1、?盡量少用。它會使程序難以理解，而且還會發生不可預知的情況，比如異常的發生使程序的狀態變為一個未知狀態。

2、?可以尋找替代方案。

3、?程序非常重要，不可以停止，可以在主循環包裝在異常處理中運行。

4、?打印出異常的信息，供后面的定位：log.error(traceback.format_exc())

5、?raise在引發異常的時候，可以傳遞引發一場的額外數據。形式如下：

raise?Exception,?1

捕獲方法：

except?CallExit,?e:

e就是那個額外數據1。(但是奇怪的是它的類型不是1)

6、?如何捕獲一個異常，進行處理，然后在把它拋出：

except:

forfletinfletList:

flet.throw()

info?=?sys.exc_info()

raiseinfo[0],?info[1],?info[2]

7、?如何使用異常才是Pythonic的做法？這個要看一下。

類型系統

1、?類型也是對象。比如：inttype?=?int,然后，n?=?inttype(‘256’)，這樣可以把字符串轉化為int值。

2、?另外，是否可以把字符串轉化為關鍵字，或者對象？比如，一個變量，abc,是否可以通過’abc’來引用？

OS的使用

os中有很多可以直接利用的東西，比如，判斷文件是否存在，刪除文件等。這樣可以不用再執行shell命令。

os.rremove(path):刪除文件

os.system(‘ls’);執行shell命令

文件的使用

1、?打開使用函數open，模式和linux?c類似。有一個不同的地方時，可以選擇，直接操作磁盤還是操作內存。

2、?readline可以讀取一個文件的一行。

3、?readlines：返回每一個列的列表。對應writelines。

4、?文件迭代器：

f?=?open(‘fliename’)

for?line?in?f:

process(line)

f.close()

或者更簡潔的：

for?line?in?open(filename):

process(line)

5、?文件迭代器的使用：

如果文件很大，readlines可能會占用過多的內存。所以，Python提出一種類似于惰性求值的惰性迭代。

有兩種方案：fileinput和文件迭代器：

import?fileinput

for?line?in?fileinput.input(filename)

process(line)

文件迭代器：

f?=?open(filename)

for?line?in?f:

process(line)

6、?如何判斷文件是否存在：

import?os

os.path.isfile('/home/keepshell')

os.path.exists('/home/keepshell')

7、?如何判斷目錄是否存在：

import?os

os.path.isdir('/home')

os.path.exists('/home')

數據庫的使用

1、?數據庫中的字段使用的utf8格式編碼，但是讀取出來卻是問號。這個問題的解決可以通過在查詢的時候指定編碼方式來解決，只要執行sql語句：Query_Execsql(pdb,?"SET?NAMES?'utf8'");

注意，這個需要在連接后馬上進行。并且，在其他的操作中，會一直使用這種編碼。除非再次更改。

2、?fetchone()：返回一條記錄。fetchall()：返回所有的記錄。

3、?可以使用一個簡單的方法獲取所有的記錄：

cur.execute(sql)

fortel,?name,?pwdincur:

printtel,?name,?pwd

FTP的使用

Python的標準模塊ftplib就可以支持FTP。

幾個函數：

FTP(host='',?user='',passwd='',?acct='',???????????????timeout=_GLOBAL_DEFAULT_TIMEOUT)：如果參數中有user，則Connect();如果同時也有user，則login()。如果沒用這些參數，后要自己調用connect和login。

connect(self,?host='',?port=0,?timeout=-999):如果端口不是標準端口，則要手動調用connect。

login(user?=?'',?passwd?=?'',?acct?=?''):登陸。

pwd():獲得當前的工作路徑。

cwd(path):更改當前的工作路徑。

dir(path,cb):顯示目錄中的內容。cb為文件的處理函數。會傳遞給retrlines。這個函數可以獲取一個目錄下的所有的內容。

retrlines(self,?cmd,?callback?=?None):下載文本文件。cmd的形式為“RETR?FILENAME”，callback是一個函數，要處理文本文件的每一個行。這里一個問題，如果直接用file的write方法，則會丟失換行符。而又沒有writeline函數。

retrbinary(self,?cmd,?callback,?blocksize=8192,?rest=None):下載二進制文件，cmd的形式為“RETR?FILENAME”，callback是一個函數，要處理文本文件的每一個塊。默認大小事8k，但是可以更改。

storlines(self,?cmd,?fp,?callback=None):上傳文本文件。cmd的形式為“STOR?FILENAME”。fp是一個文件對象，必須有readline方法。callback：每傳送一行，就會調用這個函數。

storbinary(self,?cmd,?fp,?blocksize=8192,?callback=None,?rest=None):?上傳二進制文件。cmd的形式為“STOR?FILENAME”。fp是一個文件對象，必須有read(num_bytes)方法。默認大小事8k，但是可以更改。

quit():退出。

字節的使用

1、?ord：可以見字符轉化為int類型的值。

2、?chr：ord的方向操作。可以見int類型值轉換為字符。

字符編碼的使用

1、?encode是將Unicode轉化為str，decode是將字符串轉化為Unicode。所以，一個字符串要轉化為另一種格式可以：

s?=?‘中文’

s.decode(fromcodec).encode(tocodec)

也可以直接使用：s.encode(tocodec)。這個時候，相當于默認調用了decode，并且使用的是默認的編碼方式。

源碼安全

1、?Python代碼如果直接發布，可能會暴露源碼。

2、?一個方法是利用c擴展Python，來代替核心模塊。

3、?另一個折中的方法就是對源碼進行編譯，生成pyc或者pyo文件。這些事字節碼文件。可能會被反編譯。所以，可能需要研究一下Python的pyo生成和加載方式，來生成更安全的Python字節碼。網上說可以修改Python源碼的opcode。沒有研究過。

4、?命令：python?-m?compileall。

5、?也可以在Python中使用：

a)?import?compileall

b)

c)?compileall._dir('Lib/',?force=True)

d)

e)?#?Perform?same?compilation,?excluding?files?in?.svn?directories.

f)?import?re

g)?compileall._dir('Lib/',?rx=re.compile('/[.]svn'),?force=True)

h)

GC

1、?OO中的垃圾回收：Python的垃圾回收使用的是符號引用計數。那么，如果在一個函數中申請一個對象，然后返回它的一個屬性或者方法，這個時候對象的符號引用已經去掉，對象是否會釋放？

a)?classchild(parent):

b)def__init__(self):

c)self.i?=8888

d)

e)deffoo(self):

f)print('-----------------------')

g)

h)def__del__(self):

i)print('now?in?del?child')

j)super(child,self).__del__()

第一種情況，返回的是屬性

k)def?refun():

l)o?=?child()

m)return?o.i

n)I=?refun()

o)這個時候，對象o會馬上釋放。因為o.i其實就是一個對象的引用，和o沒有關系

第二種情況，返回的是方法

f)def?refun():

g)o?=?child()

h)return?o.foo

i)foo?=?refun()

j)這個時候，對象o要等到foo釋放的時候再釋放，因為foo中包含了o的引用(foo的入參self)

k)

2、?如果兩個對象交叉引用，是否會自動回收？不會。同樣，如果一個對象把生成的對象賦值給它自身的一個屬性，那么它也不會自動回收。

3、

c擴展

1、?可以使用swig來創建c的擴展程序，非常方便。目前沒有時間研究內部機制，先暫時使用，后面在研究吧。

2、?swig使用步驟：為庫的頭文件建立.i文件：

%{

/*?Includes?the?header?in?the?wrapper?code?*/

#include?"code.h"

#include?"sip.h"

%}

/*?Parse?the?header?file?to?generate?wrappers?*/

%include?"code.h"

%include?"sip.h"

3、?使用swig命令生成py腳本及對應的C文件：swig–python?sip.i。

4、?將生成的c源文件放到c擴展庫中進行編譯。

5、?這里有一個要注意：生成的動態鏈接庫，必須是_sip.so，否則無法調用。swig是寫死的。_sip.so需要拷貝到：?/usr/local/lib/python2.7/site-packages/路徑下。

6、?Makefile文件中，對于庫引用的其他的庫，必須顯示的指出，否則Python無法找到對應的庫。

7、?如何在c的擴展庫中調用Python的函數：

swig是不支持直接在c的擴展庫中調用Python函數的。它只支持將C的接口作為回調函數設置給c的庫。

實現這個功能需要利用Python的c?API和ctypes來實現。

Python?c?的api包含一系列的函數：

PyCallable_Check：檢查對象是否可調用；

PyArg_ParseTuple：解析參數列表，將Python參數解析為c；

PyEval_CallObject：調用對象；

Py_BuildValue：將c變量打包為Python的參數對象。

好了，有這些就足夠了。

假設c庫中有一個設置回調函數接口：

void?set_callback_fun(void?(*fun)(int,?int?,?int))

{

}

下面是c擴展庫中要添加的代碼：

//全局變量，保存Python中要回調的可調用對象。

static?PyObject?*gCallbackFun?=?NULL;

//調用上面函數設置的python腳本函數

//Python可調用對象的轉換函數，轉化為C的調用方式

static?void?callbacfun(int?type,int?chn,int?dataType)

{

PyObject*?pArgs?=?NULL;

PyObject*?pRetVal?=?NULL;

int????nRetVal?=?0;

pArgs?=?Py_BuildValue("(i,?i,?i)",?type,?chn,?dataType);//將c的參數轉化為Python的參數對象

pRetVal?=?PyEval_CallObject(gCallbackFun,?pArgs);//調用Python的可調用對象。

Py_DECREF(pArgs);

Py_DECREF(pRetVal);

}

///?set_callback_fun函數的包裝函數

static?PyObject?*wrap_set_callback_fun(PyObject?*dummy,?PyObject?*args)

{

PyObject?*temp?=?NULL;

if?(PyArg_ParseTuple(args,?"O:set_callback_fun",?&temp))?{//獲取Python對象

if?(!PyCallable_Check(temp))?{//檢查對象是否可以調用

PyErr_SetString(PyExc_TypeError,?"parameter?must?be?callable");

}

Py_XINCREF(temp);?????????/*?Add?a?reference?to?new?callback?*/

Py_XDECREF(gCallbackFun);?/*?Dispose?of?previous?callback?*/

gCallbackFun?=?temp;???????/*?保存回調對象?*/

}

set_callback_fun(callbacfun);//注意，這里掉一下包，用一個C的函數注冊到c庫中。

return?Py_BuildValue("i",?(gCallbackFun?==?NULL)???0?:?1);

}

注意：如果對象不可調用，會段錯誤。后面要解決一下。

Python代碼：

CBFUNC??=?CFUNCTYPE(c_int,?c_int,?c_int,?c_int)//創建一個c函數類型的對象工廠，該函數返回值為int，有三個入參，都為int。

callbakFunc=?CBFUNC(pyFun)//根據Python可調用對象生成函數。

set_callback_fun(callbakFunc)//設置回調函數

注意：pyFun必須要有返回值。否則會報異常。

另外，我發現，不用CFUNCTYPE來生產c回調函數，直接用pyFun，也是可以的。至于區別，后面在研究一下吧，要寫代碼了。

幾個異常問題：1、一個可以使用CFUNCTYPE，但是一個一使用它就段錯誤。2、回調函數可以不返回值，也是可以的。但是一個不返回就不可以。

在Python中使用c擴展時向C傳遞數組：

8、?如果一個函數的參數是一個數組(指針)，Python如何傳遞？下面的方法是可以直接傳遞列表。把這個加到.i文件中。

%{

static?int?convert_darray(PyObject?*input,?int?*ptr,?int?size)?{

int?i;

if?(!PySequence_Check(input))?{

PyErr_SetString(PyExc_TypeError,"Expecting?a?sequence");

return?0;

}

if?(PyObject_Length(input)?!=?size)?{

PyErr_SetString(PyExc_ValueError,"Sequence?size?mismatch");

return?0;

}

for?(i?=0;?i?

PyObject?*o?=?PySequence_GetItem(input,i);

if?(!PyFloat_Check(o))?{

Py_XDECREF(o);

PyErr_SetString(PyExc_ValueError,"Expecting?a?sequence?of?floats");

return?0;

}

ptr[i]?=?PyFloat_AsDouble(o);

Py_DECREF(o);

}

return?1;

}

%}

%typemap(in)?int?[ANY](int?temp[$1_dim0])?{

if?(!convert_darray($input,temp,$1_dim0))?{

return?NULL;

}

$1?=?&temp[0];

}

9、?如果一個結構體中有一個int類型數組，應該如何賦值？

在.i中增加下面代碼：

%include?"carrays.i"

%array_class(int,?intArray);

在Python中申請數組：

a?=?intArray(10)，將A復制給數組成員即可。

代碼錯誤檢查

1、?今天遇到兩個問題：

a)?類中方法：class?_registerEvent(notifyEvent):?def?_sendRegRsp(self,?voiceres,?reqId,?result,?reason,status):，調用時參數個數少一個：self._sendRegRsp(voiceres,?reqId,?'success',?'normal')???。結果是沒有任何提示，并且，不知道調用了什么函數。這個問題有點匪夷所思。后面好好查看一下。

b)?抽取函數后，有時忘了返回值，當時卻用到了返回值：

i.?defcreateWirelessSdp(voiceRtpPort,?voiceTbcpPort):

ii.voicesdp?=?SIP_SDP()

iii.voicesdp.a_use?=1

iv.?sdp?=?createWirelessSdp(1000,2000)

v.?結果也是沒有任何提示，sdp為None。

2、?總結：寫Python代碼，需要使用代碼檢查工具，比如，pylint等。后面引進一下。

程序運行

1、?如何獲取命令行參數：

a)?importsys

b)

c)?print(sys.argv[1])

d)sys.argv[1]就是第一個參數。0是腳本的名稱。

2、

關于性能

1、?timeit：可以統計程序的運行時間。目前沒有時間，抽時間好好看看。

timeit(cut1,?number=10000)：cut1是函數名，number是執行次數。

2、?pypy可以將Python代碼翻譯為可執行程序，它的效率可以提高4倍左右。但是，內存的占用可能會很大。(沒有試過。)

3、

其他：

1、?腳本語言的進程名稱顯示為：python，如果一個服務器上有多個進程，那么將不易發現那個進程是哪個程序。可以使用第三方開源的庫來解決這個問題：setproctitle.

fromsetproctitleimportsetproctitle,getproctitle

print('當前的進程名：%s'%?getproctitle())

setproctitle('proctitle')

print('設置后的的進程名：%s'%?getproctitle())

2、?with語法：with?open(‘file’,?‘r’)?as?f:

code

可以是try的另一種形式。

可以執行with操作的類型：

file

decimal.Context

thread.LockType

threading.Lock

threading.RLock

threading.Condition

threading.Semaphore

threading.BoundedSemaphore

3、?產生隨機數：random.randint(100000,?999999)

4、?回調函數的使用：設置回調函數的時候，很多時候要使用閉包。避免閉包的一個方法是：

a)?defsetCancelFun(cancelFun,?*args,?**kwargs):

b)'''如果為None表示刪除取消函數,后面跟的是cancel函數的參數。這樣可以避免上面創建閉包。'''

c)global_cancelFun,_cancelArgs,_cancelKwargs

d)_cancelFun?=?cancelFun

e)_cancelArgs?=?args

f)_cancelKwargs?=?kwargs

g)

h)?def__execCancelFun():

i)'執行取消操作。因為在throw和kill的時候會執行此函數，所以，暫時沒有看到會在外面調用此函數。屏蔽后，接口的簡單性會提高'

j)global_cancelFun,_cancelArgs,_cancelKwargs

k)ifcallable(_cancelFun):

l)_cancelFun(*_cancelArgs,?**_cancelKwargs)

m)_cancelFun?=None#防止重復調用

n)

o)?deftest(a,?b,?c):

p)print('--------test:',?a,b,c)

q)

r)setCancelFun(test,1,2,3)

s)__execCancelFun()

也就是增加可變參數。

Python：一切皆符號？

總結

以上是生活随笔為你收集整理的python程序开发总结_python开发总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。