前言
兩本不錯的書:
《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])
4、 epool使用:
1) epoll.poll()函數的入參是等待時間,如果缺省,負值,None,則會阻塞住。非阻塞的做法是epoll.poll(0)
2)
5、
字符串的使用:
1、 Python的字符串是不可以改變的。但是你可以操作字符串以形成新的字符串。
2、 字符串中刪除一個字串。沒有直接提供這個方法,但是replace可以實現:
"abcdef".replace(" ", "")
同樣的功能還有一個方法:translate。它的原有作用是將字符串中的某個字符替換爲另外一個字符,注意,不是字符串。它的第一個參數是一個轉換表。第二個參數是要刪除的字符串。我們可以利用第二個參數del,實現這個功能。同時,第一個參數設置爲None。
translate可能更高效一點。另外,它的第二個參數可以使一個字符串,含有多個字符,這樣就會刪除多個。
注意:translate方法不會對這個字符串操作,而是返回一個新的字符串。
txt = txt.translate(None, ' \r\n\t;')
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 -mcompileall -fl ../src;
c) python -mcompileall -fl ../src/micbase;
d) mkdir%(packname)s;
e) mdkir%(packname)s;
f) ''' % {'packname':sys.argv[1], }
g) print(sh)
11、 字符串的解析:如果出現錯誤:UnicodeEncodeError:”ascii” codec cannt encode charactersin position 36-39: ordinal not in range(128).
問題的原因是系統默認的編解碼庫不支持Unicode,所以,需要設置編解碼庫。
方法:
reload(sys) #必須要重新加載纔可以。
sys.setdefaultencoding(‘gb2312’)
內建函數:
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:可以對字符串進行分割,這裏是根據模式分割。
re.split('@|:|-','123@sdfsa:sdf-223:342-23-23-21')
將字符串根據模式'@|:|-'分割,
5、
函數的使用:
1、 函數的作用域:函數中定義一個變量,如果和全局變量重名,則全局變量名稱就會被覆蓋,也就是,這裏對這個變量的更改,不會更改全局變量。但是,如果直接使用的話,是會使用全局變量的。同時,如果想要修改全局變量,需要制定是全局變量:global a
2、 xrange用法和range一樣,不過更爲高效,因爲他不會在內存中創建列表。所以,它只能用於循環。
3、 如果函數沒有return語句,則他的返回值爲None。
4、 關於函數的入參判斷:如果如此爲空,可能會發生異常。當異常發生後,可能會出現一種情況,一個事情做到了一半,就沒有在進行下去,可能會造成內存泄露。這個問題如何解決?按照C的方式,每個入參都做判斷是可以解決的,但是這樣太麻煩了。而且看很多開源代碼頁沒有這樣來做。是不是有更好的方法?換一種思路,在調用之前確保不爲空。在看看開源的代碼是怎麼做的。特別是openstack。
5、 可變入參:*args, **kwargs表示可變入參。
def funtest(a,b, c):
print(a, b, c)
def fun2(*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中是否存在。
如何建一個元組或者字典通過參數傳遞給一個函數?
def funtest(a,b, c):
print(a, b, c)
d = {'a':1, 'b':2,'c':3}
l = (1,2,3)
funtest(*l)
funtest(**d)
*和**在Python中可以實現這個功能。這樣會很靈活的。
*和**也可以單獨出現。但是,如果同時出現,*必須在**之前。
6、 默認參數或者可選參數,參數順序:調用時,可以指定默認參數中填充那個。
def funtest(a, b=1, c=2):
print(a, b, c)
funtest(1, c=5, b=6)
其實,即便定義爲:def funtest(a, b, c),也可以通過funtest(1, c=5, b=6)的形式調用。
7、 參數組:*args, **kwargs就是參數組,通過元組和字典將產生攜帶進來。這個特性有助於更爲動態的代碼生成。
8、 可變長度參數:
9、 函數的參數中如果有一個是元組,可以這樣:
def fun(a, (b,c)):
print(a, b, c)
fun(1, (1,2))
10、 關於回調,可以使用閉包,生成器,以及對象的__call__屬性。都可以封裝狀態。
11、 函數的可變入參:定義:def dlog(msg, *args):
這樣可以定義可變入參,後面根據msg以及args進行格式化。注意一點,args是元組的元組。
dlog(‘%s’, 1,2)
args是((1, 2), )。所以,在格式化的時候,要用:msg% args[0]
函數式編程:
1、 lambda使用的誤區:
錯誤的代碼:
for u in userList:
gcallinfo.userAdd(u)
curflet.addCompFun(lambda:gcallinfo.userLeave(u))
這裏是想爲每個用戶增加一個處理函數。但是結果是所有的用戶都是一個處理函數。原因是lambda它相當於是一個函數定義,而不是函數調用。即便是它出現在for循環中,它仍然是一個函數,而不是多個。
解決的方法是:
fun = lambda x:lambda :gcallinfo.userLeave(x)
for u in userList:
gcallinfo.userAdd(u)
curflet.addCompFun(fun(u))
使用兩個lambda,第一個lambda返回的是一個函數。
當然也可以這樣:
for u in userList:
gcallinfo.userAdd(u)
curflet.addCompFun((lambdax:lambda :gcallinfo.userLeave(x))(u))
但是我感覺這樣的可讀性不好。
2、
閉包的使用:
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會同步發生變化。在迭代過程中,字典不允許改變,否則會報異常。而且,viewitems的順序是不定的。
一個替代的方案是:
l = [1,2,3,4,5,6,7]
def yfun():
while True:
for i in l:
print(i)
yield
g = yfun()
列表在迭代的過程中,如果改變,是可以同步的。
10、 字典的鍵值比較規則:如果是內置類型(int,str,tuple),則是以他們的值作爲鍵值;如果是自定義對象,則是以對象的地址作爲鍵值。——這一點沒有完全證實。——最新的發現:對象的比較,內置類型,是因爲他們都重寫了默認的object的__eq__等方法,所以可以比較內容。自定義對象,沒有重寫,所以,他們的比較可能會不一樣。object默認的比較是什麼?目前還不明確,後面再補充吧。可能就是地址(或者對象的唯一標識),而不是對象的內容。涉及到字典,它不是使用的單純的比較,而是使用的__hash__,它返回的是一個hash值,字典就是根據這個hash只來散佈對象的。
集合的使用:
1、 集合內部使用hash算法。而有不是kv方式。某種情況下可能會方便。
2、 集合很方便的合併:
c = a | b
取差:c =
3、
列表的使用:
1、 列表的刪除:不可以在遍歷的過程中刪除鏈表,這樣會得到不可預知的後果。可以使用列表的過濾,來獲得新的列表。
2、 列表的過濾:
def filterFun(node):#這個函數做了兩個事情哎。
node.cycleCount = node.cycleCount -1
return node.cycleCount < 0
timeoutList = filter(filterFun, timerList)
對timerList中的每個節點執行函數filterFun,根據filterFun返回的結果,爲真的項組成一個新的列表。
3、 list的pop是刪除的最後一個元素。pop參數的默認值是-1且pop的對象不可以爲空列表。
4、 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)]
5、 生成器表達式:l = [node for node in xrange(5) if node - 3 < 0]:這個的這個方法一定程度上可以替代過濾器和map。
生成器表達式定義:
[expr foriter_var in iterable if cond_expr]
l = [2 for x inxrange(5)]#結果是生成一個含有5個2的列表
一個特殊的用法,條件可以由多個:
[str(i) for i in xrange(8) if i != 5 if i != 4]
6、 print(reduce(lambda x,y: x*y, [2 for x in xrange(38)]))
上面的這個語句是計算2的38次方的值。它用到的是二元函數reduce。它第一次調用是將第一個和第二個元素做入參,後面用他們的結果做x,新的元素做y,最後返回值。
另外,在獲取一個38個2的列表也可以使用:[2] * 38。這可能更可讀一點。
7、 enumerate:對列表處理,返回的是列表的索引以及節點。
for index, node in enumerate(timerList):
if timerId == node.timerId and timerEvent ==node.timerEvent:
del timerList[index]
8、 列表的分片:[1,2,3,4],l[1:-1]表示從索引從1到倒數第一個,不包含倒數第一個。如果要從某位置到最後,則應該:[1:]
9、 l[i:j:k]:表示切片,從i到j,步長爲k。
10、l[i:j]:表示從i到j,不包括索引j。
11、如何在列表的迭代過程中刪除元素:
如果在迭代過程中刪除,會遍歷不完全:
l = [1,2,3,4,5,6]
for i in l:
print(i)
if i%2 ==0:
l.remove(i)
這是一個方案,是通過切片操作獲取一個新的元素。
for x in a[:]:
if x < 0: a.remove(x)
條件表達式
1、 if 1 :print('------------'):這種方式也是可以的。
2、 return 1 if False else 100:這樣返回的是100
3、 (fun1 if 1 else fun)():選擇不同的調用函數。
4、
5、 條件表達式類似於c語言的三元表達式:C?X:Y。
6、 條件表達式的語法:X if C else y.如果C成立,這是X,否則是Y。注意:else必須有,否則編譯不過;不可以是elif。
7、 用法1-賦值:
x , y = 3, 4
min = xif x < y else y
print(min)
8、 用法2-函數調用:
def fun():
print('fun')
def fun2():
print('fun2')
(fun if 0 else fun2)()
其實就是所有可以使用表達式的地方。
排序
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來啓動生成器。
11、
a) def fun():
b) print(1)
c) yield
d) print(2)
e) yield
f)
g) g = fun()
h) cb = g.next
i) print('-----')
j) cb()
k) print('-----')
l) cb()
m) print('-----')
上面的輸出:
n) -----
o) 1
p) -----
q) 2
r) -----
說明:調用第一個next函數後,纔會進入函數執行,直到遇到yield爲止。然後再調用下一個next的時候,執行到下一個yield。如果沒有yield了,則觸發一個異常。
12、
裝飾器的使用:
1、 裝飾器本質上來說就是函數(或者是可調用對象),他們接受函數對象。裝飾器僅僅用來裝飾或者修飾函數的包裝,返回一個修改後的函數對象,並將其賦值原來的標示符,並永久失去對原有函數的訪問。
2、 什麼是帶參數的裝飾器?其實就是一個函數,這個函數可以返回一個裝飾器,同時這個函數可以接受參數。
3、 不帶參數的裝飾器要返回一個函數,這個函數就是用來替換原有的標示符的。
def decofun(fun):
def _mydeco(*args,**kwargs):
print('before fun!')
ret =fun(*args, **kwargs)
print('after fun', ret)
return ret
return _mydeco#新的函數,用於替換原有標示符
@decofun
def funtest():#funtest被替換爲decofun
print('now in funtest!')
return 1
funtest()
4、 裝飾器是可以重疊的,那麼他們的順序怎麼樣:
a) @decofun2
b) @decofun
c) def funtest():
d) print('now in funtest!')
e) return 1
f) 原理是,funtest首先被decofun包裝,然後再被decofun2包裝。也就是,調用的時候,首先調用的是最上面的裝飾器(也就是decofun2)的函數前面部分,然後再調用decofun的函數前面部分,之後再調用funtest。funtest返回後,首先調用的是decofun的函數後面部分,再調用decofun2後面部分。類似於一個棧的結構。
5、 裝飾器不要濫用。如果一個裝飾器只用了一次,要考慮他存在的必要了。
6、 攜帶參數的裝飾器:
7、def decoarg(arg):
a) def decofun3(fun):
b) def _mydeco(*args, **kwargs):
c) print('decoargbefore fun!', arg)
d) ret = fun(*args, **kwargs)
e) print('decoargafter fun', ret)
f) return ret
g) return _mydeco
h) return decofun3
8、 裝飾器用到的一個最重要的技術,就是閉包。裝飾器函數返回的其實就是一個閉包。
9、 裝飾器也可以修飾類的__方法:
class testc:
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('decofunafter fun', ret)
i) return ret
j) @objdeco
k) def funtest(a, b=2):
l) print('funtest1a , 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也可以實現抽象基類,也就是接口:
注意:不可以對私有屬性和方法執行@abstractmethod。否則會失敗。因爲,私有的無法被重寫,所以,無法生成被實例化。 |
|
4、 __str__屬性可以將對象轉換爲字符串,也就是調用print(object)是會打印的字符串。
5、 __call__(魔法方法)可以將對象作爲函數來調用。給它一個入參就可以。:
def __call__(self, protoVer):
return api.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) def spawn(cls, *args, **kwargs):
c) """Return a new :class:`Greenlet` object, scheduled tostart.
d)
e) The arguments are passed to:meth:`Greenlet.__init__`.
f) """
g) g = cls(*args, **kwargs)
h) g.start()
i) return g
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) class c(object):
b) def __init__(self):
c) self._num = 1
d) @property
e) def num(self):
f) return self._num * 10
g) @num.setter
h) def num(self,v):
i) self._num = v
j) @num.deleter
k) def num(self):
l) pass
m) o = c()
n) print(o.num)
o) o.num = 20
p) print(o.num)
q) 這樣的好處是,可以在操作屬性時,不用顯示爲方法調用,更加可讀。同時又可以統一入口。:注意,它也必須繼承object纔可以。
19、 OO中的垃圾回收:Python的垃圾回收使用的是符號引用計數。那麼,如果在一個函數中申請一個對象,然後返回它的一個屬性或者方法,這個時候對象的符號引用已經去掉,對象是否會釋放?
a) class child(parent):
b) def __init__(self):
c) self.i = 8888
d)
e) def foo(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修飾。可以直接使用。後面如果有需要,在進行修飾。這樣既減少了工作,修改時,也不會對原有代碼進行改動。
21、 子類無法繼承父類中以“__”開始的成員。
模塊的使用:
1、 如果不想將模塊的某些函數和變量被別的模塊使用,可以以單下劃線開頭。這樣import *是沒有的,但是使用importmode,然後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中是不可以的。
from srctest import itest, outitest,setitest
import srctest
# 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的設計哲學告訴你,這不是一個好的實踐,所以這樣不行。應該怎麼弄?一個模塊調用另外一個模塊,如果被調用模塊想調用調用模塊的方法,通過回調的形式。這樣可以保證,模塊間的連接都是單向的。
7、 模塊間相互引用全局變量:如果採用:from mode import vlaue的格式,引用的全局變量將會是一個新的符號,如果這個被模塊的變量重新複製,引用模塊中的變量不會同步更新的。這個是用可以使用import mode 的格式,然後使用mode.value形式引用。當然,不推薦模塊間相互引用全局變量。會增加模塊間的耦合。可以使用函數代替。
日誌的使用:
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、 自己寫了一個簡單的日誌模塊。遇到一個問題,如何獲得log的文件名和行號。
看了loging模塊的實現,它用了sys模塊:
def fun():
f =sys._getframe(0)
print(f.f_back)
co = f.f_code
print(co.co_filename,f.f_lineno, co.co_name)
def fun1():
fun()
fun1()
上面的代碼,sys._getframe就是獲取棧信息。參數0表示獲取的當前函數的棧。1表示獲取調用fun函數的地方。2表示調用fun1的地方。3的話會報錯,沒有足夠的調用深度。
可以從f.f_code中獲得文件名,行號,函數名。
f.f_back獲取上一層的棧。
最後,這個函數可以獲取上層函數的調用文件名和行號,函數:
def findCaler():
f =sys._getframe(2)
co = f.f_code
return co.co_filename,f.f_lineno, co.co_name
5、 ilog(traceback.format_exc()):這句代碼有問題,如果,如果traceback.format_exc()返回的字符串中包含百分號,則會導致異常。
自省的使用:
1、 type()可以查看對象的類型。這就是自省。也就是可以看看自己是什麼類型。這個功能在動態語言中非常有用。
2、 getattr函數:這是個非常有用的函數,它可以根據字符串,從模塊,類,對象實例中獲取屬性和方法的應用並且調用。這個功能非常類似於c語言的函數指針,以及c++中的成員函數的指針。
1)從模塊中獲取函數和成員
import testfun
tf = getattr(testfun, 'test')
tstr = getattr(testfun, 'str')
2)從類中獲取屬性和方法
class test():
tst = 2
def __init__(self):
self.abc= 1
def method(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 = [methodfor 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) class ctest():
b) def test(self):
c) print('c test test')
d) def testfun():
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()
配置文件讀取的使用:
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 :
for flet in fletList:
flet.throw()
info = sys.exc_info()
raise info[0], info[1], info[2]
7、 如何使用異常纔是Pythonic的做法?這個要看一下。
8、
9、 xcept (Exc1[, Exc2[, ... ExcN]])[, reason]: 可以處理多個異常
suite_for_exceptions_Exc1_to_ExcN
10、 捕獲所有異常
try:
:
except Exception, e:
# error occurred, log 'e', etc.
11、 先捕獲指定,再捕獲所有
try:
:
except (KeyboardInterupt, SystemExit):
# user wants to quit
raise # reraise back to caller
except Exception:
# handle real errors
12、 KeyboardInterrupt 和 SystemExit 被從 Exception 裏移出, 和 Exception 平級。
a) try:
b) :
c) except (KeyboardInterupt,SystemExit):
d) # user wants to quit
e) raise # reraise back to caller
f) except Exception:
g) # handle real errors
13、 在 try 範圍中沒有異常被檢測到時,執行 else 子句
a) try:
b) 3rd_party_module.function()
c) except:
d) log.write("*** caught exception inmodule\n")
e) else:
f) log.write("*** no exceptionscaught\n")
14、 finally 子句是無論異常是否發生,是否捕捉都會執行的一段代碼.你可以將 finally 僅僅配合try一起使用,也可以和try-except(else也是可選的)一起使用.
15、 .try-finally語句 try 中是否有異常觸發,finally 代碼段都會被執行
a) try-except-else-finally:
b) with語句:
c) with context_expr [as var]:
d) with_suite
16、 raise [SomeException [, args [, traceback]]] 。args 可以使一個元組。如果是一個對象,則它會把它封裝成一個元組。
try:
raise Exception, 1
except Exception, e:
print(e)
if e == 1://這是不可以的。e的類型是一個特殊的對象。正確的應該是:if e[0] == 1
print('\n222222222')
17、 標準異常:
18、
19、
類型系統
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()
或者更簡潔的:
forline in open(filename):
process(line)
5、 文件迭代器的使用:
如果文件很大,readlines可能會佔用過多的內存。所以,Python提出一種類似於惰性求值的惰性迭代。
有兩種方案:fileinput和文件迭代器:
import fileinput
for line infileinput.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')
8、 遍歷目錄路徑:os.listdir(‘/home’),返回值是一個列表。
9、 basename:去掉目錄名,返回文件名;dirname:去掉文件名,返回目錄名。
數據庫的使用
1、 數據庫中的字段使用的utf8格式編碼,但是讀取出來卻是問號。這個問題的解決可以通過在查詢的時候指定編碼方式來解決,只要執行sql語句:Query_Execsql(pdb,"SET NAMES 'utf8'");
注意,這個需要在連接後馬上進行。並且,在其他的操作中,會一直使用這種編碼。除非再次更改。
2、 fetchone():返回一條記錄。fetchall():返回所有的記錄。
3、 可以使用一個簡單的方法獲取所有的記錄:
cur.execute(sql)
for tel, name, pwd in cur:
print tel, 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、 由字符串轉化爲字節流:bytes = struct.pack('!2B2s2B2s2B2s', 3, 1, '11', 3, 1, '22', 3, 1,'22')
2、 處理後的字節流也可以使用字符串處理函數。
3、
字符編碼的使用
1、 encode是將Unicode轉化爲str,decode是將字符串轉化爲Unicode。所以,一個字符串要轉化爲另一種格式可以:
s = ‘中文’
s.decode(fromcodec).encode(tocodec)
也可以直接使用:s.encode(tocodec)。這個時候,相當於默認調用了decode,並且使用的是默認的編碼方式。
2、 直接對一個Unicode文本調用str()函數的時候可能會報錯:ASCII不支持等等。原因是默認的編碼方式ASCII,不支持多字節。可以通過更改默認的編碼方式來解決:
reload(sys)
sys.setdefaultencoding('gb2312')
3、 新的內建函數unicode()和unichar()可以看成Unicode版本的str()和chr().Unicode()函數可以把任何 Python 的數據類型轉換成一個 Unicode 字符串
4、 核心編程中的建議。核心編程這本書不錯,要好好看看。
a) 程序中出現字符串時一定要加個前綴u.
b) 不要用 str()函數,用 unicode()代替.
c) 不要用過時的 string 模塊 -- 如果傳給它的是非 ASCII 字符,它會把一切搞砸。
d) 不到必須時不要在你的程序裏面編解碼 Unicod 字符.只在你要寫入文件或數據庫或者
e) 網絡時, 才調用encode()函數;相應地,只在你需要把數據讀回來的時候才調用decode()
f) 函數.
5、 epoll.register函數中的event需要使用“|”來將多個事件並聯起來。它應該是使用的其中的一位。
6、 epoll.poll函數返回套接字,事件。這個事件中可能含有多個事件,是以位的形式表示的。所以判斷是否有某個事件,需要使用:event & select.EPOLLOUT。
7、
源碼安全與發佈
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)
6、 程序發佈:可以使用zip對所有的源文件進行打包。zip包中需要有一個入口文件:__main__.py,然後就可以使用Pythontest.zip來執行程序。
GC
1、 OO中的垃圾回收:Python的垃圾回收使用的是符號引用計數。那麼,如果在一個函數中申請一個對象,然後返回它的一個屬性或者方法,這個時候對象的符號引用已經去掉,對象是否會釋放?
a) class child(parent):
b) def __init__(self):
c) self.i = 8888
d)
e) def foo(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 theheader in the wrapper code */
#include"code.h"
#include"sip.h"
%}
/* Parse theheader 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 voidcallbacfun(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 ofprevious 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 intconvert_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 < size; i++) {
PyObject *o =PySequence_GetItem(input,i);
if (!PyFloat_Check(o)) {
Py_XDECREF(o);
PyErr_SetString(PyExc_ValueError,"Expecting a sequence offloats");
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. def createWirelessSdp(voiceRtpPort, voiceTbcpPort):
ii. voicesdp = SIP_SDP()
iii. voicesdp.a_use = 1
iv. sdp = createWirelessSdp(1000,2000)
v. 結果也是沒有任何提示,sdp爲None。
2、 總結:寫Python代碼,需要使用代碼檢查工具,比如,pylint等。後面引進一下。
程序運行
1、 如何獲取命令行參數:
a) import sys
b)
c) print(sys.argv[1])
d) sys.argv[1]就是第一個參數。0是腳本的名稱。
代碼調試
1、 自己摸索的一個方法:
1、gdbpython
2、run
3、importtest.py
這裏注意一下,這個腳本是主流程腳本。沒有if __name__ == "__main__".
關於性能
1、 timeit:可以統計程序的運行時間。目前沒有時間,抽時間好好看看。
timeit(cut1,number=10000):cut1是函數名,number是執行次數。
2、 pypy可以將Python代碼翻譯爲可執行程序,它的效率可以提高4倍左右。但是,內存的佔用可能會很大。(沒有試過。)
3、 使用字典代替列表:字典內部使用哈希,比列表的迭代更快。
4、 使用set集合代替列表:set內部也使用哈希,而且set的求差集交集也非常快。
5、 字符串優化:
a) join比+要快。
b) 當對字符串可以使用正則表達式或者內置函數來處理的時候,選擇內置函數。如str.isalpha(),str.isdigit(),str.startswith((‘x’, ‘yz’)),str.endswith((‘x’, ‘yz’))
c) 對字符串格式化比直接串聯格式化要快。
d)
6、 列表解析比使用循環構造一個列表根據高效。
7、 生成器表達式則是在2.4中引入的新內容,語法和列表解析類似,但是在大數據量處理時,生成器表達式的優勢較爲明顯,它並不創建一個列表,只是返回一個生成器,因此效率較高。它的語法是:(a for a in xrang(100) if a != 1)
8、 如果需要交換兩個變量的值使用a,b=b,a而不是藉助中間變量t=a;a=b;b=t;
9、 使用xrange而不是range。
10、 避免使用global關鍵字,訪問全局變量要比訪問局部變量慢很多。
11、 if done is not None比語句if done!=None更快。if done is noe 比 if done == None更快。
12、 在耗時較多的循環中,可以把函數的調用改爲內聯的方式;
13、 使用級聯比較 “x < y < z”而不是“x < y and y < z”;
14、 while 1要比while True更快(當然後者的可讀性更好);
15、 build in函數通常較快,add(a,b)要優於a+b。
16、 Python內置了豐富的性能分析工具,如profile,cProfile與hotshot。
17、 Python的性能優化工具:Psyco,Pypy,Cython,Pyrex。
18、 from a import b 引用b比a.b引用b要快。
優化的原則是,首先找到整個系統的瓶頸(源於80/20原則)。然後使用優化工具進行優化。有兩個比較看好,分別是Cython(可以用來寫Python的c擴展)和pypy(一個新的解釋器)。
pypy目前不支持cpython的c擴展。如果使用純Python是可以使用pypy的。但是如果使用了c擴展,則可能要使用cython來優化。
切忌:不要提前優化,這是萬惡之源。
如果知道了上面這幾條是“爲什麼”,那我對Python的認識就又提高一個層次了。下一階段的目標。
其他:
1、 腳本語言的進程名稱顯示爲:python ,如果一個服務器上有多個進程,那麼將不易發現那個進程是哪個程序。可以使用第三方開源的庫來解決這個問題:setproctitle.
from setproctitle import setproctitle,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)。choice會返回序列的一個隨機元素。
4、 回調函數的使用:設置回調函數的時候,很多時候要使用閉包。避免閉包的一個方法是:
a) def setCancelFun(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) if callable(_cancelFun):
l) _cancelFun(*_cancelArgs,**_cancelKwargs)
m) _cancelFun = None#防止重複調用
n)
o) def test(a,b, c):
p) print('--------test:', a,b,c)
q)
r) setCancelFun(test, 1, 2, 3)
s) __execCancelFun()
也就是增加可變參數。
Python:一切皆符號?