Python常用函數

python學習筆記17-常用函數總結整理 

一、所有對象通用的運算符和函數

1、标準類型運算符

1)、對象值得比較

>,<,>=,<=,==,!=,<>(不等于的另外一個表示，逐漸退出曆史舞台）

2)、對象身份比較

is 對象身份比較

3）布爾類型 

and,or,not運算符的優先級按從低到高，not運算擁有最優先級，隻比素有運算符低一級

2、标準内建函數

type(obj) :接受一個對象做為參數，并傳回它的類型。它的傳回值是一個類型對象

cmp(obj1,obj2) :用于比較兩個對象obj1 和obj2， 如果obj1 小于obj2, 則傳回一個負整

數，如果obj1 大于obj2 則傳回一個正整數， 如果obj1 等于obj2， 則傳回0。

比較是在對象之間進行的，不管是标準類型對象還是使用者自定

義對象。如果是使用者自定義對象， cmp()會調用該類的特殊方法__cmp__()。

str(obj)和repr(obj) 或反引号運算符(``) 可以友善的以字元串的方式擷取對象的

内容、類型、數值屬性等資訊。str()函數得到的字元串可讀性好， 而repr()函數得到的字元

串通常可以用來重新獲得該對象, 通常情況下 obj == eval(repr(obj)) 這個等式是成立的

isinstance(obj,type) 判斷對象的類型

>>> s='jin'

>>> isinstance(s,str)

True

>>> isinstance(s,int) 

False

>>> isinstance(s,(int,str,float))

3、類型工廠函數

python2.2統一了類型和類，所有内建類型現在都是類。原來的所謂内建轉換函數像int(),type(),list()現在都成了工廠函數。

以前稱為内建函數的工廠函數

int(),long(),float(),complex() 将對象轉換為整數,長整數,浮點,複數

str(),unicode(),basestring() 将對象轉換為字元串類型，unicode，str和unicode的父類basestring

tuple(),list() 将對象轉換為元組，清單

type([obj]) 檢查資料類型，傳回對象類型

其他工廠函數

dict() 将對象轉換為字典

bool() 

set(),frozenset()

object()

classmethod()

super() ???

property() 性能？

file()

4、基礎内建函數

dir([obj]) 顯示對象屬性，如果沒有提供參數，則顯示全局變量的名字 

help([obj]) 顯示文檔字元5串，如果沒有提供從參數，則會進入互動幫助

len([obj]) 傳回對象長度

range([start],[stop],[step]) 傳回一個整數清單，起始值為start,結束值為stop-1，start預設為0,step步進預設為1

open(filenam,mode) 以mode[r,w,a讀寫追加]方式打開filename檔案對象 

raw_input(str) 等待使用者輸入一個字元串，可以提供一個可選的參數str用作提示資訊，比如互動模式下打開檔案

id() 可以看到變量指向不同的對象的位置。

>>> X=33

>>> Y=33

>>> X==Y

>>> X is Y

>>> id(X)

674748936

>>> id(Y)

二、數字函數總結

1、标準類型運算符（也是工廠函數）

cmp() 比較兩個數字的大小

str() 将數字轉換為字元串

type() 傳回數字對象的類型

2、轉換工廠函數

int(obj,base=10) 可接受進制參數,預設10進制。傳回一個字元串或數值對象的整型表示

long(obj,base=10) 可接受進制參數，傳回一個字元串或資料對象的長整型表示

float(obj) 傳回一個字元串或資料對象的長整型表示

complex(str) 傳回一個字元串的複數表示，或者根據給定實數生産複數對象 

bool(obj) 将整數型1和0轉換為标注布爾值True和False

3、功能函數

abs(num) 傳回給定參數的(num)絕對值

coerce(num1,num2) 僅傳回一個包含類型轉換完畢的兩個數值元素的元組 如傳回(1,2)

divmod(num1,num2) 把除法個取餘運算集合起來，傳回一個包含商和餘數的元組。如divmod(10,3)傳回(3,1),如divmod(10,2.5)傳回(4.0,0.0)

pow(x,y)或** 指數運算 一個内建函數，一個是操作符 可以使用第三個參數，即将運算結果和第三個參數取餘運算。常用語密碼運算.

pow(x,y,z)比pow(x,y)%z性能好

round() 常用于浮點型，進行四舍五入運算，不提供小數位參數，傳回和第一參數最接近的整數，第2個參數告訴round函數精确到小數點後幾位。

rount(3,4) 結果3 round(3.49999,1)結果 3.5

4、僅用于整數的函數

hex(num) 将數字換行為16進制并以字元串形式傳回

oct(num) 将數字換行為8進制并以字元串形式傳回

chr(num) 将ASCII的數字換行為ASCII的字元，範圍隻能是0<=num<=255

ord(num) 接受一個ASCII或Unicode字元（長度為1的字元串），傳回相應的ASCII值或Unicode值

unichar(num) 将數字換行為8進制并以字元串形式傳回

三、字元串函數

(一)标準類型操作符和标準内建函數

1)、标準類型操作符

>,<,>=,<=,==,!=,<>對象值得比較

注：做比較時字元串是按ASCII值的大小來比較的

and,or,not 布爾類型 

2）标準内建函數

type(obj) 

cmp(obj1,obj2)

(二)序列操作

1、序列操作

字元串屬于序列對象，可以使用所有序列的操作和函數 

切片 [] [:] [::]

簡單總結：

*索引（S[i])擷取特定偏移的元素。

——第一個元素偏移為0

——（S[0])擷取第一個元素。

——負偏移索引意味着從最後或右邊反向進行計數

——（S[-2])擷取倒數第二個元素（就像S[len(s)-2]一樣

*分片[S[i:j]提取對應的部分作為一個序列

——右邊界不包含在内

——分片的邊界預設為0和序列的長度，如果沒有給出的話S[:]

——（S[1:3])擷取了從偏移為1，直到但不包括偏移為3的元素

——（S[1:])擷取從偏移為1到末尾之間的元素

——（S[:3])擷取從偏移為0直到但不包括偏移為3的元素

