和之前一樣,仍然全部貼出來,而不是把新的貼出來,請諒解。 g) print(sh) h) 內(nèi)建函數(shù):
這次新增的部分包括c擴(kuò)展,排序,ftp,源碼安全,性能,代碼檢查等。
后面在python上努力的幾個(gè)方向:
1、繼續(xù)在開發(fā)中多使用,積累開發(fā)經(jīng)驗(yàn)。
2、針對我們公司完善基礎(chǔ)庫,在我們公司推廣。
3、抽時(shí)間,系統(tǒng)學(xué)習(xí)一下python。
4、學(xué)習(xí)一下高手在怎么使用python。畢竟我是自學(xué)。
5、參與開源。
如果你想下載這個(gè)文檔,請點(diǎn)擊這里:
string.capitalize() | 把字符串的第一個(gè)字符大寫 |
string.center(width) | 返回一個(gè)原字符串居中,并使用空格填充至長度 width 的新串 |
string.count(str, beg=0, end=len(string)) | 返回 str 在 string 里面出現(xiàn)的次數(shù),如果 beg 或者 end 指返回指定范圍內(nèi) str 出現(xiàn)的次數(shù) |
string.decode(encoding='UTF-8', errors='strict') | 以 encoding 指定的編碼格式解碼 string,如果出錯(cuò)默認(rèn)報(bào)ValueError 的異常,除非 errors 指定的是'ignore'或'replace' |
string.encode(encoding='UTF-8', errors='strict') | 以 encoding 指定的編碼格式編碼 string,如果出錯(cuò)默認(rèn)報(bào)ValueError的異常, 除非errors指定的是'ignore'或者'repl |
string.endswith(obj, beg=0, end=len(string)) | 檢查字符串是否以 obj 結(jié)束,如果 beg 或者 end 指定則檢定的范圍內(nèi)是否以 obj 結(jié)束, 如果是, 返回True,否則返回Fa |
string.expandtabs(tabsize=8) | 把字符串 string 中的 tab 符號轉(zhuǎn)為空格, 默認(rèn)格數(shù) tabsize 是 8. |
string.find(str, beg=0, end=len(string)) | 檢測 str 是否包含在 string 中,如果 beg 和 end 指定范則檢查是否包含在指定范圍內(nèi),如果是返回開始的索引值,返回-1 |
string.index(str, beg=0, end=len(string)) | 跟find()方法一樣, 只不過如果str不在string中會報(bào)一個(gè)異 |
string.isalnum() | a, b, c R如果string至少有一個(gè)字符并且所有字符都是字母或數(shù)字回 True,否則返回 False |
string.isalpha() | a, b, c 如果string至少有一個(gè)字符并且所有字符都是字母則返回T否則返回 False |
string.isdecimal() | b, c, d 如果 string 只包含十進(jìn)制數(shù)字則返回 True 否則返回 False. |
string.isdigit() | b, c 如果 string 只包含數(shù)字則返回 True 否則返回 False. |
string.islower() | b, c 如果 string 中包含至少一個(gè)區(qū)分大小寫的字符,并且所有這些(大小寫的)字符都是小寫,則返回 True,否則返回 False |
string.isnumeric() | b, c, d 如果 string 中只包含數(shù)字字符,則返回 True,否則返回 False |
string.isspace() | b, c 如果 string 中只包含空格,則返回 True,否則返回 False. |
string.istitle() | b, c 如果 string 是標(biāo)題化的(見 title())則返回 True,否則返回 False |
string.isupper() | b, c 如果 string 中包含至少一個(gè)區(qū)分大小寫的字符, 并且所有這些(區(qū)分大小寫的)字符都是大寫,則返回 True,否則返回 False |
string.join(seq) | Merges (concatenates)以 string 作為分隔符,將 seq 中所有的元素(的字符串表示)合并為一個(gè)新的字符串 |
string.ljust(width) | 返回一個(gè)原字符串左對齊,并使用空格填充至長度 width 的新字符串 |
string.lower() | 轉(zhuǎn)換 string 中所有大寫字符為小寫. |
string.lstrip() | 截掉 string 左邊的空格 |
string.partition(str) | e 有點(diǎn)像 find()和 split()的結(jié)合體,從 str 出現(xiàn)的第一個(gè)位置起,把 字 符 串 string 分 成 一 個(gè) 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()函數(shù),不過是從右邊開始查找. |
string.rindex( str, beg=0,end=len(string)) | 類似于 index(), 不過是從右邊開始. |
string.rjust(width) | 返回一個(gè)原字符串右對齊,并使用空格填充至長度 width 的新字符串 |
string.rpartition(str) | e 類似于 partition()函數(shù),不過是從右邊開始查找. |
string.rstrip() | 刪除 string 字符串末尾的空格. |
string.split(str="", num=string.count(str)) | 以 str 為分隔符切片 string,如果 num有指定值,則僅分隔 num 個(gè)子字符串 |
string.splitlines(num=string.count('\n')) | b, c按照行分隔, 返回一個(gè)包含各行作為元素的列表, 如果 num 指定則僅切片 num 個(gè)行. |
string.startswith(obj, beg=0,end=len(string)) | b, e檢查字符串是否是以 obj 開頭,是則返回 True,否則返回 False。如果beg 和 end 指定值,則在指定范圍內(nèi)檢查. |
string.strip([obj]) | 在 string 上執(zhí)行 lstrip()和 rstrip() |
string.swapcase() | 翻轉(zhuǎn) string 中的大小寫 |
string.title() | b, c 返回"標(biāo)題化"的 string,就是說所有單詞都是以大寫開始,其余字母均為小寫(見 istitle()) |
string.translate(str, del="") | 根據(jù)str給出的表(包含256個(gè)字符)轉(zhuǎn)換string的字符,要過濾掉的字符放到 del 參數(shù)中 |
string.upper() | 轉(zhuǎn)換 string 中的小寫字母為大寫 |
string.zfill(width) | 返回長度為 width 的字符串,原字符串 string 右對齊,前面填充0 |
正則表達(dá)式
1、 為什么要學(xué)習(xí)正則:主要是為了處理字符串更加方便,特別是為后面進(jìn)行代碼生成做儲備。
2、 match是匹配字符串的開頭是否匹配,而search是查看字符串任意起始位置是否滿足。
3、 sub可以對字符串中模式匹配的部分進(jìn)行替換
4、 split:可以對字符串進(jìn)行分割,這里是根據(jù)模式分割。
函數(shù)的使用:
1、 函數(shù)的作用域:函數(shù)中定義一個(gè)變量,如果和全局變量重名,則全局變量名稱就會被覆蓋,也就是,這里對這個(gè)變量的更改,不會更改全局變量。但是,如果直接使用的話,是會使用全局變量的。同時(shí),如果想要修改全局變量,需要制定是全局變量:global a
2、 xrange用法和range一樣,不過更為高效,因?yàn)樗粫趦?nèi)存中創(chuàng)建列表。所以,它只能用于循環(huán)。
3、 如果函數(shù)沒有return語句,則他的返回值為None。
4、 關(guān)于函數(shù)的入?yún)⑴袛啵喝绻绱藶榭?,可能會發(fā)生異常。當(dāng)異常發(fā)生后,可能會出現(xiàn)一種情況,一個(gè)事情做到了一半,就沒有在進(jìn)行下去,可能會造成內(nèi)存泄露。這個(gè)問題如何解決?按照C的方式,每個(gè)入?yún)⒍甲雠袛嗍强梢越鉀Q的,但是這樣太麻煩了。而且看很多開源代碼頁沒有這樣來做。是不是有更好的方法?換一種思路,在調(diào)用之前確保不為空。在看看開源的代碼是怎么做的。特別是openstack。
5、 可變?nèi)雲(yún)ⅲ?args, **kwargs表示可變?nèi)雲(yún)ⅰ?/p>
def funtest(a, b, c):
print(a, b, c)
def fun2(*args, **kwargs):
funtest(*args, **kwargs)
fun2(1,2,3)
也可以這樣定義:
fun2(a, *args, **kwargs)
如何從可變參數(shù)中解析出參數(shù)的值?
在fun2中添加打?。嚎梢园l(fā)現(xiàn),其實(shí)args是一個(gè)元組,kwargs是一個(gè)字典。
分析:調(diào)用fun2(1,2,3),會把a(bǔ)賦值給a,2賦值給元組args,{‘c’=3}賦值給kwargs.
args和kwargs的順序不可顛倒。
args和kwargs可能同時(shí)都有值。這樣,要獲取指定的入?yún)?,首先根?jù)看args中有沒有,然后根據(jù)字符串看kwargs中是否存在。
如何建一個(gè)元組或者字典通過參數(shù)傳遞給一個(gè)函數(shù)?
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中可以實(shí)現(xiàn)這個(gè)功能。這樣會很靈活的。
*和**也可以單獨(dú)出現(xiàn)。但是,如果同時(shí)出現(xiàn),*必須在**之前。
6、 默認(rèn)參數(shù)或者可選參數(shù),參數(shù)順序:調(diào)用時(shí),可以指定默認(rèn)參數(shù)中填充那個(gè)。
def funtest(a, b=1, c=2):
print(a, b, c)
funtest(1, c=5, b=6)
其實(shí),即便定義為:def funtest(a, b, c),也可以通過funtest(1, c=5, b=6)的形式調(diào)用。
7、 參數(shù)組:*args, **kwargs就是參數(shù)組,通過元組和字典將產(chǎn)生攜帶進(jìn)來。這個(gè)特性有助于更為動(dòng)態(tài)的代碼生成。
8、 可變長度參數(shù):
9、 函數(shù)的參數(shù)中如果有一個(gè)是元組,可以這樣:
def fun(a, (b, c)):
print(a, b, c)
fun(1, (1,2))
10、 關(guān)于回調(diào),可以使用閉包,生成器,以及對象的__call__屬性。都可以封裝狀態(tài)。
閉包的使用:
1、 將組成函數(shù)的語句和語句的執(zhí)行環(huán)境打包在一起形成的對象,成為閉包。
2、 2.7之前的閉包不支持關(guān)鍵字nonlocal。3.0之后才支持。所以2.7前的閉包不可以使用nonlocal。
3、 這樣他就不可以對執(zhí)行環(huán)境中的變量進(jìn)行更改。
字典的使用:
1、 字典的刪除:直接使用del dict[k]可能會引發(fā)異常;首先判斷k是否存在則效率有些低;使用異常使程序結(jié)構(gòu)看起來不好。一個(gè)好的方法是pop(k, default v)。這個(gè)刪除一個(gè)k項(xiàng),并且返回。如果不存在返回默認(rèn)的v。如果不加默認(rèn)值,則會引發(fā)異常。
2、 直接使用字典下標(biāo)獲取字典的值可能會引發(fā)一場。使用get方法則不會,如果不存在會返回none。另外,還可以設(shè)置不存在的默認(rèn)值。
3、 通過字典格式化字符串:print “value is %(key)s” % kvdict
4、 items方法返回一個(gè)列表,列表中的元素是一個(gè)元組,第一個(gè)是key,第二個(gè)是value。比較好用的方法。
5、 iteritems:返回的是一個(gè)迭代器。如果想要迭代這個(gè)字典,iteritems會比items更高效一點(diǎn)。
6、 iterkeys則返回的是key的迭代器。keys返回的是key的list。
7、 values返回值的列表,itervalues返回的是vlaue的迭代器
8、 popitem會隨機(jī)彈出(同時(shí)刪除)一個(gè)項(xiàng),則對于想要處理所有的元素,并且刪除所有的元素是有幫助的。但是,如果沒用元素的話,會拋出異常。
9、 viewitems,viewkeys,viewvalues:這三個(gè)函數(shù)返回的是一個(gè)view對象。這個(gè)類似于視圖。分別表示(key, value)pair的列表,key的列表,value的列表。一個(gè)優(yōu)點(diǎn)是,如果字典發(fā)生變化,view會同步發(fā)生變化。在迭代過程中,字典不允許改變,否則會報(bào)異常。
10、 字典的鍵值比較規(guī)則:如果是內(nèi)置類型(int,str,tuple),則是以他們的值作為鍵值;如果是自定義對象,則是以對象的地址作為鍵值?!@一點(diǎn)沒有完全證實(shí)?!钚碌陌l(fā)現(xiàn):對象的比較,內(nèi)置類型,是因?yàn)樗麄兌贾貙懥四J(rèn)的object的__eq__等方法,所以可以比較內(nèi)容。自定義對象,沒有重寫,所以,他們的比較可能會不一樣。object默認(rèn)的比較是什么?目前還不明確,后面再補(bǔ)充吧。可能就是地址(或者對象的唯一標(biāo)識),而不是對象的內(nèi)容。涉及到字典,它不是使用的單純的比較,而是使用的__hash__,它返回的是一個(gè)hash值,字典就是根據(jù)這個(gè)hash只來散布對象的。
列表的使用:
1、 列表的刪除:不可以在遍歷的過程中刪除鏈表,這樣會得到不可預(yù)知的后果??梢允褂昧斜淼倪^濾,來獲得新的列表。
2、 列表的過濾:
def filterFun(node):#這個(gè)函數(shù)做了兩個(gè)事情哎。
node.cycleCount = node.cycleCount - 1
return node.cycleCount < 0
timeoutList = filter(filterFun, timerList)
對timerList中的每個(gè)節(jié)點(diǎn)執(zhí)行函數(shù)filterFun,根據(jù)filterFun返回的結(jié)果,為真的項(xiàng)組成一個(gè)新的列表。
3、 map: kvlist = map(lambda x:x.strip(), kvlist)。同時(shí),map可以接受多個(gè)列表,這個(gè)時(shí)候,函數(shù)也會接受多個(gè)參數(shù),分別表示列表的每一個(gè)元素:
kvlist = map(lambda x,y:x+y, [1,2,3], [4,5,6])
如果函數(shù)為None,則相當(dāng)于函數(shù)zip:
zip([1,2,3], [4,5,6])
[(1,4),(2,5),(3,6)]
4、 生成器表達(dá)式:l = [node for node in xrange(5) if node - 3 < 0]:這個(gè)的這個(gè)方法一定程度上可以替代過濾器和map。
生成器表達(dá)式定義:
[expr for iter_var in iterable if cond_expr]
l = [2 for x in xrange(5)]#結(jié)果是生成一個(gè)含有5個(gè)2的列表
5、 print(reduce(lambda x,y: x*y, [2 for x in xrange(38)]))
上面的這個(gè)語句是計(jì)算2的38次方的值。它用到的是二元函數(shù)reduce。它第一次調(diào)用是將第一個(gè)和第二個(gè)元素做入?yún)?,后面用他們的結(jié)果做x,新的元素做y,最后返回值。
另外,在獲取一個(gè)38個(gè)2的列表也可以使用:[2] * 38。這可能更可讀一點(diǎn)。
6、 enumerate:對列表處理,返回的是列表的索引以及節(jié)點(diǎn)。
for index, node in enumerate(timerList):
if timerId == node.timerId and timerEvent == node.timerEvent:
del timerList[index]
7、 列表的分片:[1,2,3,4],l[1:-1]表示從索引從1到倒數(shù)第一個(gè),不包含倒數(shù)第一個(gè)。如果要從某位置到最后,則應(yīng)該:[1:]
8、 l[i:j:k]:表示切片,從i到j(luò),步長為k。
9、 l[i:j]:表示從i到j(luò),不包括索引j。
排序
1、 list自己提供了排序的函數(shù):sort。
2、 sort的參數(shù):
a) cmp是一個(gè)比較函數(shù),輸入兩個(gè)元素,比較大小,返回值為-1,0,1.
b) key也是一個(gè)函數(shù),入?yún)橐粋€(gè)元素,返回這個(gè)元素的關(guān)鍵字。
c) reverse是一個(gè)標(biāo)志位,表示升序還是降序。默認(rèn)False是升序,True表示降序。
3、使用key和reverse的性能,優(yōu)于cmp函數(shù)。時(shí)間是cmp函數(shù)的一半。
迭代的使用:
1、 迭代比直接使用列表遍歷效率根據(jù)高。比如字典的keys函數(shù)返回的列表,以及iterkeys返回的迭代器。
2、 reversed() 內(nèi)建函數(shù)將返回一個(gè)反序訪問的迭代器.參數(shù)必須為序列。
3、 enumerate:返回一個(gè)迭代器:有索引值。
4、 for eachLine in myFile 替 換 for eachLine in myFile.readlines() :
5、 注意:在迭代的過程中不可以更改序列,否則會引發(fā)問題,導(dǎo)致迭代出錯(cuò)。
6、 可以自己定義一個(gè)類,可以迭代使用。不過需要定義方法:__iter__,next。
7、 filter(function, iterable):可以對迭代使用過濾器。
生成器的使用:
1、 yield關(guān)鍵字可以阻塞住函數(shù)的執(zhí)行,并且保存當(dāng)前的執(zhí)行環(huán)境,整個(gè)包被稱為生成器。
2、 生成器可以通過調(diào)用生成器函數(shù)來創(chuàng)建。生成器函數(shù)是指包含關(guān)鍵字yield的函數(shù)。
3、 生成器可以通過.next()來執(zhí)行。每調(diào)用一次,就執(zhí)行代碼,直到遇到y(tǒng)ield關(guān)鍵字停止,并且返回yield關(guān)鍵字后面的表達(dá)式的值。
4、 可以通過調(diào)用send()函數(shù)來發(fā)送消息到生成器中。a = yield l:表示將send的入?yún)①x值給a。
5、 throw:允許客戶端傳入要拋出的任何異常。
6、 和throw相同,只不過是要拋出一個(gè)特定的異常:GeneratorExit。
7、 send只接受一個(gè)參數(shù),但是可以通過傳遞元組的方式傳遞多個(gè)參數(shù)。
8、 類的方法也可以返回生成器,因?yàn)樗举|(zhì)上就是一個(gè)函數(shù)。
9、 在生成器使用的時(shí)候,如何獲取它自身的send和nex函數(shù)?通過send二次傳入是有些風(fēng)險(xiǎn)的,非常可能造成交叉引用,無法垃圾回收造成內(nèi)存泄露。
10、 第一次,必須調(diào)用next來啟動(dòng)生成器。
裝飾器的使用:
1、 裝飾器本質(zhì)上來說就是函數(shù)(或者是可調(diào)用對象),他們接受函數(shù)對象。裝飾器僅僅用來裝飾或者修飾函數(shù)的包裝,返回一個(gè)修改后的函數(shù)對象,并將其賦值原來的標(biāo)示符,并永久失去對原有函數(shù)的訪問。
2、 什么是帶參數(shù)的裝飾器?其實(shí)就是一個(gè)函數(shù),這個(gè)函數(shù)可以返回一個(gè)裝飾器,同時(shí)這個(gè)函數(shù)可以接受參數(shù)。
3、 不帶參數(shù)的裝飾器要返回一個(gè)函數(shù),這個(gè)函數(shù)就是用來替換原有的標(biāo)示符的。
def decofun(fun):
def _mydeco(*args, **kwargs):
print('before fun!')
ret = fun(*args, **kwargs)
print('after fun', ret)
return ret
return _mydeco#新的函數(shù),用于替換原有標(biāo)示符
@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包裝。也就是,調(diào)用的時(shí)候,首先調(diào)用的是最上面的裝飾器(也就是decofun2)的函數(shù)前面部分,然后再調(diào)用decofun的函數(shù)前面部分,之后再調(diào)用funtest。funtest返回后,首先調(diào)用的是decofun的函數(shù)后面部分,再調(diào)用decofun2后面部分。類似于一個(gè)棧的結(jié)構(gòu)。
5、 裝飾器不要濫用。如果一個(gè)裝飾器只用了一次,要考慮他存在的必要了。
6、 攜帶參數(shù)的裝飾器:
7、 def decoarg(arg):
a) def decofun3(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、 裝飾器用到的一個(gè)最重要的技術(shù),就是閉包。裝飾器函數(shù)返回的其實(shí)就是一個(gè)閉包。
9、 裝飾器也可以修飾類的__方法:
class testc:
def __init__(self):
self.i = 1
@decoarg(1)
@decofun2
@decofun
def __call__(self):
print('i is %d' % self.i)
注意:裝飾器修飾類方法是無法被子類繼承的(或者說子類的方法是沒有被修飾的)。因?yàn)樗举|(zhì)上就是一個(gè)函數(shù)。
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) 這種方法看起來復(fù)雜了,但是可能會在有時(shí)候會比較有用。
11、 裝飾器可以修飾類。這個(gè)時(shí)候裝飾器接收的是一個(gè)類名,而返回的也是這個(gè)類名。它可以為這個(gè)類添加一些屬性或者進(jìn)行一些操作。
協(xié)程的使用:
1、 協(xié)程(coroutine)是一個(gè)可以掛起,回復(fù),并且有多個(gè)進(jìn)入點(diǎn)的函數(shù)。
2、
XML的使用:
1、 處理xml消息包比較好用的模塊是xml.etree.ElementTree。
2、 Element執(zhí)行xml的根節(jié)點(diǎn)。
3、 elem.find(path):查找根節(jié)點(diǎn)下面路徑為path的子節(jié)點(diǎn)。
4、 elem.findall(path):同樣的子節(jié)點(diǎn)可能有多個(gè),這里會返回一個(gè)列表。
5、 elem.findtext(path):獲取指定路徑子節(jié)點(diǎn)的內(nèi)容,這個(gè)我們會經(jīng)常使用。
6、 elem.get(key);獲取屬性的值。
7、 上面如果沒用,則返回none
8、 elem.append:添加自節(jié)點(diǎn)。
9、 elem.tag:返回tag值,也就是name。
10、 elem.text:返回內(nèi)容。
11、 elem.attrib:返回屬性的字典。
12、 SubElement:生成一個(gè)節(jié)點(diǎn),自動(dòng)添加為父節(jié)點(diǎn)的子節(jié)點(diǎn)。
13、 tostring:轉(zhuǎn)化為xml文本字符串。但是不包括xml頭。如果編碼方式為UTF-8或者GB2312,gb2312都會產(chǎn)生xml頭;如果是utf-8,則不會產(chǎn)生xml頭
14、 fromstring:從字符串轉(zhuǎn)化為ElementTree對象。和XML同樣的功能。
15、 elem.set();設(shè)置屬性值
time的使用:
1、 time.sleep()函數(shù)函數(shù)具有c下sleep函數(shù)功能,單位為秒,但是可以接受浮點(diǎn)數(shù)。這樣可以表示毫秒。
2、 ti = datetime.datetime.now()可以顯示當(dāng)前的時(shí)間,包括當(dāng)前的微秒也可以顯示出來。兩個(gè)的差值可以表示時(shí)間 的間隔:microsecondLong = timeLong.seconds * 1000000 + timeLong.microseconds。差值的成員是seconds和microseconds
3、
OO的使用:
1、 如果不想讓成員變量或者方法被外部使用(也就是private特性),可以以__雙下劃線開通。
2、 屬性不但可以定義在init中,也可以定義在任意的方法中通過self定義。不過最好在init中定義。
3、 Python也可以實(shí)現(xiàn)抽象基類,也就是接口
5、 __call__(魔法方法)可以將對象作為函數(shù)來調(diào)用。給它一個(gè)入?yún)⒕涂梢浴?4、 __str__屬性可以將對象轉(zhuǎn)換為字符串,也就是調(diào)用print(object)是會打印的字符串。
def __call__(self, protoVer):
return api.protoModules[protoVer].TimeTicks(
(time.time()-self.birthday)*100
)
它的作用:比較常用的是作為回調(diào),因?yàn)樗梢员4鏍顟B(tài)信息。它和閉包類似,可能比閉包的可讀性要好一點(diǎn)。
6、 對象實(shí)例是否可以刪除?
7、 Python參考手冊要好好看一下。
8、 python的static方法使用的是裝飾器語法:@staticmethod.
9、 對類的調(diào)用還有一個(gè)方法:CALSS.method(object)。
10、 子類中,如果想調(diào)用父類的方法,可以通過:
parent.method(self).
不過還有更好的方法:
super(child, self).foo()//注意:這里是根據(jù)子類的類型獲取父類的方法。它的好處是不用明顯給出基類的類型。
11、 cls:類方法的第一個(gè)參數(shù)。通常表示類的類型,可以通過cls()來生成實(shí)例。
a) @classmethod
b) def spawn(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) return g
12、 繼承,如果子類定義了__init__函數(shù),子類的init函數(shù)不會默認(rèn)調(diào)用父類的init函數(shù),需要手動(dòng)調(diào)用:parent.__init__。這一點(diǎn)是和c++有區(qū)別的。如果子類沒有定義__init__,則子類會調(diào)用父類的__init__。這里可以發(fā)現(xiàn),其實(shí),子類如果定義了init函數(shù),是對父類的init的一個(gè)覆蓋。
13、 super注意:?。。∷荒苡迷谛率降念惗x中。什么是新式的?原來只是基類定義時(shí)繼承object?。。?。
14、 繼承如何繼承方法:只要繼承一個(gè)類,就會繼承這個(gè)類所有的方法,包括__init__,__del__。但是如果子類重寫某方法,就會覆蓋父類的方法,不會再調(diào)用父類的方法了。如果想調(diào)用父類的方法,可以通過super的方式調(diào)用。
15、 繼承如何繼承屬性:只要不覆蓋父類__init__方法,或者調(diào)用了父類的__init__方法,就會繼承父類__init__屬性的方法。繼承后也可以更改這些屬性。
16、 父類如何防止被繼承:方法或者屬性以__開頭,則可以防止被繼承。
17、 根據(jù)我的經(jīng)驗(yàn),其實(shí)可以以一種本質(zhì)的方式理解Python的繼承:Python的類就是一些方法的集合,繼承一個(gè)類就是繼承這個(gè)類的所有的方法。如果在子類中定義一個(gè)方法,其實(shí)是更改了這個(gè)類的符號。而屬性,則可以在所有的方法中定義,只要調(diào)用了定義屬性的方法,調(diào)用父類,則是繼承父類的屬性,調(diào)用子類定義屬性的方法,則是定義子類的方法。
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) 這樣的好處是,可以在操作屬性時(shí),不用顯示為方法調(diào)用,更加可讀。同時(shí)又可以統(tǒng)一入口。:注意,它也必須繼承object才可以。
19、 OO中的垃圾回收:Python的垃圾回收使用的是符號引用計(jì)數(shù)。那么,如果在一個(gè)函數(shù)中申請一個(gè)對象,然后返回它的一個(gè)屬性或者方法,這個(gè)時(shí)候?qū)ο蟮姆栆靡呀?jīng)去掉,對象是否會釋放?
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) 這個(gè)時(shí)候,對象o會馬上釋放。因?yàn)閛.i其實(shí)就是一個(gè)對象的引用,和o沒有關(guān)系
第二種情況,返回的是方法
a) def refun():
b) o = child()
c) return o.foo
d) foo = refun()
e) 這個(gè)時(shí)候,對象o要等到foo釋放的時(shí)候再釋放,因?yàn)閒oo中包含了o的引用(foo的入?yún)elf)
20、 對于對象的屬性,如果屬性是可讀寫的,則第一步?jīng)]有必要用@property修飾??梢灾苯邮褂谩:竺嫒绻行枰?,在進(jìn)行修飾。這樣既減少了工作,修改時(shí),也不會對原有代碼進(jìn)行改動(dòng)。
模塊的使用:
1、 如果不想將模塊的某些函數(shù)和變量被別的模塊使用,可以以單下劃線開頭。這樣import *是沒有的,但是使用import mode,然后mode._fun仍然可以調(diào)用。在class中是以雙下劃線開頭的。
2、 使用from。。。import導(dǎo)入的符號,應(yīng)該是本地符號,更改的話,無法更改模塊中的值??梢酝ㄟ^mode.name=來修改。
3、 __init__.py的作用:可以這樣理解:包也是一個(gè)對象,這個(gè)py就是這個(gè)包的構(gòu)造函數(shù)。導(dǎo)入這個(gè)包,就會自動(dòng)的執(zhí)行__init__.py。如果在這個(gè)py中導(dǎo)入其他符號,import 這個(gè)包并且加*也會導(dǎo)入這個(gè)符號。
4、 import *無法導(dǎo)入模塊中以_開頭的符號。但是,不用*是可以的。
5、 import的本質(zhì)也是創(chuàng)建一個(gè)符號,指向一個(gè)對象的引用。這個(gè)符號和被import的模塊的符號是沒有關(guān)系的。和c的extern不一樣。extern可以更改變量的值,但是,這在Python中是不可以的。
from srctest import itest, outitest, setitest
import srctest
# itest = 9#這個(gè)地方其實(shí)改變的是本模塊中符號的引用,無法更改srctest中對應(yīng)符號。
#srctest.itest = 9#這個(gè)可以更改srctest中的itest
setitest(9)#這個(gè)可以更改srctest中的itest,但是改變不了當(dāng)前模塊的itest,也就是,這種設(shè)置是無法同步的。
print(itest)#打印當(dāng)前模塊的itest
printitest()#打印srctest中的itest
Python的設(shè)計(jì)哲學(xué):看似不方便的背后,其實(shí)有Python的設(shè)計(jì)哲學(xué)。便捷性很多時(shí)候都是模塊性的大敵。在軟件開發(fā)中,模塊間的最短路徑未必是最合理路徑,而且往往是最不合理路徑。它會破壞軟件原有的交互原則。
Python這樣設(shè)計(jì)的理由應(yīng)該是,盡量將數(shù)據(jù)和對數(shù)據(jù)的操作放在一起。如果數(shù)據(jù)會擴(kuò)散,那么,就將數(shù)據(jù)設(shè)計(jì)為只讀的。這樣有助于提高程序模塊的內(nèi)聚性(全局變量是內(nèi)聚性的大敵),降低耦合性。降低程序的復(fù)雜性(數(shù)據(jù)只讀,調(diào)試根據(jù)方便)。
srctest.itest是可以改變itest的值的,說明我們可以通過改變這個(gè)對象的屬性來改變對象(模塊也是對象)。
可能有一點(diǎn)小題大做。
6、 兩個(gè)模塊不可以雙向import。那萬一兩個(gè)模塊都要互相調(diào)用對方怎么辦?Python的設(shè)計(jì)哲學(xué)告訴你,這不是一個(gè)好的實(shí)踐,所以這樣不行。應(yīng)該怎么弄?一個(gè)模塊調(diào)用另外一個(gè)模塊,如果被調(diào)用模塊想調(diào)用調(diào)用模塊的方法,通過回調(diào)的形式。這樣可以保證,模塊間的連接都是單向的。
日志的使用:
1、 日志的標(biāo)準(zhǔn)模塊logging基本可以滿足我的工作。
2、 設(shè)置log的初始化工作:
logging.basicConfig(
filename = "test.log",
format = "[%(asctime)s-%(levelname)s] %(message)s [%(filename)s,%(lineno)d]",
level = logging.INFO,
datefmt = "%F %T")
3、 除此之外,一個(gè)比較強(qiáng)大的功能就是過濾功能:可以針對級別,文件,行號等等很多的東西進(jìn)行過濾。
4、
自省的使用:
1、 type()可以查看對象的類型。這就是自省。也就是可以看看自己是什么類型。這個(gè)功能在動(dòng)態(tài)語言中非常有用。
2、 getattr函數(shù):這是個(gè)非常有用的函數(shù),它可以根據(jù)字符串,從模塊,類,對象實(shí)例中獲取屬性和方法的應(yīng)用并且調(diào)用。這個(gè)功能非常類似于c語言的函數(shù)指針,以及c++中的成員函數(shù)的指針。
1)從模塊中獲取函數(shù)和成員
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函數(shù)指針。因?yàn)闆]有實(shí)例,所以調(diào)用必須用下面的方法:
t = test()
tm(t)#申請一個(gè)實(shí)例,并且作為第一個(gè)參數(shù)傳進(jìn)去。
tm = getattr(test, '__test’)#這里會報(bào)錯(cuò),也就是無法獲取私有方法。
tabc = getattr(test, 'abc’)#這是錯(cuò)誤的。無法獲取。
ttst = getattr(test, 'tst’)#這是可以的。。
3)從對象實(shí)例中獲取屬性和方法
t = test()
tm = getattr(t, 'method')
tm()#可以這樣調(diào)用,而不用傳入t實(shí)例。
tabc = getattr(test, 'abc’)#可以獲取實(shí)例的屬性。
3、 callable:函數(shù)表示某個(gè)對象是否可以調(diào)用。它和getattr結(jié)合起來,可以獲取一個(gè)對象中的所有的method列表:
methods = [method for method in dir[object] if callable(getattr(object, method))]
4、 自省也叫放射。
5、 exec(‘print “test”‘):可以執(zhí)行字符串代碼。這個(gè)特性有助于動(dòng)態(tài)執(zhí)行代碼,可以用于機(jī)器學(xué)習(xí),自動(dòng)生成代碼。
exec的參數(shù)可以使一個(gè)打開的文件對象,string,code object。
code object可以通過函數(shù)
類似的方法:execfile(filename[, globals[, locals]])。
6、 可以更改類的方法,將它指向一個(gè)新的方法。如下:
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。這個(gè)特性有助于根據(jù)動(dòng)態(tài)的代碼實(shí)現(xiàn),但是往往會增加代碼的透明性。
類似的,setattr也可以實(shí)現(xiàn)這樣的功能。delattr可以刪除屬性。
setattr(c, 'test', testfun)
delattr(c, 'test')
c.test()#這里調(diào)用的其實(shí)就是ctest的test方法。也就是說,delattr會首先刪除setattr設(shè)置的屬性,如果在調(diào)用一次delattr,才會刪除c的test方法。但是如果多調(diào)用幾次setattr,也只要調(diào)用一次delattr即可刪除。所以,要?jiǎng)h除一個(gè)方法,最多調(diào)用兩次delattr。
這個(gè)特性可以用于動(dòng)態(tài)更改代碼。也可用于補(bǔ)丁。
setattr無法對Python的c擴(kuò)展模塊進(jìn)行操作。
7、 如何判斷一個(gè)變量是否存在:
‘v’ in dir()
‘v’ in locals.key()
配置文件讀取的使用:
1、 使用模塊ConfigParser。實(shí)例如下:
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、 盡量少用。它會使程序難以理解,而且還會發(fā)生不可預(yù)知的情況,比如異常的發(fā)生使程序的狀態(tài)變?yōu)橐粋€(gè)未知狀態(tài)。
2、 可以尋找替代方案。
3、 程序非常重要,不可以停止,可以在主循環(huán)包裝在異常處理中運(yùn)行。
4、 打印出異常的信息,供后面的定位:log.error(traceback.format_exc())
5、 raise在引發(fā)異常的時(shí)候,可以傳遞引發(fā)一場的額外數(shù)據(jù)。形式如下:
raise Exception, 1
捕獲方法:
except CallExit, e:
e就是那個(gè)額外數(shù)據(jù)1。(但是奇怪的是它的類型不是1)
6、 如何捕獲一個(gè)異常,進(jìn)行處理,然后在把它拋出:
except :
for flet in fletList:
flet.throw()
info = sys.exc_info()
raise info[0], info[1], info[2]
7、 如何使用異常才是Pythonic的做法?這個(gè)要看一下。
類型系統(tǒng)
1、 類型也是對象。比如:inttype = int,然后,n = inttype(‘256’),這樣可以把字符串轉(zhuǎn)化為int值。
2、 另外,是否可以把字符串轉(zhuǎn)化為關(guān)鍵字,或者對象?比如,一個(gè)變量,abc,是否可以通過’abc’來引用?
OS的使用
os中有很多可以直接利用的東西,比如,判斷文件是否存在,刪除文件等。這樣可以不用再執(zhí)行shell命令。
os.rremove(path):刪除文件
os.system(‘ls’);執(zhí)行shell命令
文件的使用
1、 打開使用函數(shù)open,模式和linux c類似。有一個(gè)不同的地方時(shí),可以選擇,直接操作磁盤還是操作內(nèi)存。
2、 readline可以讀取一個(gè)文件的一行。
3、 readlines:返回每一個(gè)列的列表。對應(yīng)writelines。
4、 文件迭代器:
f = open(‘fliename’)
for line in f:
process(line)
f.close()
或者更簡潔的:
for line in open(filename):
process(line)
5、 文件迭代器的使用:
如果文件很大,readlines可能會占用過多的內(nèi)存。所以,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')
數(shù)據(jù)庫的使用
1、 數(shù)據(jù)庫中的字段使用的utf8格式編碼,但是讀取出來卻是問號。這個(gè)問題的解決可以通過在查詢的時(shí)候指定編碼方式來解決,只要執(zhí)行sql語句:Query_Execsql(pdb, "SET NAMES 'utf8'");
注意,這個(gè)需要在連接后馬上進(jìn)行。并且,在其他的操作中,會一直使用這種編碼。除非再次更改。
2、 fetchone():返回一條記錄。fetchall():返回所有的記錄。
3、 可以使用一個(gè)簡單的方法獲取所有的記錄:
cur.execute(sql)
for tel, name, pwd in cur:
print tel, name, pwd
FTP的使用
Python的標(biāo)準(zhǔn)模塊ftplib就可以支持FTP。
幾個(gè)函數(shù):
FTP(host='', user='', passwd='', acct='', timeout=_GLOBAL_DEFAULT_TIMEOUT):如果參數(shù)中有user,則Connect();如果同時(shí)也有user,則login()。如果沒用這些參數(shù),后要自己調(diào)用connect和login。
connect(self, host='', port=0, timeout=-999):如果端口不是標(biāo)準(zhǔn)端口,則要手動(dòng)調(diào)用connect。
login(user = '', passwd = '', acct = ''):登陸。
pwd():獲得當(dāng)前的工作路徑。
cwd(path):更改當(dāng)前的工作路徑。
dir(path,cb):顯示目錄中的內(nèi)容。cb為文件的處理函數(shù)。會傳遞給retrlines。這個(gè)函數(shù)可以獲取一個(gè)目錄下的所有的內(nèi)容。
retrlines(self, cmd, callback = None):下載文本文件。cmd的形式為“RETR FILENAME”,callback是一個(gè)函數(shù),要處理文本文件的每一個(gè)行。這里一個(gè)問題,如果直接用file的write方法,則會丟失換行符。而又沒有writeline函數(shù)。
retrbinary(self, cmd, callback, blocksize=8192, rest=None):下載二進(jìn)制文件,cmd的形式為“RETR FILENAME”,callback是一個(gè)函數(shù),要處理文本文件的每一個(gè)塊。默認(rèn)大小事8k,但是可以更改。
storlines(self, cmd, fp, callback=None):上傳文本文件。cmd的形式為“STOR FILENAME”。fp是一個(gè)文件對象,必須有readline方法。callback:每傳送一行,就會調(diào)用這個(gè)函數(shù)。
storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None): 上傳二進(jìn)制文件。cmd的形式為“STOR FILENAME”。fp是一個(gè)文件對象,必須有read(num_bytes)方法。默認(rèn)大小事8k,但是可以更改。
quit():退出。
字節(jié)的使用
1、 ord:可以見字符轉(zhuǎn)化為int類型的值。
2、 chr:ord的方向操作??梢砸奿nt類型值轉(zhuǎn)換為字符。
字符編碼的使用
1、 encode是將Unicode轉(zhuǎn)化為str,decode是將字符串轉(zhuǎn)化為Unicode。所以,一個(gè)字符串要轉(zhuǎn)化為另一種格式可以:
s = ‘中文’
s.decode(fromcodec).encode(tocodec)
也可以直接使用:s.encode(tocodec)。這個(gè)時(shí)候,相當(dāng)于默認(rèn)調(diào)用了decode,并且使用的是默認(rèn)的編碼方式。
源碼安全
1、 Python代碼如果直接發(fā)布,可能會暴露源碼。
2、 一個(gè)方法是利用c擴(kuò)展Python,來代替核心模塊。
3、 另一個(gè)折中的方法就是對源碼進(jìn)行編譯,生成pyc或者pyo文件。這些事字節(jié)碼文件??赡軙环淳幾g。所以,可能需要研究一下Python的pyo生成和加載方式,來生成更安全的Python字節(jié)碼。網(wǎng)上說可以修改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的垃圾回收使用的是符號引用計(jì)數(shù)。那么,如果在一個(gè)函數(shù)中申請一個(gè)對象,然后返回它的一個(gè)屬性或者方法,這個(gè)時(shí)候?qū)ο蟮姆栆靡呀?jīng)去掉,對象是否會釋放?
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) 這個(gè)時(shí)候,對象o會馬上釋放。因?yàn)閛.i其實(shí)就是一個(gè)對象的引用,和o沒有關(guān)系
第二種情況,返回的是方法
f) def refun():
g) o = child()
h) return o.foo
i) foo = refun()
j) 這個(gè)時(shí)候,對象o要等到foo釋放的時(shí)候再釋放,因?yàn)閒oo中包含了o的引用(foo的入?yún)elf)
k)
2、 如果兩個(gè)對象交叉引用,是否會自動(dòng)回收?不會。同樣,如果一個(gè)對象把生成的對象賦值給它自身的一個(gè)屬性,那么它也不會自動(dòng)回收。
3、
c擴(kuò)展
1、 可以使用swig來創(chuàng)建c 的擴(kuò)展程序,非常方便。目前沒有時(shí)間研究內(nèi)部機(jī)制,先暫時(shí)使用,后面在研究吧。
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腳本及對應(yīng)的C文件:swig –python sip.i。
4、 將生成的c源文件放到c擴(kuò)展庫中進(jìn)行編譯。
5、 這里有一個(gè)要注意:生成的動(dòng)態(tài)鏈接庫,必須是_sip.so,否則無法調(diào)用。swig是寫死的。_sip.so需要拷貝到: /usr/local/lib/python2.7/site-packages/路徑下。
6、 Makefile文件中,對于庫引用的其他的庫,必須顯示的指出,否則Python無法找到對應(yīng)的庫。
7、 如何在c的擴(kuò)展庫中調(diào)用Python的函數(shù):
swig是不支持直接在c的擴(kuò)展庫中調(diào)用Python函數(shù)的。它只支持將C的接口作為回調(diào)函數(shù)設(shè)置給c的庫。
實(shí)現(xiàn)這個(gè)功能需要利用Python的c API和ctypes來實(shí)現(xiàn)。
Python c 的api包含一系列的函數(shù):
PyCallable_Check:檢查對象是否可調(diào)用;
PyArg_ParseTuple:解析參數(shù)列表,將Python參數(shù)解析為c;
PyEval_CallObject:調(diào)用對象;
Py_BuildValue:將c變量打包為Python的參數(shù)對象。
好了,有這些就足夠了。
假設(shè)c庫中有一個(gè)設(shè)置回調(diào)函數(shù)接口:
void set_callback_fun(void (*fun)(int, int , int))
{
}
下面是c擴(kuò)展庫中要添加的代碼:
//全局變量,保存Python中要回調(diào)的可調(diào)用對象。
static PyObject *gCallbackFun = NULL;
//調(diào)用上面函數(shù)設(shè)置的python腳本函數(shù)
//Python可調(diào)用對象的轉(zhuǎn)換函數(shù),轉(zhuǎn)化為C的調(diào)用方式
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的參數(shù)轉(zhuǎn)化為Python的參數(shù)對象
pRetVal = PyEval_CallObject(gCallbackFun, pArgs);//調(diào)用Python的可調(diào)用對象。
Py_DECREF(pArgs);
Py_DECREF(pRetVal);
}
/// set_callback_fun函數(shù)的包裝函數(shù)
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)) {//檢查對象是否可以調(diào)用
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; /* 保存回調(diào)對象 */
}
set_callback_fun(callbacfun);//注意,這里掉一下包,用一個(gè)C的函數(shù)注冊到c庫中。
return Py_BuildValue("i", (gCallbackFun == NULL) ? 0 : 1);
}
注意:如果對象不可調(diào)用,會段錯(cuò)誤。后面要解決一下。
Python代碼:
CBFUNC = CFUNCTYPE(c_int, c_int, c_int, c_int)//創(chuàng)建一個(gè)c函數(shù)類型的對象工廠,該函數(shù)返回值為int,有三個(gè)入?yún)?,都為int。
callbakFunc = CBFUNC(pyFun)//根據(jù)Python可調(diào)用對象生成函數(shù)。
set_callback_fun(callbakFunc)//設(shè)置回調(diào)函數(shù)
注意:pyFun必須要有返回值。否則會報(bào)異常。
另外,我發(fā)現(xiàn),不用CFUNCTYPE來生產(chǎn)c回調(diào)函數(shù),直接用pyFun,也是可以的。至于區(qū)別,后面在研究一下吧,要寫代碼了。
幾個(gè)異常問題:1、一個(gè)可以使用CFUNCTYPE,但是一個(gè)一使用它就段錯(cuò)誤。2、回調(diào)函數(shù)可以不返回值,也是可以的。但是一個(gè)不返回就不可以。
在Python中使用c擴(kuò)展時(shí)向C傳遞數(shù)組:
8、 如果一個(gè)函數(shù)的參數(shù)是一個(gè)數(shù)組(指針),Python如何傳遞?下面的方法是可以直接傳遞列表。把這個(gè)加到.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 < size; 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、 如果一個(gè)結(jié)構(gòu)體中有一個(gè)int類型數(shù)組,應(yīng)該如何賦值?
在.i中增加下面代碼:
%include "carrays.i"
%array_class(int, intArray);
在Python中申請數(shù)組:
a = intArray(10),將A復(fù)制給數(shù)組成員即可。
代碼錯(cuò)誤檢查
1、 今天遇到兩個(gè)問題:
a) 類中方法:class _registerEvent(notifyEvent): def _sendRegRsp(self, voiceres, reqId, result, reason,status):,調(diào)用時(shí)參數(shù)個(gè)數(shù)少一個(gè):self._sendRegRsp(voiceres, reqId, 'success', 'normal') 。結(jié)果是沒有任何提示,并且,不知道調(diào)用了什么函數(shù)。這個(gè)問題有點(diǎn)匪夷所思。后面好好查看一下。
b) 抽取函數(shù)后,有時(shí)忘了返回值,當(dāng)時(shí)卻用到了返回值:
i. def createWirelessSdp(voiceRtpPort, voiceTbcpPort):
ii. voicesdp = SIP_SDP()
iii. voicesdp.a_use = 1
iv. sdp = createWirelessSdp(1000,2000)
v. 結(jié)果也是沒有任何提示,sdp為None。
2、 總結(jié):寫Python代碼,需要使用代碼檢查工具,比如,pylint等。后面引進(jìn)一下。
程序運(yùn)行
1、 如何獲取命令行參數(shù):
a) import sys
b)
c) print(sys.argv[1])
d) sys.argv[1]就是第一個(gè)參數(shù)。0是腳本的名稱。
2、
關(guān)于性能
1、 timeit:可以統(tǒng)計(jì)程序的運(yùn)行時(shí)間。目前沒有時(shí)間,抽時(shí)間好好看看。
timeit(cut1, number=10000):cut1是函數(shù)名,number是執(zhí)行次數(shù)。
2、 pypy可以將Python代碼翻譯為可執(zhí)行程序,它的效率可以提高4倍左右。但是,內(nèi)存的占用可能會很大。(沒有試過。)
3、
其他:
1、 腳本語言的進(jìn)程名稱顯示為:python ,如果一個(gè)服務(wù)器上有多個(gè)進(jìn)程,那么將不易發(fā)現(xiàn)那個(gè)進(jìn)程是哪個(gè)程序??梢允褂玫谌介_源的庫來解決這個(gè)問題:setproctitle.
from setproctitle import setproctitle,getproctitle
print('當(dāng)前的進(jìn)程名:%s' % getproctitle())
setproctitle('proctitle')
print('設(shè)置后的的進(jìn)程名:%s' % getproctitle())
2、 with語法:with open(‘file’, ‘r’) as f:
code
可以是try的另一種形式。
可以執(zhí)行with操作的類型:
file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
3、 產(chǎn)生隨機(jī)數(shù):random.randint(100000, 999999)
4、 回調(diào)函數(shù)的使用:設(shè)置回調(diào)函數(shù)的時(shí)候,很多時(shí)候要使用閉包。避免閉包的一個(gè)方法是:
a) def setCancelFun(cancelFun, *args, **kwargs):
b) '''如果為None表示刪除取消函數(shù), 后面跟的是cancel函數(shù)的參數(shù)。這樣可以避免上面創(chuàng)建閉包。'''
c) global _cancelFun,_cancelArgs,_cancelKwargs
d) _cancelFun = cancelFun
e) _cancelArgs = args
f) _cancelKwargs = kwargs
g)
h) def __execCancelFun():
i) '執(zhí)行取消操作。因?yàn)樵趖hrow和kill的時(shí)候會執(zhí)行此函數(shù),所以,暫時(shí)沒有看到會在外面調(diào)用此函數(shù)。屏蔽后,接口的簡單性會提高'
j) global _cancelFun,_cancelArgs,_cancelKwargs
k) if callable(_cancelFun):
l) _cancelFun(*_cancelArgs, **_cancelKwargs)
m) _cancelFun = None#防止重復(fù)調(diào)用
n)
o) def test(a, b, c):
p) print('--------test:', a,b,c)
q)
r) setCancelFun(test, 1, 2, 3)
s) __execCancelFun()
也就是增加可變參數(shù)。
Python:一切皆符號?
轉(zhuǎn)自:http://www.cnblogs.com/chgaowei/archive/2012/06/05/2537442.html