擼一遍python的內建方法
這樣做的好處就是：我如果要完成一個功能的時候，如果能用內建方法完成，就用內建方法。這樣可以提高效率，同時使自己的代碼更加優雅。哎呦？那豈不是擼完就是python高手了？我先幫大家試試效果，請靜候我的反饋！
反饋：內建方法全部看完了，並敲完所有的內建方法，收獲還是有的，但是發現不了解的知識更多了。內建方法屬於python的標准庫中的一章。python的標准庫中還有很多值得一看的章節。python2.7.8中文標准庫文檔，這些內容我粗略的看了一遍。這個內建方法的學習筆記我周三就寫完了，本來想在寫內建類型的學習筆記。但是發現太多了！而且我發現，看的太多記下的東西就會變少，所以我打算把重心轉移到我自己練手的項目中（現在還沒什么值得分享的東西，等拿得出手肯定會告訴大家的）。我想把學習標准庫中收獲的技巧用到我的項目中，這樣學以致用才能真正融匯貫通。這就是我的下一步學習計划：通過實際項目，運用python標准庫中的技巧！
結論就是：看完標准庫我還沒有成為高手，但是我收獲了很多知識，基礎牢固了一些。下一步打算在我自己的項目中運用這些技巧，提高自己的能力和技術！
相關資料
內建方法
| 常用內建方法 |
|---|
| all |
| abs |
| any |
| basestring |
| bin |
| bool |
| bytearray |
| callable |
| chr |
| classmethod |
| cmp |
| compile |
| complex |
| delattr |
| dict |
| dir |
說明:[,xxx]表示為可選參數。
abs(x)
返回x的絕對值，例如：
abs(-1.23) # 1.23
all(iterable)
如果iterable(迭代對象)的所有元素為真（或者iterable為空：[],'',()等），返回True。例如：
all('') # True
all([1,2,3,0]) # False
any(iterable)
如果iterable中只要又一個元素為真，就返回True。例如：
any([1,2,3,0]) # True
basestring()
它是str和unicode的超類，不能被調用或者實例化。只能用來測試一個對象是不是str或unicode的實例。例如：
a = u'a'
b = 'b'
isinstance(a, basestring) # True
isinstance(b, basestring) # True
bin()
將整數轉成二進制字符串。
bin(3) # '0b11'
bool()
將一個值轉化成布爾值。
bool(1) # True
bool(0) # True
bool('') # False
bool(' ') # True
bool([]) # False
bytearray()
結合memoryview，實現改變str類型對象的值。請移步python內建類型
callable(object)
如果object參數可調用，返回True；否則返回False。對類的調用，返回一個新的實例。對於實例，如果實例有call方法，則該實例也是可以調用的。例如：
class TestCallable(object):
def __init__(self):
pass
def __call__(self):
pass
callable(TestCallable) # True
callable(TestCallable()) # True
chr(i)
返回一個字符，該字符的ASCII碼為整數i。i的取值范圍：0 <= x < 255
chr(100) # 'd'
ord('d') # 100
classmethod(functions)
將傳入的方法包裝成類方法（類方法是指，類不需要實力化就可以直接調用的方法）。
類方法的第一個參數必須為類（約定俗稱用cls代表），實例方法的第一個參數必須為實例（約定俗稱為self），這兩種接收參數的方法叫做：隱式第一參數（implicit first argument）。靜態方法（通過@staticmethod裝飾的方法)不需要如上述兩個方法的隱式參數。
class C(object):
@classmethod
def f(cls, arg1, arg2):
pass
注意：通過@classmethod修飾的方法，為類方法。類可以直接調用（如C.f())；實例也可以直接調用（如C().f())，切記類方法中不能操作實例的屬性。如果子類調用類方法，子類對象被傳遞為隱式的第一個參數（也就是cls為子類對象）。
cmp(x, y)
比較兩個對象x和y，當x < y返回'-1'；x > y返回'1';x == y返回0
cmo(1, 3) # -1
cmp(3, 1) # 1
cmp(1, 1) # 0
注意：bool(-1)結果為True
compile(source, filename, mode)
compile可以將字符串或者Unicode字符串編譯成代碼對象。代碼對象可以通過exec或eval執行。
- 參數source：字符串或者AST（Abstract Syntax Trees）對象。
- 參數 filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。
- 參數model：指定編譯代碼的種類。可以指定為 ‘exec’,’eval’,’single’。
source ="if cmp(1, 1)==0: print 'yes'"
test_compile = compile(source, '', 'exec')
exec(test_compile) #yes
注意：source是字符串，要注意引號和雙引號，最后指定什么model，就用那種方法執行。compile返回的類型是code。
complex(str)
創建一個復數。
complex('1+2j') #可行
complex('1 + 2j') #報錯(因為字符串中'+'或者'-'兩遍不能有空白)
delattr(object, name)
參數是一個對象和一個字符串(name為字符串類型)，字符串必須是該對象的某個屬性名。效果是：刪除該對象的name對應的屬性。
class Test(object):
def __init__(self):
self.name = 'XueWeiHan'
test_delatter = Test()
test_delatter.name # XueWeiHan
delattr(test_delatter, 'name')
test_delatter.name # 報錯，沒有name屬性，刪除成功
dict()
創建一個新字典。
dict(a=1) # {'a': 1}
dir(object)
如果沒有參數，返回當前本地作用域的名字列表。如果有參數，返回該參數的屬性列表(屬性和方法)。
如果類中定義了__dir__方法，則dir()會先默認從__dict__屬性中收集信息。
import time
type(time) # model
dir(time) # ['__doc__','__file__',...,'sleep','strftime',]就是time.可以調用的屬性和方法
class TestDir(object):
def __dir__(self):
return ['TestDir1', 'TestDir2']
dir(TestDir) # ['TestDir1', 'TestDir2']
注意：dir()主要是方便交互環境
divmod(a, b)
效果：a除以b，返回商和余數的二元組（兩個數組成的元組）
divmod(5, 2) #(2, 1)
enumerate(sequence, start=0)
返回一個枚舉對象。sequence必須是序列，迭代器iterator，或者支持迭代的對象：
迭代器Iterators:
迭代器僅是一容器對象，它實現了迭代器協議。它有兩個基本方法：
1）next方法
返回容器的下一個元素
2）__iter__方法
返回迭代器自身
names = ['Xuweihan', 'James', 'Kobe']
enumerate_data = (names, start=0) #這是個枚舉類型數據
list(enumerate_data) #[(0, 'Xuweihan'), (1, 'James'), (2, 'Kobe')]
list(enumerate(names, 1)) #[(1, 'Xuweihan'), (2, 'James'), (3, 'Kobe')]
# 實現
def enumerate(sequence, start=0):
n =start
for elem in sequence:
yield n, elem
n += 1
注意：enumerate是生成器，惰性計算。可以調用next()
eval(expression[,globals()[,locals()]])
expression參數被當作python表達式執行。使用globals()和locals()指定執行的代碼中變量是全局變量還是本地變量。代碼例子如下：
a = 1 #全局變量
def add_one():
a = 2 #本地變量
eval('a+1', globals()) #結果為 2
eval('a+1', locals()) #結果為 3
execfile(filename[,globals[,locals]])
該函數類似exec（上面的那個），不同的是他解析一個文件，而不是字符串。它不同與__import__語句的地方在於，它不使用模塊管理——它無條件的讀入文件且不會創建一個新模塊。
(不常用)
file()
file類型的構造函數。打開一個文件的時候，建議使用open()而不使用file()。file更適合類型檢測例如：isinstance(f, file)。
filter(functions, iterable)
構造一個列表，列表的元素來自於iterable，返回對於這些元素function返回True的元素。iterable可以是個序列，支持迭代的容器或者一個迭代器。
filter函數相當於過濾，返回符合functions的列表中的元素。帶判斷的列表生成式:[i for i in list if i]
test_list = ['python', 'ruby', 'node.js']
result = filter((lambda x: x=='python'), test_list) ＃結果：['python']
float()
將字符串或者數字轉化成浮點數。
float('.3333') #0.3333
float('a.333') #報錯
float(1) #1.0
format(value[,format_spec])
將value轉化成“格式化”的表現形式，格式由format_spec控制。
_string = '{name} is a pythoner'.format(name='Xueweihan')
print _string # 'Xueweihan is a pythoner'
frozenset()
返回一個新的forzenset對象。就是一個不可變的集合，所以存在哈希值，可以作為字典的key。
注意：python的集合類型不支持整數。
getattr(object, name[,default])
返回object的屬性值。name必須是個字符串。如果名字指明的屬性不存在，則返回default參數。
例如：getattr(x, 'test')等於x.test。
globals()
globals(x)，x成為全局變量。
hasattr(object, name)
參數是一個對象和一個字符串。如果對象含有該屬性則返回True；否則返回False。
hash(object)
返回對象的hash值。hash值是整數，它被用於字典查找時快速比較字典的鍵。相同的數值有相同的hash（例如：1和1.0的hash值相同）
help([object])
調用幫助系統（主要用於交互式的使用過程中）。如果沒有指定object的話，則進入交互式的help幫助系統。
hex()
將number類型的數據，轉化成“0x”打頭小寫的十六進制字符串：
hex(33) #'-0x21'
#float類型數據
float.hex(0.32) #'0x1.47ae147ae147bp-2'
id(object)
返回對象的“表示”，這是一個整數，在對象的生命期內唯一且不變。
注意：CPython中：id就是對象的內存地址。
id(33) # 140300932661128
a = 33
id(a) # 140300932661128
b = 33
id(b) # 140300932661128
input()
獲取用戶的輸入。
建議用：raw_input
int(x, base=10)
將數字或字符串x轉化成一個整數，如果沒有參數則返回0。
isinstance(object, classinfo)
如果參數object是參數classinfo的一個實例；或者是一個子類的實例，最終返回真。
推薦使用這個而不是用type進行判斷。
isinstance(1, int) #True
issubclass(class, classinfo)
如果class是classinfo的子類，則返回真。
iter(o[,sentinel])
返回一個iterator(迭代器)對象。如果沒有第二個參數，o必須是個集合獨享，要么支持迭代協議參考，要么支持序列協議。例如：
for x in [1, 2, 3]:
pass
#等同於
it = iter([1, 2, 3])
while True:
try:
x = next(it)
except StopIteration:
break
如果有第二個參數sentinel，o必須是個可調用對象。使用場景：
# 讀取一個文件的行，直到讀到特定行
with open('test.txt') as fp:
for line in iter(fp.readline, ''):
process_line(line)
len(s)
返回對象的長度（元素的個數）。s可以是：序列或者集合。
len('xueweihan') #9
list([iterable])
返回一個列表，其中的元素來自於iterable。iterable可以是個序列，支持迭代的容器，或者迭代器對象。
list('xueweihan') #['x', 'u', 'e', 'w', 'e', 'i', 'h', 'a', 'n']
locals()
把傳入的變量，修飾成局部變量。
long()
將一個字符串或者數字傳化成一個長整數。
map()
遍歷iterable的每個元素，並把元素作為參數傳入function，返回結果的列表。
def add_two(num):
return num+2
num_list = [1,2,3,4,5]
map(add_two, num_list) #[3,4,5,6,7]
max()
返回可迭代的對象中最大的元素。
memoryview()
返回memoryview對象，它允許Python代碼訪問對象的內部數據而不用復制，只要該對象支持緩沖區協議。
如有疑問請參考python內建類型memoryview
min()
返回可迭代的對象中的最小的元素。
next(iterator[,default])
通過調用iterator(迭代器)的next()方法，得到它的下一個元素。如果有default參數，在迭代器迭代完之后返回該參數；否則拋出StopIteration。
test_next_data = iter([1,2,3])
print next(test_next_data, 'Done') #1
print next(test_next_data, 'Done') #2
print next(test_next_data, 'Done') #3
print next(test_next_data, 'Done') #Done
注意:通過iter()返回的就是迭代器。
object()
object是所有新式類的基類
class A(object):
pass
#繼承於object的類為新式類
oct()
將任意一個整數轉成一個八進制字符串。
open(name, [,mode[,buffering]])
打開文件的方法，返回一個file類型對象。如果文件不能打開拋出IOError。
mode：用什么方式打開文件。'r'讀文件；'w'寫文件；'a'附加。如果沒有mode，默認是'r'。
buffering: 緩沖
ord()
參考：chr()
注意:如果是unicode,則返回unicode碼
pow(x, y[,z])
返回x的y次冪：x**y
如果有z參數：(x**y) % z
print()
這個方法可以輸出內容到file對象。
注意:不常用，為了使print語句失效，而是用print()函數。（print和print()不是一個東西）可以在你的模塊上面使用future語句：from __future__ import print_function
property()
property其實就是個控制屬性的權限的方法。同時實現，經property裝飾的方法，可通過Object.xxx調用屬性，把實例方法，變成實例的屬性。這樣做的好處是：可以在方法中實現限制條件，同時限制可執行的操作。
class Student(object):
def __init__(self):
self._name = None
@property
def name(self):
return self._name
@name.setter
def name(self, value):
if value != 'xueweihan':
self._name = value
@name.deleter
def name(self):
print 'del name!'
del self._name
s = Student()
s.name = 'aaa'
s.name #賦值成功'aaa'
s.name = 'xueweihan'
s.name #賦值失敗'aaa'
del s.name #‘del name!’
注意:@property可以控制屬性，比如只讀屬性：不實現@xxx.setter和@xxx.deleter就可以了。
range(start, stop[,step])
用於創建列表，‘要頭不要尾’。setp參數為步長
range(5) #[0, 1, 2, 3, 4]
range(2, 4) #[2, 3]
range(10, 20, 5) #[10, 15]
raw_input()
獲取控制台的輸入
reduce(function,iterable[,initializer])
將帶有兩個參數的function累計地應用到iterable的元素上，從左向右。如果提供可選的參數initializer，它在計算時放在可迭代序列的最前面，並且當可迭代序列為空時作為默認值。例如：
reduce((lambda x,y: x+y), [1, 2, 3, 4])
#相當於計算(((1+2)+3)+4)
reload(module)
如果你重新修改了模塊，並且不打算停止重新啟動python解釋器的情況下使用該模塊的最新版本。那么就使用reload()，在reload之前就需要確保import過。
# test_reload.py
print 'a'
import test_reload #'a'
#修改test_reload.py ——> print 'b'
import test_reload #什么都輸出，因為沒有之前已經import過了，所以沒有重新加載
reload(test_reload) #'b'重新加載成功！
repr(object)
精准的返回某個對象可打印形式的字符串。返回的值，可以通過eval()執行。
a = repr('a') #"'a'"
reversed(seq)
返回一個反向的迭代器。seq必須是一個具有_reversed_()方法或支持序列協議的對象（實現_len_()和_getitem_()方法）。
test_reverse = reversed([1, 2, 3, 4]) #<listreverseiterator object at 0x10bcab810>
test_reverse.next #4
注意:可以編寫一個定制的_reversed_()方法的可能。
round(number[, ndigits])
返回一個浮點數的近似值，保留小數點后ndigits位，默認ndigits為零。這個方法不好用，因為近似值不是四舍五入。
round(2.675,2) #2.67
set([iterable])
返回一個集合對象，iterable是可迭代的對象。
setattr(object,name,value)
給object的屬性賦值，可以是存在的屬性，也可以是不存的屬性。例如：setattr(s, 'name','xueweihan')等同於s.name='xueweihan'
slice()
常用的切片方法：
a = [1, 2, 3]
a[1:2] #2
sorted(iterable[,cmp[,key[,reverse]]])
用於iterable對象排序的方法。
- cmp指定一個自定義的帶有兩個參數的比較函數（可迭代的元素），它應該根據第一個參數是小於、等於還是大於第二個參數返回負數、零或者正數：cmp=lambda x,y: cmp(x.lower(), y.lower())。默認值是None。
- key指定一個帶有一個參數的函數，它用於從每個列表元素選擇一個比較的關鍵字：key=str.lower。默認值是None（直接比較元素）。
- reverse是一個布爾值。如果設置為True，那么列表元素以反向比較排序。
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
sorted(student_objects, key=lambda student: student.age) # sort by age
#結果為：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
staticmethod(function)
返回一個靜態方法。
class C(object):
@staticmethod
def f(arg1, arg2):
pass
注意:靜態方法基可以在類上調用C.f()，也可以在實例上調用C().f()。
str(object='')
返回一個字符串，包含對象的友好可打印表達形式。
注意:print調用的就是對象的__str__方法
sum(iterable[,start])
將iterable的元素從左向右相加並返回總和。
sum([1, 2, 3]) #6
sum([1, 2, 3], 2) #8
super()
用於顯性的指定父類的方法。同時實現方法的綁定。
class C(B):
def method(self, arg):
super(C, self).method(arg) #C的父類實例的method()
tuple([iterable])
返回一個元素，元素順序和iterable的元素相同。
type(object)
返回object的類型。
type(name, bases, dict)
class X(object):
a = 1
X = type('X', (object,), dict(a=1)) # 當傳入三個參數時，返回一個新的類型對象。
unichr(i)
返回Unicode類型數據i的Unicode碼。例如：unichr(97)返回字符串u'a'。
unicode(object='')
返回object的Unicode版字符串
vars([object])
返回模塊，類，實例或者其他任何具有__dict__屬性的對象的__dict__屬性。(key:value形式的__dict__屬性)
xrange(x)
和range()方法一樣，區別就是它返回的是一個xrange對象而不是一個列表。惰性計算！當x很大的時候，一定要用xrange。
zip([iterable,...])
該函數返回一個元組的列表，其中第i個元素包含每個元素的序列的第i個元素。
x = [1, 2, 3]
y = [4, 5, 6]
#可用於轉置矩陣
zipped = zip(x, y) #[(1, 4), (2, 5), (3, 6)]
x2, y2 = zip(*zipped)
x == list(x2) and y == list(y2) #True
_import_()
這種高級引入模塊的方法，不常用，所以pass