——（S[:-1])擷取從偏移為0直到但不包括最後一個元素之間的元素

——（S[:])擷取從偏移為0到末尾之間的元素,這有效地實作了頂層S拷貝

拷貝了一個相同值，但是是不同記憶體區域的對象。對象字元串這樣不可變的對象不是很有用，但是對于可以實地修改的對象來說很有用。

比如清單。

擴充分片：第三個限制值 【步進】

完×××式：X[I:J:K]:這辨別索引X對象的元素，從偏移為I直到J-1，每隔K元素索引一次。第三個限制值，K，預設為1

執行個體

>>> S='abcdefghijk'

>>> S[1:10]

'bcdefghij'

>>> S[1:10:2]

'bdfhj

也可以使用負數作為步進。

分片表達式

>>> "hello"[::-1]

'olleh'

通過負數步進，兩個邊界的意義實際上進行了反轉。

3、成員操作符 in ，not in

傳回布爾值True 或False

可以使用string子產品來判斷輸入字元的合法性，可見成品中的idcheck.py

4、字元串連接配接

+ 連接配接字元串 ‘name’+' '+'jin'

字元串格式化 '%s %s' % ('name','jin')

join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])

5、删除清空字元串

del aString

aString=''

(三)、序列函數

序列類型函數

len(str) 傳回字串的長度

enumerate(iter):接受一個可疊代對象作為參數，傳回一個enumerate 

max(str)/min(str):max()和min()函數對其他的序列類型可能更有用,但對于string類型它們能很好地運作,傳回最大或者最小的字元(按照ASCII 碼值排列),

zip([it0, it1,... itN]) 傳回一個清單，其第一個元素是it0,it1,...這些元素的第一個元素組成的一個元組，第二個...,類推.

reversed(seq)c 接受一個序列作為參數,傳回一個以逆序通路的疊代器(PEP 322)

sorted(iter,func=None,key=None,reverse=False) 接受一個可疊代對象作為參數，傳回一個有序的清單;可選參數func,key 和reverse 的含義跟list.sort()内建函數的參數含義一樣.

注意：

sorted等需要在原處修改的函數無法用在字元串對象，但可以産生新的對象

sum處理的對象是數字，不能用在字元串

>>> sorted(s)

['a', 'e', 'e', 'g', 'g', 'g', 'o']

(四)隻适合于字元串類型的函數

1)raw_input()函數

内建的raw_input()函數使用給定字元串提示使用者輸入并将這個輸入傳回，下面是一個使

用raw_input()的例子:

>>> user_input = raw_input("Enter your name: ")

>>> prin user_input

2)str() and unicode()

str()和unicode()函數都是工廠函數，就是說産生所對應的類型的對象.它們接受一個任

意類型的對象，然後建立該對象的可列印的或者Unicode 的字元串表示. 它們和basestring 都

可以作為參數傳給isinstance()函數來判斷一個對象的類型

3)chr(), unichr(), and ord()

chr()函數用一個範圍在range(256)内的(就是0 到255)整數做參數,傳回一個對應的字元.unichr()跟它一樣，隻不過傳回的是Unicode 字元

ord()函數是chr()函數(對于8 位的ASCII 字元串)或unichr()函數(對于Unicode 對象)

的配對函數,它以一個字元(長度為1 的字元串)作為參數,傳回對應的ASCII 數值，或者Unicode

數值，如果所給的Unicode 字元超出了你的Python 定義範圍,則會引發一個TypeError 的異常

(五)、隻适用于字元串的操作符

1、格式化操作符 %

字元串格式化符号

格式化字元 轉換方式

%c 轉換成字元(ASCII 碼值，或者長度為一的字元串)

%ra 優先用repr()函數進行字元串轉換

%s 優先用str()函數進行字元串轉換

%d / %i 轉成有符号十進制數

%ub 轉成無符号十進制數

%ob 轉成無符号八進制數

%xb/%Xb (Unsigned)轉成無符号十六進制數(x/X 代表轉換後的十六進制字元的大

小寫)

%e/%E 轉成科學計數法(e/E 控制輸出e/E)

%f/%F 轉成浮點數(小數部分自然截斷)

%g/%G %e 和%f/%E 和%F 的簡寫

%% 輸出%

格式化操作符輔助指令

符号 作用

* 定義寬度或者小數點精度

- 用做左對齊

+ 在正數前面顯示加号( + )

<sp> 在正數前面顯示空格

# 在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決于

用的是'x'還是'X')

0 顯示的數字前面填充‘0’而不是預設的空格

% '%%'輸出一個單一的'%'

(var) 映射變量(字典參數)

m.n m 是顯示的最小總寬度,n 是小數點後的位數(如果可用的話)

2、字元串模闆: 更簡單的替代品

由于新式的字元串Template 對象的引進使得string 子產品又重新活了過來，Template 對象

有兩個方法,substitute()和safe_substitute().前者更為嚴謹,在key 缺少的情況下它會報一

個KeyError 的異常出來，而後者在缺少key 時，直接原封不動的把字元串顯示出

3、原始字元串操作符( r/R )

字元串抑制轉義r'帶特殊符号的字串'

myfile=open(r'C:\new\text.data','w')

4、Unicode 字元串操作符( u/U )

u'abc' U+0061 U+0062 U+0063

u'\u1234' U+1234

u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012

(六)字元串對象的方法：

1、删減

T2.lstrip() 移除字元串前面字元（預設空格），傳回字元串

T2.rstrip() 移除字元串後面字元（預設空格），傳回字元串

T2.strip() 移除字元串前後面空格，傳回字元串 預設空格，可以其他字元 S.strip('"')

2、切割

partition(sep),

rpartition(sep),

splitlines([keepends]),#把S按照行分割符分為一個list，keepends是一個bool值，如果為真每行後而會保留行分割符

split([sep [,maxsplit]]),#以sep為分隔符，把S分成一個list。maxsplit表示分割的次數。預設的分割符為空白字元

rsplit([sep[,maxsplit]]) #從右到左切割

備注：

