 |
VOOZH | about |
|
VOOZH | about |
兩本不錯的書：
《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，實現這個功能。同時，第一個參數設置為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)
內建函數：
1、 為什麼要學習正則：主要是為了處理字符串更加方便，特別是為後面進行代碼生成做儲備。
2、 match是匹配字符串的開頭是否匹配，而search是查看字符串任意起始位置是否滿足。
3、 sub可以對字符串中模式匹配的部分進行替換
4、 split：可以對字符串進行分割，這裡是根據模式分割。
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 = (123)
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, (12))
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、 列表的過濾：
def filterFun(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 in enumerate(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、 不帶參數的裝飾器要返回一個函數，這個函數就是用來替換原有的標示符的。
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('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、 裝飾器也可以修飾類的__方法：
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('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、
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;設置屬性值
1、 time.sleep函數函數具有c下sleep函數功能，單位為秒，但是可以接受浮點數。這樣可以表示毫秒。
2、 ti = datetime.datetime.now可以顯示當前的時間，包括當前的微秒也可以顯示出來。兩個的差值可以表示時間 的間隔：microsecondLong = timeLong.seconds * 1000000 + timeLong.microseconds。差值的成員是seconds和microseconds
3、
1、 如果不想讓成員變量或者方法被外部使用（也就是private特性），可以以__雙下劃線開通。
2、 屬性不但可以定義在init中，也可以定義在任意的方法中通過self定義。不過最好在init中定義。
3、 Python也可以實現抽象基類，也就是接口
5、 __call__(魔法方法)可以將對象作為函數來調用。給它一個入參就可以。:4、 __str__屬性可以將對象轉換為字符串，也就是調用print(object)是會列印的字符串。
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 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__函數，子類的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修飾。可以直接使用。後面如果有需要，在進行修飾。這樣既減少了工作，修改時，也不會對原有代碼進行改動。
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中是不可以的。
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的設計哲學告訴你，這不是一個好的實踐，所以這樣不行。應該怎麼弄？一個模塊調用另外一個模塊，如果被調用模塊想調用調用模塊的方法，通過回調的形式。這樣可以保證，模塊間的連接都是單向的。
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）從模塊中獲取函數和成員
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 = [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) 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.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 :
for flet in fletList:
flet.throw
info = sys.exc_info
raise info[0], info[1], info[2]
7、 如何使用異常才是Pythonic的做法？這個要看一下。
1、 類型也是對象。比如：inttype = int,然後，n = inttype(『256』)，這樣可以把字符串轉化為int值。
2、 另外，是否可以把字符串轉化為關鍵字，或者對象？比如，一個變量，abc,是否可以通過』abc』來引用？
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)
for tel, name, pwd in cur:
print tel, name, pwd
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)
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、
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 < 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、 如果一個結構體中有一個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是腳本的名稱。
2、
1、 timeit：可以統計程序的運行時間。目前沒有時間，抽時間好好看看。
timeit(cut1, number=10000)：cut1是函數名，number是執行次數。
2、 pypy可以將Python代碼翻譯為可執行程序，它的效率可以提高4倍左右。但是，內存的占用可能會很大。（沒有試過。）
3、
1、 腳本語言的進程名稱顯示為：python ，如果一個伺服器上有多個進程，那麼將不易發現那個進程是哪個程序。可以使用第三方開源的庫來解決這個問題：setproctitle.
from setproctitle import setproctitlegetproctitle
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
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
也就是增加可變參數。
