Python核心编程-细节
直接從六張開始看看書里有什么。
cmp() len() max() and min() sorted() and reversed() enumerate() and zip() sum() list() and tuple() dir()方法來得到它所有的方法和屬性
extend() ?and append() ? extend()接受一個列表的內容，然后把所有元素追加到另一個列表中 ?append()把整個元素追加列表中，如：[].extend('abc') ?最后輸出的結果就是 ['a', 'b', 'c'] ?[].append('abc')輸出結果是['abc']?
pop() 把數組中的元素去掉，接受的參數是一個integer，把傳入的index去掉，如果不傳默認是最后一個
range(start, end, step =1)
filter(func, seq) map(func, seq1[,seq2...]) reduce(func, seq[, init])
issubclass() isinstance() hasattr(), getattr(),setattr(), delattr() dir() super() vars()
list.append(obj)
list.count(obj)
list.extend(seq) a
list.index(obj, i=0,
j=len(list))
list.insert(index, obj)?
list.pop(index=-1)
list.remove(obj)
list.reverse()
list.sort(func=None,key=None,reverse=False)
?
字典
d = {'name':'allen','name2':'allen','age':'40'}
d = dict((['x', 1],['y', 2], ['z',3])) # 注意：兩個()，dict只接受一個參數，可以是元祖，可以是列表，每個組合的數據個數兩個
d = dict([['x', 1],['y', 2], ['z',3]])
d = {}.fromkeys(('x', 'y'), 1)
d =?dict(zip(('x', 'y'), (1, 2)))
d =?dict([('xy'[i-1], i) for i in range(1,3)]) ? ? ? #{'y':2, 'x':1}
d=?dict(x=1, y=2)
cmp():字典的比較，先比較兩個字典的元素個數，通過keys()方法獲取返回鍵的順序，在比較第一組的鍵，在比較第一組的值，在比較第二組的鍵。。。。。。。。
dict.clear ()
dict.copy ()
dict.fromkeys (seq,
val=None) c
dict.get(key,default=None)
dict.has_key(key)
dict.items()
dict.keys()
dict.iter()? 對字典 dict 中的鍵 key,返回它對應的值 value,如果字典中不存在此鍵,則返回 default 的值(注意,參數 default 的默認值為 None)
dict.pop (key[, default])?
dict.setdefault(key,default=None)?
dict.update(dict2) 將字典 dict2 的鍵-值對添加到字典 dict
dict.values()
?
set() frozenset()
集合等價/不等價
obj in s
obj not in s
?s == t
?s != t
?s < t (嚴格意義上)子集測試; s != t 而且s中所有的元素都是 t 的成員
s.issubset(t) ??s <= t
?s > t
s.issubset(t) ? s <= t
?s > t
s.issuperset(t) s >= t
s.union(t) s | t 合并操作:s 或 t 中的元素
s.intersection(t) ?s & t 交集操作:s 和 t 中的元素
s.difference(t) s - t 差分操作: s 中的元素,而不是 t 中的元素
s.symmetric_difference(t) s ^ t 對稱差分操作:s 或 t 中的元素,但不是 s 和 t 共有的元素
s.update(t) ?s |= t (Union) 修改操作: 將 t 中的成員添加 s
s.intersection_update(t) s &= t 交集修改操作: s 中僅包括 s 和 t 中共有的成員
s.difference_update(t) ??s -= t 差修改操作: s 中包括僅屬于 s 但不屬于 t 的成員
s.symmetric_difference_update(t) s ^= t 對稱差分修改操作: s 中包括僅屬于 s 或僅屬于 t 的成員
s.add(obj)
s.remove(obj)
s.discard(obj)
s.pop()
s.clear()
?
條件和循環
if condition:
? pass
elif ?condition:
? pass
else:
? pass
while expression:
? pass
for iter_var in iterable:
? pass
pass什么也不做
?
文件和輸入輸出
open() file()
file_object = open(file_name, access_mode='r', buffering=-1)
access_mode是一個字符串代表一個文件打開的模式，r讀 w寫 a追加 U通用換行符。r 和U 打開的文件必須是存在的，w打開的文件首先會清空，a打開的文件是為了追加做準備的，所有寫入的文件追加到末尾。+ 代表可讀可寫，b 代表二進制模式訪問
buffering用于指示訪問文件采用的緩沖方式，0 表示不緩沖，1 表示只緩沖一行數據。
r ?以讀方式打開
rU 或 Ua 以讀方式打開, 同時提供通用換行符支持 (PEP 278)
w ?以寫方式打開 (必要時清空)
a ?以追加模式打開 (從 EOF 開始, 必要時創建新文件)
r+ 以讀寫模式打開
w+ ?以讀寫模式打開 (參見 w )
a+ ??以讀寫模式打開 (參見 a )
rb ? ?以二進制讀模式打開
wb ??以二進制寫模式打開 (參見 w )
ab 以二進制追加模式打開 (參見 a )
rb+ ?以二進制讀寫模式打開 (參見 r+ )
wb+ ?以二進制讀寫模式打開 (參見 w+ )
ab+ ?以二進制讀寫模式打開 (參見 a+ )
例子：fp = open(r'c:\io.sys', 'rb') # 以二進制讀模式打開 ? 這里需要說一下的是file_name參數中的r 的意思是名字就是字符串的所顯示的名，也就是遇見 ’\‘ 不轉義
open()
open() 和 file() 函數具有相同的功能, 可以任意替換.您所看到任何使用 open() 的地方, 都可以使用 file() 替換它.一般說來, 我們建議使用 open() 來讀寫文件, 在您想說明您在處理文件對象時使用 file() , 例如 ifinstance(f, file)
9.2.2 通用換行符支持(UNS)
不同平臺用來表示行結束的符號是不同的, 例如 \n, \r, 或者 \r\n這就是 UNS 的關鍵所在, 作為 PEP 278 的結果, Python 2.3 引入了 UNS. 當你使用 'U' 標志打開文件的時候, 所有的行分割符(或行結束符, 無論它原來是什么)通過 Python 的輸入方法(例如 read*() )返回時都會被替換為換行符 NEWLINE(\n). ('rU' 模式也支持 'rb' 選項) . 這個特性還支持包含不同類型行結束符的文件. 文件對象的 newlines 屬性會記錄它曾“看到的”文件的行結束符.
如果文件剛被打開, 程序還沒有遇到行結束符, 那么文件的 newlines 為 None .在第一行被讀取后, 它被設置為第一行的結束符. 如果遇到其它類型的行結束符, 文件的 newlines 會成為一個包含每種格式的元組. 注意 UNS 只用于讀取文本文件. 沒有對應的處理文件輸出的方法.在編譯 Python 的時候,UNS 默認是打開的. 如果你不需要這個特性, 在運行 configure 腳本時,你可以使用 --without-universal-newlines 開關關閉它. 如果你非要自己處理行結束符, 請查閱核心筆記,使用 os 模塊的相關屬性.
當使用輸入方法如 read() 或者 readlines() 從文件中讀取行時, Python 并不會刪除行結束符. 這個操作被留給了程序員. 例如這樣的代碼在 Python 程序中很常見:
f = open('myFile', 'r')
data = [line.strip() for line in f.readlines()]
f.close()
類似地, 輸出方法 write() 或 ritelines() 也不會自動加入行結束符. 你應該在向文件寫入數據前自己完成。
文件內移動：seek()
seek() 方法(類似 C 中的 fseek() 函數)可以在文件中移動文件指針到不同的位置. offset字節代表相對于某個位置偏移量. 位置的默認值為 0 , 代表從文件開頭算起(即絕對偏移量), 1 代表從當前位置算起, 2 代表從文件末尾算起. 如果你是一個 C 程序員,并且使用過了 fseek() , 那么,0, 1, 2 分別對應著常量 SEEK_SET, SEEK_CUR, 以及 SEEK_END. 當人們打開文件進行讀寫操作的時候就會接觸到 seek()方法。
text() 方法是對 seek() 的補充; 它告訴你當前文件指針在文件中的位置 - 從文件起始算起,單位為字節.
seek()方法在文件內移動，tell()告訴我們當前的位置。
函數：
一個方法理解可變長度的函數：只有是 * = * 格式的才會進入**dict_args中，否則就算本身是dict也算入*tuple_args中
arg1: 1 arg2: 2 tuple_args: 3 tuple_args: 4 tuple_args: d tuple_args: {'y': 2, 'x': 1} dict_args : y = 1 dict_args : x = 1
匿名函數lambda
a = lambda x, y = 2: x + y
filter函數用法： ? 就是過濾用的，經過帥選，選出符合方法返回值的數。傳入的方法有且只接受一個參數
def odd(n):return n % 2 allNums = range(10) print filter(odd, allNums)結果：[1, 3, 5, 7, 9]
map函數用法：
print map(lambda x, y: (x+y, x-y), [1,3,5], [2,4,6]) 結果：[(3, -1), (7, -1), (11, -1)]reduce函數用法：就是算出前兩個參數的值作為一個值和第三個參數一起算出一個值，依次進行。
def add(x, y):return x + y print reduce(add, [1,2,3])結果：6
partial函數的用法：
int函數的用法:int(10)省略了base=10，默認就是一個十進制的數，所以用int('10')也可已得到十進制數。int('11', base = 2)會得到一個基于二進制的十位數，這里的不痛是指定了base參數，那么前面的參數就必須是一個string類型的參數，int(11, base=2)會報 : ??int() can't convert non-string with explicit base
結果：18
下面這種寫法：
baseTwoBAD = partial(int, 2)
baseTwoBAD('10010') TypeError: an integer is required
baseTwoBAD(10) TypeError: int() can't convert non-string with explicit base
上面baseTwo(x) = int(x, base=2)。baseTwoBAD(x) = int(2, x)
關鍵字參數總是出現在形參之后，也就是說，a = * 這種關鍵字參數一定要出現在單獨一個參數 x 后面，這里沒有指定base，2默認為形參，當在傳入x后，x會放在第二個位置上也就是base的位置，所以上面兩種情況分別報了不同錯誤。
作用域：
變量是有作用域的，在方法中聲明的變量雖然和全局變量名一樣，也有可能直接訪問全局變量，但是出了方法后，全局變量的值就變回來了。直接代碼解釋：
沒有問題，結果：fzk
g_str = 'fzk' def test1():print g_strg_str = 'badboy'print g_str報錯：UnboundLocalError: local variable 'g_str' referenced before assignment。
g_str = 'fzk' def test1():print g_strg_str = 'badboy'print g_strglobal g_strprint g_str結果：
fzk
badboy
badboy
第三種情況沒報錯，說明全部變量global在哪里聲明都無所謂，只要在方法里聲明了。
閉包的問題，是一個問題，和裝飾器弄一篇。
在導入模塊的時候，注意循環導入的問題。
python中，一個模塊也就是一個已.py結尾的文件， 一個packge中可以有很多個模塊，一般新建一個packge后會自動生成一個__init__.py文件。
類中的__init__(), __new()__, __del__()：
__init__() ?：就是一個構造器，一般自己重寫。
__new__()：這個方法更像是一個構造器，因為__new()__必須返回一個合法的實例，這樣解釋器在調用__init__()時就可以把他作為self傳給他。調用__new()__會先調用父類的__new()__。
__del__() ?：結構器，只有在所有的引用全部del后，才會調用__del__()方法。調用__del__()方法前先調用父類的__del__()方法。并不是調用刪除一個屬性(del a)就會調用這個方法，這是刪除了一個引用，只有全部引用全部刪除后才會調用這個方法。
類中有屬性，修改實例中的類屬性時需要謹慎。
實例中可以訪問類中的屬性，類中的屬性修改實例也會感知到。但是如果在實例中修改類的屬性就要注意了，如果實例中修改類的屬性，相當于在實例中創建了原類中相同名的一個屬性(只是名一樣，并不是類中的屬性)，實例在訪問自己的屬性時先會查找自己的屬性，沒有則會從類中查找，如果修改了實例中屬性，相當于給實例屬性賦值，這時就不會從類中查找，除非刪除實例中屬性。
結果：
1
1
3
1
1
4
3
4
classmethod和staticmethod：
class C(object):def foo():passfoo = staticmethod(foo)@staticmethod
def bar():
pass
class D(object):def foo(cls):pass
@classmethod
def bar():
pass
foo = classmethod(foo)
對應的內建函數被轉換成它們相應的類型,并且重新賦值給了相同的變量名。如果沒有調用這兩個函數,二者都會在 Python 編譯器中產生錯誤,顯示需要帶 self 的常規方法聲明。現在, 我們可以通過類或者實例調用這些函數。沒個類中兩個的方法的生命是等價的。
老式類和新式類集成的問題：
老實類采用深度優先，比如
class P1: #(object): def foo(self):print 'called P1-foo()' class P2: #(object)def foo(self):print 'called P2-foo()' def bar(self):print 'called P2-bar()' class C1(P1, P2): pass class C2(P1, P2): def bar(self):print 'called C2-bar()' class GC(C1, C2):pass gc = GC() gc.foo() # GC ==> C1 ==> P1 called P1-foo() gc.bar() # GC ==> C1 ==> P1 ==> P2 called P2-bar()新式類采用廣度優先：
上面的代碼中，把p1和p2的(object)注解打開。重新調用上面的兩個方法
gc = GC() gc.foo()# GC ==> C1 ==> C2 ==> P1 called P1-foo() gc.bar() # GC ==> C1 ==> C2 called C2-bar()在繼承類的括號中（如C1(P1, P2)左邊p1，右邊p2）從左側開始查找，查找完一個類后在找同胞順序是從左到右，依次向深處查找。直到找到為止。下面還有一個例子：
class G(object):def __init__(self):print 'G init' class H(object):def __init__(self):print 'H init' class I( H, G):pass i = I()結果：H init
如果改成下面這樣：
class I(G, H):pass結果：G init
?定制類：
基本定制型
C.__init__(self[, arg1, ...]) 構造器(帶一些可選的參數)
C.__new__(self[, arg1, ...])? ?構造器(帶一些可選的參數);通常用在設置不變數據類型的子類。
C.__del__(self) ?解構器
C.__str__(self) ?可打印的字符輸出;內建 str()及 print 語句
C.__repr__(self) ? ? ??運行時的字符串輸出;內建 repr() 和‘‘ 操作符
C.__unicode__(self)? Unicode 字符串輸出;內建 unicode()
C.__call__(self, *args) ?表示可調用的實例
C.__nonzero__(self) 為 object 定義 False 值;內建 bool() (從 2.2 版開始)
C.__len__(self) ?“長度”(可用于類);內建 len()
特殊方法
C.__cmp__(self, obj) 對象(值)比較對象比較;內建 cmp()
C.__lt__(self, obj) and ?小于/小于或等于;對應<及<=操作符
C.__gt__(self, obj) and ??大于/大于或等于;對應>及>=操作符
C.__eq__(self, obj) and ??等于/不等于;對應==,!=及<>操作符
屬性
C.__getattr__(self, attr) 獲取屬性;內建 getattr();僅當屬性沒有找到時調用
C.__setattr__(self, attr, val) ? ?設置屬性
C.__delattr__(self, attr) 刪除屬性
C.__getattribute__(self, attr) 獲取屬性;內建 getattr();總是被調用
C.__get__(self, attr) ?(描述符)獲取屬性
C.__set__(self, attr, val) ?(描述符)設置屬性
C.__delete__(self, attr) ??(描述符)刪除屬性
數值類型:二進制操作符
C.__*add__(self, obj) 加;+操作符
C.__*sub__(self, obj) 減;-操作符
C.__*mul__(self, obj) 乘;*操作符
C.__*div__(self, obj) ?除;/操作符
C.__*truediv__(self, obj) ??True 除;/操作符
C.__*floordiv__(self, obj) ?Floor 除;//操作符
C.__*mod__(self, obj) 取模/取余;%操作符
C.__*divmod__(self, obj) ?除和取模;內建 divmod()
C.__*pow__(self, obj[, mod]) ??乘冪;內建 pow();**操作符
C.__*lshift__(self, obj) 左移位;<<操作符
定制類/模擬類型
數值類型:二進制操作符
C.__*rshift__(self, obj) 右移;>>操作符
C.__*and__(self, obj) ?按位與;&操作符
C.__*or__(self, obj) ?按位或;|操作符
C.__*xor__(self, obj) ? ?按位與或;^操作符
數值類型:一元操作符
C.__neg__(self) ? ?一元負
C.__pos__(self) ?一元正
C.__abs__(self) ?絕對值;內建 abs()
C.__invert__(self) ??按位求反;~操作符
數值類型:數值轉換
C.__complex__(self, com) 轉為 complex(復數);內建 complex()
C.__int__(self) 轉為 int;內建 int()
C.__long__(self) ?轉為 long;內建 long()
C.__float__(self) ? ??轉為 float;內建 float()
數值類型:基本表示法(String)
C.__oct__(self) 八進制表示;內建 oct()
C.__hex__(self) 十六進制表示;內建 hex()
數值類型:數值壓縮
C.__coerce__(self, num) 壓縮成同樣的數值類型;內建 coerce()
C.__index__(self) ?在有必要時,壓縮可選的數值類型為整型(比如:用于切片索引等等)
序列類型
C.__len__(self) ?序列中項的數目
C.__getitem__(self, ind)? 得到單個序列元素
C.__setitem__(self, ind,val) ??設置單個序列元素
C.__delitem__(self, ind) ? 刪除單個序列元素
特殊方法
序列類型
C.__getslice__(self, ind1,ind2) 得到序列片斷
C.__setslice__(self, i1, i2,val) ?設置序列片斷
C.__delslice__(self, ind1,ind2) ?刪除序列片斷
C.__contains__(self, val) ?測試序列成員;內建 in 關鍵字
C.__*add__(self,obj) ?串連;+操作符
C.__*mul__(self,obj) ?重復;*操作符
C.__iter__(self) ?創建迭代類;內建 iter()
映射類型
C.__len__(self) ??mapping 中的項的數目
C.__hash__(self) 散列(hash)函數值
C.__getitem__(self,key) ? ?得到給定鍵(key)的值
C.__setitem__(self,key,val) ?設置給定鍵(key)的值
C.__delitem__(self,key) 刪除給定鍵(key)的值
C.__missing__(self,key) ??給定鍵如果不存在字典中,則提供一個默認值
"*" 代表''(selp OP obj), 'r'(obj OP self),或'i'(原位(in-place)操作),例如__add__, __radd__, or __iadd__.
雙下劃線(__)和單下劃線(_)
雙下劃線是Python 為類元素(屬性和方法)的私有性提供的形式。
單下劃線是模塊級私有化。可以防止模塊的屬性用“from module import *”來加載。
__slots__屬性：
__dict__屬性跟蹤所有實例屬性。舉例來說,你有一個實例 inst.它有一個屬性 foo,那使用 inst.foo 來訪問它與使用 inst.__dict__['foo']來訪問是一致的。字典會占據大量內存,如果你有一個屬性數量很少的類,但有很多實例,那么正好是這種情況。為內存上的考慮,用戶現在可以使用__slots__屬性來替代__dict__。
如果__slots__屬性中沒有要獲取的屬性戶會報異常，如果在__slots__外面又定義了一個屬性a，那么a是read-only的。
結果：AttributeError: 'SlottedClass' object has no attribute 'xxx'
要知道的是他繼承的是object，如果繼承了其他的類，但是這個類中并沒有用__slots__屬性，那么也不會報錯，他會認為那個屬性是父類的。但是如果父類（非object）也用了__slots__，那么和集成object效果一樣。
描述符真的是一個很惡心的東西。在弄一篇。
callable()：一個布爾函數，確定一個對象是否可以通過函數操作符(())來調用。如果函數可調用便返回 True,否則便是 False
compile()：函數允許程序員在運行時刻迅速生成代碼對象，函數中有三個參數，都是必須的，第一個參數是python代碼。第二個是一個字符串，存放代碼生成文件的名字，通常置為空(‘’)。第三個參數有三個選擇
'eval' 可求值的表達式[和 eval()一起使用]
'single' ? ?單一可執行語句[和 exec 一起使用]
'exec' ?可執行語句組[和 exec 一起使用]
eval()：對表達式求值。如：eval('100 + 200')
exec：
input()：是 eval()和 raw_input()的組合,等價于 eval(raw_input())。如：aList = input('Enter a list: ')
轉載于:https://www.cnblogs.com/badboyf/p/6111425.html
總結
以上是生活随笔為你收集整理的Python核心编程-细节的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 考研数学各科的“命题潜规则”，看完多得好
- 下一篇： python子类分配