partition()函數族是2.5版本新增的方法。它接受一個字元串參數，并傳回一個3個元素的 tuple 對象。

如果sep沒出現在母串中，傳回值是 (sep, ‘’, ‘’)；

否則，傳回值的第一個元素是 sep 左端的部分，第二個元素是 sep 自身，第三個元素是 sep 右端的部分。

>>> S.partition(';') 

('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')

參數 maxsplit 是分切的次數，即最大的分切次數，是以傳回值最多有 maxsplit+1 個元素。

s.split() 和 s.split(‘ ‘)的傳回值不盡相同

>>> ' hello world!'.split()

 ['hello', 'world!']

 >>> ' hello world!'.split(' ')

 ['', '', 'hello', '', '', 'world!']

>>> S.split('\n',3)

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']

超過最大切割個數後面的全部為一個元素

按行切割

>>> S

'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'

>>> S.splitlines()

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']

産生差異的原因在于當忽略 sep 參數或sep參數為 None 時與明确給 sep 賦予字元串值時 split() 采用兩種不同的算法。

對于前者，split() 先去除字元串兩端的空白符，然後以任意長度的空白符串作為界定符分切字元串

即連續的空白符串被當作單一的空白符看待；

對于後者則認為兩個連續的 sep 之間存在一個空字元串。是以對于空字元串（或空白符串），它們的傳回值也是不同的：

>>> ''.split()

 []

 >>> ''.split(' ')

 ['']

3、變形

lower(),#全部小寫

upper(),#全部小寫

capitalize(),#首字母大寫

swapcase(),#大小寫交換

title()#每個單詞第一個大寫,其他小寫

備注

因為title() 函數并不去除字元串兩端的空白符也不會把連續的空白符替換為一個空格，

是以建議使用string 子產品中的capwords(s)函數，它能夠去除兩端的空白符，再将連續的空白符用一個空格代替。

>>> ' hello world!'.title()

' Hello World!'

>>> string.capwords(' hello world!')

'Hello World!'

4、連接配接

join(seq)

join() 函數的高效率（相對于循環相加而言），使它成為最值得關注的字元串方法之一。

它的功用是将可疊代的字元串序列連接配接成一條長字元串，如：

>>> conf = {'host':'127.0.0.1',

 ... 'db':'spam',

 ... 'user':'sa',

 ... 'passwd':'eggs'}

 >>> ';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())

 'passswd=eggs;db=spam;user=sa;host=127.0.0.1'

>>> S=''.join(T) #使用空字元串分割把字元清單轉換為字元串

5、查找

count( sub[, start[, end]]),#計算substr在S中出現的次數 

find( sub[, start[, end]]),#傳回S中出現sub的第一個字母的标号，如果S中沒有sub則傳回-1。start和end作用就相當于在S[start:end]中搜尋 

index( substr[, start[, end]]),#與find()相同，隻是在S中沒有substr時，會傳回一個運作時錯誤

rfind( sub[, start[,end]]),#傳回S中最後出現的substr的第一個字母的标号，如果S中沒有substr則傳回-1，也就是說從右邊算起的第一次出現的substr的首字母标号

rindex( sub[, start[, end]])

T2.find('ie') 字元串方法調用：搜尋

find()----找到的第一個符合字元的index

rfind()-----找到最後一個符合的字元的index

find()函數族找不到時傳回-1，index()函數族則抛出ValueError異常。

另，也可以用 in 和 not in 操作符來判斷字元串中是否存在某個模闆

6、替換

replace(old, new[,count]),#把S中的oldstar替換為newstr，count為替換次數。這是替換的通用形式，還有一些函數進行特殊字元的替換 

translate(table[,deletechars]) #使用上面的函數産後的翻譯表，把S進行翻譯，并把deletechars中有的字元删掉

replace()函數的 count 參數用以指定最大替換次數

translate() 的參數 table 可以由 string.maketrans(frm, to) 生成

translate() 對 unicode 對象的支援并不完備，建議不要使用

7、判定

isalnum(),#是否全是字母和數字，并至少有一個字元

isalpha(),是否全是字母，并至少有一個字元

isdigit(),是否全是數字，并至少有一個字元 ，如果是全數字傳回True,否則傳回False

islower(),#S中的字母是否全是小寫 

isupper(),#S中的字母是否是大寫 

isspace(),#是否全是空白字元，并至少有一個字元

istitle(),S是否是首字母大寫的

startswith(prefix[, start[, end]]), #是否以prefix開頭 

endswith(suffix[,start[, end]]),#以suffix結尾 

這些函數都比較簡單，顧名知義。需要注意的是*with()函數族可以接受可選的 start, end 參數，善加利用，可以優化性能。

另，自 Py2.5 版本起，*with() 函數族的 prefix 參數可以接受 tuple 類型的實參，當實參中的某人元素能夠比對，即傳回 True。

8、填充

字元串在輸出時的對齊：

center(width[, fillchar]), 字元串中間對齊

ljust(width[, fillchar]), 字元串左對齊，不足部分用fillchar填充，預設的為空格

rjust(width[, fillchar]), 字元串右對齊，不足部分用fillchar填充，預設的為空格

zfill(width), 把字元串變成width長，并在右對齊，不足部分用0補足

expandtabs([tabsize])把字元串中的制表符（tab）轉換為适當數量的空格。

fillchar 參數指定了用以填充的字元，預設為空格

zfill的z為zero的縮寫,顧名思義,是以字元0進行填充，用于數值輸出

expandtabs()的tabsize 參數預設為8。它的功能是把字元串中的制表符（tab）轉換為适當數量的空格。

9、編碼

encode([encoding[,errors]]),

decode([encoding[,errors]])

這是一對互逆操作的方法，用以編碼和解碼字元串。因為str是平台相關的，它使用的内碼依賴于作業系統環境，

而unicode是平台無關的，是Python内部的字元串存儲方式。

unicode可以通過編碼（encode）成為特定編碼的str，而str也可以通過解碼（decode）成為unicode。

# 其中encoding可以有多種值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支援。errors預設值為"strict"，意思是UnicodeError。

