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
True
>>> X is Y
True
>>> id(X)
674748936
>>> id(Y)
674748936
二、數字函數總結
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值的大小來比較的
is 對象身份比較
and,or,not 布爾類型
2）標準內建函數
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引號運算符(``) 可以方便的以字符串的方式獲取對象的
內容、類型、數值屬性等信息。str()函數得到的字符串可讀性好， 而repr()函數得到的字符
串通常可以用來重新獲得該對象, 通常情況下 obj == eval(repr(obj)) 這個等式是成立的
isinstance(obj,type) 判斷對象的類型
(二)序列操作
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
True
>>> L is M
False
查詢一個對象被引用 的次數：在sys模塊中的getrefcount函數返回對象應用的次數。
T2.lstrip() 移除字符串前面空格，返回字符串
T2.rstrip() 移除字符串後面空格，返回字符串
T2.strip() 移除字符串前後面空格，返回字符串 默認空格，可以其他字符 S.strip('"')
如果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
>>> L
[2, 'a']
3、分片賦值（第一個參數是開始分片的起始位置，第二個參數是結束分片的下一個位置）
1)修改序列
>>> name = list('Perl')
>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['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]
>>> num
[1, 2, 5]
4、添加元素 append 和 extend
1)添加一個元素 append
>>> L.append('NI')
>>> L
[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)
>>> a
[1, 2, 3, 4, 5, 6]
5、刪除 pop,del,remove
1)pop 根據位置刪除[填寫序列]
移除列表中的一個元素（默認最後一個元素），並且返回該元素的值
pop(元素位置)，返回刪除的元素
>>> L.pop(1)
'a'
2)、刪除 del語句實現
del 列表[元素位置]
>>> L=[2, 'NI']
>>> del L[1]
>>> L
[2]
3）、移除 [填寫對象]
remove(元素)
>>> L.remove('NI')
>>> L
6、插入
L.insert(位置,'元素')
注意，這個會改變原來元素的位置
>>> L
[2]
>>> L.insert(0,'test')
>>> L
['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進行排序
[html] view plaincopy
>>> x = [4, 6, 2, 3, 5, 1]
>>> y = x[:]
>>> y.sort()
>>> x
[4, 6, 2, 3, 5, 1]
>>> y
[1, 2, 3, 4, 5, 6]
方法二：使用sorted函數(返回一個已排序的副本，不改變原序列)
[html] view plaincopy
>>> x = [4, 6, 2, 3, 5, 1]
>>> y = sorted(x)
>>> y
[1, 2, 3, 4, 5, 6]
>>> x
[4, 6, 2, 3, 5, 1]
關鍵字排序：key
長度(len)排序：###按長度排序
[html] view plaincopy
>>> x = ['bb', 'eeeee', 'a', 'dddd', 'ccc']
>>> x.sort(key = len)
>>> x
8.索引 index
從列表中找出某個值第一個匹配項的索引位置
['a', 'c', 'd', 'c']
>>> L.index('c')
1
9、計數
統計某個元素在列表中出現的次數
>>> L
['a', 'c', 'd', 'c']
>>> L.count('c')
2
10、比較兩個數字的大小
>>> cmp(43,54)
-1
>>> cmp(43,42)
1
>>> cmp(43,43)
0
(五)、列表特殊強大的功能
列表解析
>>> [ 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)、標準類型運算符
>,<,>=,<=,==,!=,<> 對象值得比較
is 對象身份比較
and,or,not 布爾類型
2)、標準內建函數
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引號運算符(``)
isinstance(obj,type) 判斷對象的類型
3)、序列類型操作符
序列操作符 作用
seq[ind] 獲得下標爲ind 的元素
seq[ind1:ind2] 獲得下標從ind1 到ind2 間的元素集合
seq[ind1:ind2:ind3] 以爲ind3爲步進獲得下標從ind1 到ind2 間的元素集合
seq * expr 序列重複expr 次
seq1 + seq2 連接序列seq1 和seq2
obj in seq 判斷obj 元素是否包含在seq 中
obj not in seq 判斷obj 元素是否不包含在seq 中
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')
False
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={}
>>> D.setdefault('name','jin')
'jin'
>>> D
{'name': 'jin'}
>>> D.setdefault('name','test')
'jin'
>>> D
{'name': 'jin'}
2)、求值是設置字典默認值
dict.get(key,default=None) 對字典dict中的存在的鍵key,返回它對應的值value，如果字典中不存在此鍵，則返回default的值(注意，參數default 的默認值爲None)
在Python2.2版本引入in 和not in 後，此方法幾乎已廢棄不用了，但仍提供一個可工作的接口。
>>> D
{'name': 'jin'}
>>> D.get('sex','man') #不存在時返回設置的默認值
'man'
>>> D
{'name': 'jin'}
>>> D.get('name','diege') #存在時返回存在健的值，而不是get設置的默認值
'jin'
>>> D
{'name': 'jin'}
6、特別健值組合
dict.items() 返回一個包含字典中(鍵, 值)對元組的列表
dict.iter() 方法iteritems(), iterkeys(), itervalues()與它們對應的非迭代方法一樣，不同的是它們返回一個迭代子，而不是一個列表。
dict.items() 實例
>>> D.items()
[('name', 'jin'), ('sex', 'man')]
iteritems() 實例
>>> for i in D.iteritems():
... print i
...
('name', 'jin')
('sex', 'man'
'fromkeys',
'get',
iterkeys() 實例
>>> for i in D.iterkeys():
... print i
...
name
sex
itervalues() 實例
>>> for i in D.itervalues():
... print i
...
jin
man
8、創建字典的多種方法
1）
>>> {'name':'diege','age':45}
{'age': 45, 'name': 'diege'}
2）
>>> D={}
>>> D['name']='lily'
>>> D['age']=18
>>> D
{'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))
>>> D
{'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}
>>> D
{'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=open('data.ext','r')
>>> 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) 將字符串 s 寫入文件
f.writelines(l) 將列表 l 中的所有字符串寫入文件
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)
>>> f.close()
# 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
the 1st line
the 2nd line
file.flush()沒有刷到硬盤可能會出一下問題
http://topic.csdn.net/u/20120620/10/69378f85-4386-476c-b0ab-34a1bcd181b1.html
4、關閉文件
讀入文件或寫入文件後一定要關閉文件
f.close() 結束文件
比較好的方法
with open("hello.txt") as f:
for line in f:
print line
這種方式打開後會自動關閉
f = open("hello.txt")
try:
for line in f:
print line
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
False
>>> f.closed #f.closed 表示文件狀態的布爾值: 0 表示文件打開， 1 表示已關閉。
False
>>> f.softspace
0
#f.softspace這是一個布爾值在使用print語句時表示在打印另一個值之前，是否要先打印一個空白符。若用類來模仿文件操作則必須提供這樣一個可寫的屬性，並將其初始化爲0。
6、文件內移動 seek()
f.seek(offset [, where]) 定位到一個新的文件位置
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.close()
>>> f=open('/root/test.file')
>>> f.tell()
0L
>>> f.seek(99)
不知道有爲什麼用
>>> f.tell()
99L
>>> f.fileno()
3
7.f.truncate()和f.readinto(）
f.truncate([size]) 如果文件長於 size 就截短它至 size 大小
這個文件對象是write的情況下，因爲需要修改文件對象
# wc -l test.file
119 test.file
>>> f=open('/root/test.file','w',0)
>>> f.truncate(50)
>>> f.close()
# 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')
>>> E.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> sorted(open('/etc/rc.conf')) #這個工具排序了，較新的內置函數，採用了迭代協議。應用於任何可迭代的對象上。
>>> sum([3,5,6,9]) #sum調用會計算任何可迭代對象內所有數字的和
any如果可迭代對象中的任何元素或者全部元素爲True,內置函數就會返回True:all全部元素爲True才返回True,有一個元素不爲
True，都會返回flase
>>> any(['diege','',''])
True
>>> all(['diege','','ni'])
False
>>> all(['diege','a','ni'])
True
函數
匿名函數：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']
<module 'test17' from '/root/test17.py'>
>>> sys.modules['test17'].name