可能的值還有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通過

expandtabs

參考

http://www.cnblogs.com/rubylouvre/archive/2011/06/19/2083855.html

http://www.cnblogs.com/lovemo1314/archive/2010/10/07/1845025.html

檢查對象是否有相同值得和檢查是否是同一對象。

==檢查對象是否有相同的值。 is操作符，檢查對象的同一性。如果兩個變量名精準地指向同一個對象，它會傳回True。是以這是一種更嚴格的相等測試。

實際上,is隻是比較現實引用的指針。是以如果必要的話是代碼中檢測共享引用的一種方法。如果變量名引用值相等。但是為不同的對象，它的傳回值将是False.

>>> L=[1,2,3]

>>> M=[1,2,3]

>>> L==M

>>> L is M

查詢一個對象被引用 的次數：在sys子產品中的getrefcount函數傳回對象應用的次數。

T2.lstrip() 移除字元串前面空格，傳回字元串

T2.rstrip() 移除字元串後面空格，傳回字元串

如果centos6.2 主機名前後有"

for line in open('/etc/sysconfig/network', 'r'):

 if 'HOSTNAME' in line.rstrip(): #in 'HOSTNAME':

 hostname = line.rstrip().replace('HOSTNAME=', '').strip('"')

四、清單的函數

(一)、标準内建函數

type()

cmp()

str()

isinstance()

(二）序列類型操作符

序列操作符 作用

seq[ind] 獲得下标為ind 的元素

seq[ind1:ind2] 獲得下标從ind1 到ind2 間的元素集合

seq * expr 序列重複expr 次

seq1 + seq2 連接配接序列seq1 和seq2

obj in seq 判斷obj 元素是否包含在seq 中

obj not in seq 判斷obj 元素是否不包含在seq 中

1、成員關系 in,not in

對象 [not] in 序列

2、連接配接操作符(+)

sequence1+sequence2

3、重複操作符(*)

sequence*int

int必須是一個整數，而且不能使長整數

4、切片操作符[][N][n:m][:][::][n:m:l]

5、使用步長來進行擴充切片[n:m:l]

s='abcded'

s[::-1] 類似翻轉

s[::2] 隔一個取一個

6、切片索引的更多内容

切片索引的文法要比簡單的單一進制素索引靈活的多。開始和結束素引值可以超過字元串的

長度。換句話說，起始索引可以小于0,而對于結束索引，即使索引值為100 的元素并不存在也

不會報錯

有一個字元串，我們想通過一個循環按照這樣的形式顯示它：每次都把

位于最後的一個字元砍掉，下面是實作這個要求的一種方法：

>>> s = 'abcde'

>>> for i in range(-1, -len(s), -1):#-1,-len(s)倒數，步進在-1 有正數

... print s[:i]

(三)、序列類型函數[不是對象的方法是函數]

1)清單求長：len(L)

2)清單中的最大值最小值： max(L)和min(L)

max()和min()函數在字元串操作裡面用處不大,因為它們能對字元串做的隻能是找出

串中"最大"和"最小"的字元(按詞典序),而對清單和元組來說,它們被定義了更多的用處.比如

對隻包含數字和字元串對象的清單,max()和min()函數就非常有用,重申一遍,混合對象的結構

越複雜傳回的結構準确性就越差

3)正向排序和反向排序：sorted(L) reversed(L) 

4)zip() 對多個清單内容進行組合

傳回一個清單，其第一個元素是it0,it1,...這些元素的第一個元素組成的一個元組，第二個...,類推.

6)sum() 清單求和

7）enumerate(iter) ：接受一個可疊代對象作為參數，傳回一個enumerate 對象(同時也是一個疊代器),該對象生成由iter 每個元素的index 值和item值組成的元組(PEP 279)

(四)【清單類型的内建函數】清單的方法

http://blog.csdn.net/sheila_1988/article/details/7242256

1、list函數

将字元串轉化成清單，例

>>> name=list('hello')

>>> name

['h', 'e', 'l', 'l', 'o']

2、改變清單：元素指派

>>> L

['1', 'a']

>>> L[0]=2

[2, 'a']

3、分片指派（第一個參數是開始分片的起始位置，第二個參數是結束分片的下一個位置）

1)修改序列

>>> name = list('Perl') 

>>> name = list('Perl')

>>> name[1:] = list('ython')

['P', 'y', 't', 'h', 'o', 'n']

2)插入序列

>>> num=[1,5]

>>> num[1:1]=[2,3,4]

>>> num

[1, 2, 3, 4, 5]

3)删除序列

>>> num=[1, 2, 3, 4, 5]

>>> num[1:4]=[2]

[1, 2, 5]

4、添加元素 append 和 extend 

1)添加一個元素 append

>>> L.append('NI')

[2, 'a', 'NI']

2)擴充extend 在結尾添加多個元素 和字元串的' '.jion('LIST') 有點類似

在清單末尾一次性追加另一個序列中的多個值（用新清單擴充原來的清單）

函數中填寫一個清單

>>> a = [1, 2, 3]

>>> a.extend([4,5,6])

>>> a

[1, 2, 3, 4, 5, 6]

或者填一個清單對象

>>> a = [1, 2, 3] 

>>> b = [4, 5, 6] 

>>> a.extend(b) 

5、删除 pop,del,remove

1)pop 根據位置删除[填寫序列]

移除清單中的一個元素（預設最後一個元素），并且傳回該元素的值

pop(元素位置)，傳回删除的元素

>>> L.pop(1)

'a'

2)、删除 del語句實作

del 清單[元素位置]

>>> L=[2, 'NI']

>>> del L[1]

[2]

3）、移除 [填寫對象]

remove(元素)

>>> L.remove('NI')

6、插入

L.insert(位置,'元素')

注意，這個會改變原來元素的位置

>>> L.insert(0,'test')

['test', 2]

7、排序 sort

1）升序

>>> L.sort() 預設安裝升序進行排序

2）排序翻轉

反向清單中元素

>>> L.reverse()

排序執行個體：

對原清單進行排序

[html] view plaincopy

>>> x = [4, 6, 2, 3, 5, 1] 

>>> x.sort() 

>>> x 

[1, 2, 3, 4, 5, 6] 

若不需要修改原序列(注意：如果這裡采用x = y的話，那麼x和y都指向同一個清單，即使操作時隻對y排序，實際上x也會被排序)

方法一：建立副本y，并對y進行排序

>>> y = x[:] 

>>> y.sort() 

[4, 6, 2, 3, 5, 1] 

>>> y 

方法二：使用sorted函數(傳回一個已排序的副本，不改變原序列)

>>> y = sorted(x) 

關鍵字排序：key 

長度(len)排序：###按長度排序

>>> x = ['bb', 'eeeee', 'a', 'dddd', 'ccc'] 

>>> x.sort(key = len) 

8.索引 index

從清單中找出某個值第一個比對項的索引位置

['a', 'c', 'd', 'c']

>>> L.index('c')

1

9、計數

統計某個元素在清單中出現的次數

>>> L.count('c') 

2

10、比較兩個數字的大小

>>> cmp(43,54)

-1

>>> cmp(43,42)

>>> cmp(43,43)

(五)、清單特殊強大的功能

清單解析

>>> [ i * 2 for i in [8, -2, 5] ]

[16, -4, 10]

>>> [ i for i in range(8) if i % 2 == 0 ]

[0, 2, 4, 6]

五、元組

1、标準類型操作符,序列類型操作符和内建函數.

元組的對象和序列類型操作符還有内建函數跟清單的完全一樣.你仍然可以對元組進行切

片操作,合并操作,以及多次拷貝一個元組,還可以檢查一個對象是否屬于一個元組,進行元組之

間的比較等.

1)、标準類型運算符

>,<,>=,<=,==,!=,<> 對象值得比較

2)、标準内建函數

cmp(obj1,obj2) 

str(obj)和repr(obj) 或反引号運算符(``) 

3)、序列類型操作符

seq[ind1:ind2:ind3] 以為ind3為步進獲得下标從ind1 到ind2 間的元素集合

2、元組對象的方法

和字元串,清單不同，元組沒有自己的方法

3、元組不可修改，和清單轉哈

不可原處修改，修改都是淺拷貝新對象。轉換也是産生新對象

list(tuple) 

tuple(list)

六、字典

0、字典中有清單可以使用清單的函數

為嵌套添加資料

>>> off['job'].append('jantior')

>>> off['job']

['dev', 'mgr', 'jantior']

>>> off['job'][2]

'jantior'

避免擷取到一個不存在的鍵我們使用字典的has_key方法判斷鍵的存在性

>>> help(D.has_key)

Help on built-in function has_key:

has_key(...)

 D.has_key(k) -> True if D has a key k, else False

>>> D.has_key('k') 

Ptest.get('name','Bad choice') 字典的get方法，如果有name鍵則傳回其值，如果沒有則傳回預設值,注意不會修改原來的對象。

1、指派、修改、索引

D1={} 空字典

D={'one':1} 設定字典

D2={'name':'diege','age':18} 兩項目字典

D3={'name':{'first':'diege','last':'wang'},'age':18} 嵌套

D1[key]='class' 增加資料：已經存在就是修改，沒有存在就是增加資料

D2['name'] 以鍵進行索引計算

D3['name']['last'] 字典嵌套字典的鍵索引

D['three'][0] 字典嵌套清單的鍵索引

D['six'][1] 字典嵌套元組的鍵索引

2、健,值,求長,索引

dict.keys() 方法：鍵清單 傳回一個包含字典中鍵的清單

dict.values() 方法：值清單 傳回一個包含字典中所有值的清單

list(D) 擷取D這個字典的的KEY的 MS按字典順序排序成一個清單 好像也不是

len(D) 方法：求長（存儲元素的數目)

3、删除,拷貝,合并,清空

1)删除

del dict[’key'] 函數del 函數字典中指定鍵

dict.pop('age') 方法：删除 根據key删除,并傳回删除的value

dict.pop(key[, default]) 和方法get()相似，如果字典中key 鍵存在，删除并傳回dict[key]，如果key 鍵不存在，且沒有給出default 的值，引發KeyError 異常。

dict.popitem() 從字典前面一對K:V的方式删除，并傳回K,V合成的元組

>>> D

{'name': 'jin', 'sex': 'man'}

>>> D.popitem() 

('name', 'jin')

>>> D #剩下

{'sex': 'man'}

del dict[’sex] 

2)拷貝

dict.copy() 方法：拷貝 傳回字典(淺複制)的一個副本

3)合并

D2.update(D1) 方法：合并。D1合并到D2,D1沒有變化，D2變化。注意和字元串，清單好的合并操作”+“不同

4)清除

dict.clear() 方法：清除字典 删除字典中所有元素,字典對象還有，但字典是空字典

del dict del函數 起整個dict字典 這個是這個字典對象都沒有了

4、key存在判斷

dict.has_key(key) 方法：判斷字典是否有key鍵 如果鍵(key)在字典中存在，傳回True，否則傳回False.

'name' in D 方法：成員測試：注意使用key來測試

'name' not in D 方法： 成員測試，不存在key的情況

5、預設值

1)、建立時設定預設值

dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 鍵，由dict[key]=default 為它指派，如果存在則不改變原字典值

>>> D={}

>>> D.setdefault('name','test')

'test'

>>> D.setdefault('name','jin')

'jin'

{'name': 'jin'}

2)、求值是設定字典預設值

dict.get(key,default=None) 對字典dict中的存在的鍵key,傳回它對應的值value，如果字典中不存在此鍵，則傳回default的值(注意，參數default 的預設值為None)

在Python2.2版本引入in 和not in 後，此方法幾乎已廢棄不用了，但仍提供一個可工作的接口。

>>> D.get('sex','man') #不存在時傳回設定的預設值

'man'

>>> D.get('name','diege') #存在時傳回存在健的值，而不是get設定的預設值

6、特别健值組合

dict.items() 傳回一個包含字典中(鍵, 值)對元組的清單

dict.iter() 方法iteritems(), iterkeys(), itervalues()與它們對應的非疊代方法一樣，不同的是它們傳回一個疊代子，而不是一個清單。

dict.items() 執行個體

>>> D.items()

[('name', 'jin'), ('sex', 'man')]

iteritems() 執行個體

>>> for i in D.iteritems():

... print i

... 

('sex', 'man'

'fromkeys', 

'get',

iterkeys() 執行個體

>>> for i in D.iterkeys():

... print i 

name

sex

itervalues() 執行個體

>>> for i in D.itervalues():

jin

man

8、建立字典的多種方法

1）

>>> {'name':'diege','age':45}

{'age': 45, 'name': 'diege'}

2）

>>> D['name']='lily'

>>> D['age']=18 

{'age': 18, 'name': 'lily'}

3）dict(key1='value1',key2='value2')

>>> dict(name='kelly',age=19) 

{'age': 19, 'name': 'kelly'}

注意這裡name,age沒有 ’‘括起來，因為這裡是變量。

4)dict([(’key1','value1'),(key2','value2')])

>>> dict([('name','tom'),('age',23)])

{'age': 23, 'name': 'tom'}

這裡将每一個資料(屬性），做為元組放到一個清單裡傳遞給dict函數

dict(清單，清單中的每個元素是一對key value 組成的元組)

5）dict(zip(keyslist,valslist)) 

>>> keyslist=['shell','sql']

>>> valslist=[['s1','k1','all'],['s1','k1','all']]

>>> keyslist

['shell', 'sql']

>>> valslist

[['s1', 'k1', 'all'], ['s1', 'k1', 'all']]

>>> D=dict(zip(keyslist,valslist)) 

{'shell': ['s1', 'k1', 'all'], 'sql': ['s1', 'k1', 'all']}

6）dict.fromkeysc(seq,val=None) 方式

dict.fromkeysc(seq,val=None) 建立并傳回一個新字典，以seq中的元素做該字典的鍵的清單，val 做該字典中所有鍵對應的初始值(如果不提供此值，則預設為None)

dict.fromkeys 可以從一個清單讀取字典的key 值預設為空，可指定初始值.兩個參數一個是KEY清單，一個初始值

>>> dict.fromkeys(['a','b','c'],0)

{'a': 0, 'c': 0, 'b': 0}

6種方法的選擇技巧

*如果可以事先拼除整個字典，那麼第一種是很友善的。

*如果需要一次動态地建立字典的一個字段，第二種比較合适

*第三種關鍵字形式所需的代碼比常量少，【但是鍵必須是都是字元串才可行】

*如果需要在程式運作時把鍵和值逐漸建成序列。第四中比較有用。

zip函數把程式運作動态獲得的鍵和值清單合并在一起（例如分析資料檔案字段）

如果所有鍵的值都相同，可以使用特殊形式對字典進行初始化。簡單傳入一個鍵清單，以及所有鍵的初始值（預設為空）dict.fromkeysc(

>>> D={} 

>>> D={'one':1}

{'one': 1}

清單不能通過這樣的方法來增加資料，清單隻能通過append方法，清單之能通過L[1]='A'這樣的方法來修改已存在序列的資料。

五、檔案

方法 描述

f.read([n]) 讀取至多 n 位元組

f.readline([n]) 讀取一行中的前 n 字元。如果 n 被省略，就讀取整行

f.readlines() 讀取所有的行并傳回一個包含所有行的清單

f.xreadlines() 傳回一個疊代器，每次疊代傳回檔案的一個新行

f.write(s) 将字元串 s 寫入檔案

f.writelines(l) 将清單 l 中的所有字元串寫入檔案

f.close() 結束檔案

f.tell() 傳回目前的檔案指針

f.seek(offset [, where]) 定位到一個新的檔案位置

f.isatty() 如果 f 是一個互動式終端則傳回 1

f.flush() 重新整理輸出緩沖區

f.truncate([size]) 如果檔案長于 size 就截短它至 size 大小

f.fileno() 傳回一個整型的檔案描述符

f.readinto(buffer ,nbytes)讀取 n 位元組資料至一個 buffer 對象 【】

f.name 檔案名

f.mode 檔案類型 讀或寫

(一)内建函數open（）和file（）

文法：file_object = open(fiel_name, access_mode=’r’, buffering=-1)

File_name是要打開的檔案名字的字元串，可以使相對路徑或者絕對路徑,預設檔案儲存在運作python的起始路徑,access_mode可選參數,表示檔案打開的模式,’r’,’w’,’a’ 分别代表讀取，寫入和追加。還有個’U’模式，代表通用換行符支援。

‘r’或者’U’模式打開的檔案必須是已經存在的，使用’w’模式打開的檔案若存在則首先清空，然後重新建立。以’a’模式打開的檔案是為追加資料準備的，所有寫入資料都将追加到檔案的末尾。

另一個可選參數buffering用于訓示通路檔案所采用的緩沖方式，0表示不緩沖，1表示緩沖一行資料，大于1代表用給定值作為緩沖區大小，不提供參數或者負值代表使用系統預設緩沖機制。

File（）和open（）的用法相同。

(二)檔案内建方法：

1、讀取

read([size])方法用來直接讀取位元組到字元串中，可以指定讀取數目，預設是檔案将被讀取直至末尾。

readline()讀取打開檔案的一行，包括行結束符，也可選size參數，預設為-1，代表直至讀到行結束符。

readlines()不和前兩個一個傳回一個字元串，它會讀取所有行然後把它們作為一個字元串清單傳回，有一個可選參數sizhint代表傳回的最大位元組大小。

xreadlines() file.xreadlines()和xreadlines.xreadlines(file) 是一種更高校的檔案讀取, 一次讀取一塊, 而不是一次讀取所有行, 但是, 由于iter取代了該功能, 是以會被廢棄.

讀取指定位元組

>>> fl=open('/etc/rc.local')

>>> fl.read(10) #讀取10個位元組

'#!/bin/sh\n'

讀取檔案所有内容到一個字元串

>>> f=open('data.ext','r')

>>> f.read() 讀取所有内容到一個字元串

按行讀取

>>> f.readline() 

'Hello\n

>>> fl.readline() 

'ill be executed *after* all the other init scripts.\n'

>>> fl.readline(12) #也可以讀取行為指定位元組

'# You can pu

讀取所有行到一個清單

>>> f.readlines() 

['Hello\n', 'world\n']

讀取的疊代

next()檔案疊代方法，無需将檔案讀取。

>>> f=open('/etc/rc.local')

>>> f.next() 下一行

'#!/bin/sh\n

逐行讀取文本的最佳方式就是根本不要去讀取，其替代的方法就是，讓for循環在每輪自動調用next進而前進到下一行

>>> for line in open('/etc/rc.conf'):

... print line.upper(),

讀取所有進一個清單，一行一個元素

>>> fl.readlines() 

["t your own initialization stuff in here if you don't\n", '# want to do the full Sys V style init stuff.\n', '\n', 'touch /var/lock/subsys/local\n', 'sh /root/bin/iptables_init.sh\n']

>>> fl.xreadlines()

<open file '/etc/rc.local', mode 'r' at 0xb77b1078>

2、讀取指定行

有些時候我們，隻讀取指定行，這個時候，需要用到其他子產品了

3、寫入

write()内建方法功能與read()和readline()相反，它把含有文本資料或二進制資料塊的字元寫到檔案中去。

和readline()一樣，writelines()方法是針對清單的操作，它接受一個字元串清單作為參數，将它寫入檔案，行結束符不會自動加入，是以如果需要的話，你必須在調用writelines()前給每行結尾加上行結束符。

f.write(s)執行個體

>>> f=open('data.ext','w')

>>> f.write('Hello\n')

>>> f.write('world\n') 

>>> f.close()

>>> S='the 1st line\nthe 2nd line\n' 

>>> f=open('/root/test100.data','w',0)

>>> f.write(S)

# cat test100.data

the 1st line

the 2nd line

f.writelines(l) 執行個體

>>> L=['the 1st line\n','the 2nd line\n']

>>> f=open('/root/test99.data','w',0)

>>> f.write(L)

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

TypeError: argument 1 must be string or read-only character buffer, not list

f.write 寫入的對象隻能使字元串

>>> f.writelines(L)

# cat test99.data 

file.flush()沒有刷到硬碟可能會出一下問題

http://topic.csdn.net/u/20120620/10/69378f85-4386-476c-b0ab-34a1bcd181b1.html

4、關閉檔案

讀入檔案或寫入檔案後一定要關閉檔案

比較好的方法

with open("hello.txt") as f:

 for line in f:

 print line

這種方式打開後會自動關閉

f = open("hello.txt")

try:

finally:

 f.close()

老的版本使用try不管什麼情況下關閉檔案的方式

5、檔案基本資訊

>>> f

<open file '/root/test.file', mode 'r' at 0xb77b18b8>

>>> f.name #f.name open()函數打開的檔案名 否則，它就是一個表示檔案來源的字元串

'/root/test.file'

>>> f.mode #檔案打開模式 

'r'

>>> f.fileno() #fileno()回一個打開檔案的整型檔案描述編号，有些子產品在進行低層次 I/O操作時會用到

3

>>> f.isatty() #如果 f 是一個互動式終端則傳回 1

>>> f.closed #f.closed 表示檔案狀态的布爾值: 0 表示檔案打開， 1 表示已關閉。 

>>> f.softspace

#f.softspace這是一個布爾值在使用print語句時表示在列印另一個值之前，是否要先列印一個空白符。若用類來模仿檔案操作則必須提供這樣一個可寫的屬性，并将其初始化為0。

6、檔案内移動 seek()

seek()方法可以在檔案中移動檔案指針到不同的位置，offset位元組代表對于某個位置偏移量，位置的預設值為0，代表從檔案開頭算起，1代表從目前位置算起，2代表從檔案末尾算起。和C語言總的fseek（）類似。

seek(offset[,where]) 用來随機存取檔案的任一部分。offset是偏移量，where是可選的位置參數(預設值為0，表示檔案開始位置)。 如果where的值是1，表示目前位置。如果where是2表示檔案結束位置。fileno()傳回一個打開檔案的整型檔案描述編号，有些子產品在進行低層次 I/O操作時會用到。在支援單個檔案超過2GB容量的機器上，seek() 和 tell() 使用長整數. 不過要允許這個特性可能需要重新配置并重新編譯Python解釋器

>>> f=open('/root/test.file')

>>> f.tell()

0L

>>> f.seek(99) 

不知道有為什麼用

99L

>>> f.fileno()

7.f.truncate()和f.readinto(）

這個檔案對象是write的情況下，因為需要修改檔案對象

# wc -l test.file 

119 test.file

>>> f=open('/root/test.file','w',0)

>>> f.truncate(50)

# cat test.file 

沒内容了

f.readinto(buffer ,nbytes)讀取 n 位元組資料至一個 buffer 對象

不會用

六、子產品相關函數

1、__import__()

import 語句調用 __import__() 函數完成它的工作。提供這個函數是為了讓有特殊需要的使用者覆寫它, 實作

自定義的導入算法。

__import__() 的文法是:

__import__(module_name[, globals[, locals[, fromlist]]])

module_name 變量是要導入子產品的名稱, globals 是包含目前全局符号表的名字的字典,

locals 是包含局部符号表的名字的字典, fromlist 是一個使用 from-import 語句所導入符号的

清單。globals , locals , 以及 fromlist 參數都是可選的, 預設分别為 globals() , locals() 和[] 。

調用 import sys 語句可以使用下邊的語句完成:

sys = __import__('sys')

2.globals() 和 locals()

globals() 和 locals() 内建函數分别傳回調用者全局和局部名稱空間的字典。 在一個函數内

部, 局部名稱空間代表在函數執行時候定義的所有名字, locals() 函數傳回的就是包含這些名字的字典。 globals() 會傳回函數可通路的全局名字。

print "__main__'s globals:", globals().keys()

print "__main__'s locals:", locals().keys() foo()

要讓子產品中函數的局部命名空間，可以提升為全局命名空間，可使用global語句【注意是語句】

def testjin():

 global name

 name='jin'

testjin()

print name

這裡要注意，函數testjin()要執行後，函數内testjin()中局部變量name才會提升為全局變量，函數外才能通路

但是一般都不用這種臨時的方式，全局的就在全局定義，局部的就在局部定義

3、reload() 

内建函數可以重新導入一個已經導入的子產品。 它的文法如下:

reload(module)

module 是你想要重新導入的子產品。使用 reload() 的時候有一些标準。 首先子產品必須是全部

導入(不是使用 from-import), 而且它必須被成功導入。另外 reload() 函數的參數必須是子產品自

身而不是包含子產品名的字元串。 也就是說必須類似 reload(sys) 而不是 reload('sys')。

并行周遊函數：zip 和map

>>> L1=[1,2,3,4]

>>> L2=[5,6,7,8]

>>> zip(L1,L2)

[(1, 5), (2, 6), (3, 7), (4, 8)]

>>> for (x,y) in zip(L1,L2):

... print x,y,'--',x+y

當參數長度不同時，zip會以最短序列的長度為準來截斷所得到的元組：

内置map函數，用類似的方式把序列的元素配對起來，但是如果參數長度，不同則會為較短的序列用None補齊。

>>> map(None,S1,S2) 

[('A', 'x'), ('B', 'y'), ('C', 'z'), (None, '1'), (None, '2'), (None, '3')]

map對疊代對象中每一個元素都應用一個函數調用，類似于清單解析，有局限性，因需要函數，而不是任意表達式。

map(str.upper,open('/etc/rc.conf'))

内置range函數傳回連續整數清單，可作為for中的索引。

>>> range(5),range(2,5),range(3,10,2)

([0, 1, 2, 3, 4], [2, 3, 4], [3, 5, 7, 9])

>>> range(5,-5,-1)

[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

用于for循環，步進2的更好for循環可為：

for x in S[::2]:print x

使用zip構造字典

>>> keys=['name','age','class']

>>> vals=['diege',18,2012] 

dict(zip(keys,vals)) 構造字典

>>> dict(zip(keys,vals))

{'age': 18, 'name': 'diege', 'class': 2012}

>>> D5=dict(zip(keys,vals))

enumerate内置函數，同時産生偏移和元素

>>> S='diege'

>>> for (offset,item) in enumerate(S):

... print item,offset

...

d 0

i 1

e 2

g 3

e 4

這個方法有個next方法，每次周遊清單時，會傳回一個(index,value)的元組，而我們能在for中通過元組指派運算将其分解。

>>> E=enumerate(S)

>>> E.next()

(0, 'd')

StopIteration

>>> sorted(open('/etc/rc.conf')) #這個工具排序了，較新的内置函數，采用了疊代協定。應用于任何可疊代的對象上。

>>> sum([3,5,6,9]) #sum調用會計算任何可疊代對象内所有數字的和

any如果可疊代對象中的任何元素或者全部元素為True,内置函數就會傳回True:all全部元素為True才傳回True,有一個元素不為

True，都會傳回flase

>>> any(['diege','','']) 

>>> all(['diege','','ni']) 

>>> all(['diege','a','ni'])

函數

匿名函數：lamdba

lambad 建立了一個之後能夠被調用的函數，它傳回了一個函數而不是将這個函數指派給一個變量名。

1、lambda表達式

lanbda arg1,arg2,...,argN:expression using arguments

apply函數（）

當需要變得更加動态的話，可以通過将一個函數作為一個參數傳遞給apply來調用一個生成的函數，并且也将

傳給那個函數的參數作為一個元組傳遞給apply函數（）

map() 在序列中映射函數

map（函數，傳入函數的序列對象）

使用内置工具map，map函數會對一個序列對象中的每一個元素應用被傳入的函數，并且傳回一個包含了所有函數調用結果的一個清單。

>>> def inc(x):return x+10

>>> L=[1,2,3,4,5]

>>> map(inc,L)

[11, 12, 13, 14, 15]

備注:map函數另外一個用法，把序列的元素配對起來，但是如果參數長度，不同則會為較短的序列用None補齊。

>>> map(None,S1,S2)

>>> L=[1,2,3,4,5] 

map嵌套lambda 

>>> map((lambda x:x+3),L)

[4, 5, 6, 7, 8]

函數式程式設計工具：filter和reduce

函數式程式設計的意思就是對序列應用一些函數的工具。

基于某一測試函數過濾出一些元素-filter

對每對元素都應用函數并運作到最後結果-reduce

>>> range(-5,5)

[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> filter((lambda x:x>0),range(-5,5))

[1, 2, 3, 4]

這個等效于for range:if語句

reduce稍微複雜一點。這裡兩個reduce調用，計算在一個清單中所有元素加起來和以及乘起來的乘積

>>> reduce((lambda x,y:x+y),[1,2,3,4])

10

>>> reduce((lambda x,y:x*y),[1,2,3,4]) 

24

子產品

import: 使用戶端（導入者）以一個整體擷取一個子產品。

reload:在不中止Python程式的情況下，提供了一個重新載入子產品檔案代碼的方法。

from:容許用戶端從一個子產品檔案中湖區特定的變量名。

from語句

from将擷取（複制）子產品特定變量名

from 子產品名 import 需要複制的屬性

from 子產品名 import 需要複制的屬性 as 新的屬性名

*from将一個或多個變量名指派給另一個子產品中同名的對象

*from as将一個或者多個變量名指派給另一個子產品中不同名的對象

getattr(...)

 getattr(object, name[, default]) -> value

>>> getattr(test17,'lessthan')

<function lessthan at 0x28495bc4>

>>> getattr(test17,'name') 

'diege'

sys.modules字典中導出所有已經加載的子產品

>>> sys.modules

>>> sys.modules['test17']