1另患、getpass
2纽乱、os
3、sys
4昆箕、subprocess
5鸦列、hashlib
6租冠、json
7、pickle
8薯嗤、shutil
9顽爹、time
10、datetime
11骆姐、re
12镜粤、random
13、configparser
14诲锹、traceback
15繁仁、yaml
16、itertools
17归园、logging
1黄虱、getpass模塊詳解
pwd = getpass.getpass("請輸入密碼：") #輸入密碼不可見
yh = getpass.getuser() #顯示當(dāng)前登錄系統(tǒng)用戶名;
2、os模塊
os.getcwd() #獲取當(dāng)前工作目錄庸诱，即當(dāng)前python腳本工作的目錄路徑
os.chdir("dirname") #改變當(dāng)前腳本工作目錄捻浦；相當(dāng)于shell下cd
os.curdir #返回當(dāng)前目錄: ('.')
os.pardir #獲取當(dāng)前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2') #可生成多層遞歸目錄
os.removedirs('dirname1') #若目錄為空，則刪除桥爽，并遞歸到上一級目錄朱灿，如若也為空，則刪除钠四，依此類推
os.mkdir('dirname') #生成單級目錄盗扒；相當(dāng)于shell中mkdir dirname
os.rmdir('dirname') #刪除單級空目錄，若目錄不為空則無法刪除缀去，報錯侣灶；相當(dāng)于shell中rmdir dirname
os.listdir('dirname') #列出指定目錄下的所有文件和子目錄，包括隱藏文件缕碎，并以列表方式打印
os.remove() #刪除一個文件
os.rename("oldname","newname") #重命名文件/目錄
os.stat('path/filename') #獲取文件/目錄信息
os.sep #輸出操作系統(tǒng)特定的路徑分隔符褥影，win下為"\",Linux下為"/"
os.linesep #輸出當(dāng)前平臺使用的行終止符，win下為"\t\n",Linux下為"\n"
os.pathsep #輸出用于分割文件路徑的字符串
os.name #輸出字符串指示當(dāng)前使用平臺咏雌。win->'nt'; Linux->'posix'
os.system("bash command") #運行shell命令凡怎，直接顯示
os.environ #獲取系統(tǒng)環(huán)境變量
os.path.abspath(path) #返回path規(guī)范化的絕對路徑
os.path.split(path) #將path分割成目錄和文件名二元組返回
os.path.dirname(path) #返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path) #返回path最后的文件名赊抖。如何path以／或\結(jié)尾统倒，那么就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path) #如果path存在氛雪，返回True房匆；如果path不存在，返回False
os.path.isabs(path) #如果path是絕對路徑，返回True
os.path.isfile(path) #如果path是一個存在的文件坛缕，返回True。否則返回False
os.path.isdir(path) #如果path是一個存在的目錄捆昏，則返回True赚楚。否則返回False
os.path.join(path1[, path2[, ...]]) #將多個路徑組合后返回，第一個絕對路徑之前的參數(shù)將被忽略
os.path.getatime(path) #返回path所指向的文件或者目錄的最后存取時間
os.path.getmtime(path) #返回path所指向的文件或者目錄的最后修改時間
3骗卜、sys模塊
sys.argv #命令行參數(shù)List宠页，第一個元素是程序本身路徑
sys.exit(n) #退出程序，正常退出時exit(0)
sys.version #獲取Python解釋程序的版本信息
sys.maxint #最大的Int值
sys.path #返回模塊的搜索路徑寇仓，初始化時使用PYTHONPATH環(huán)境變量的值
sys.platform #返回操作系統(tǒng)平臺名稱
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
4举户、subprocess模塊
執(zhí)行系統(tǒng)命令
os.system
commands.* --廢棄，3.x中被移除
result = commands.getoutput('cmd')
以上執(zhí)行shell命令的相關(guān)的模塊和函數(shù)的功能均在 subprocess 模塊中實現(xiàn)遍烦，并提供了更豐富的功能俭嘁。
call
執(zhí)行命令，返回狀態(tài)碼
ret = subprocess.call(["ls", "-l"], shell=False)
ret = subprocess.call("ls -l", shell=True)
shell = True 服猪，允許 shell 命令是字符串形式
check_call
執(zhí)行命令供填，如果執(zhí)行狀態(tài)碼是 0 ，則返回0罢猪，否則拋異常
subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True)
check_output（此下兩條命令在2.6執(zhí)行失敗近她，要是2.7應(yīng)該才可以）
執(zhí)行命令，如果狀態(tài)碼是 0 膳帕，則返回執(zhí)行結(jié)果粘捎，否則拋異常
subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True)
subprocess.Popen(...)
用于執(zhí)行復(fù)雜的系統(tǒng)命令
參數(shù)：
args： #shell命令，可以是字符串或者序列類型（如：list危彩，元組）
bufsize： #指定緩沖攒磨。0 無緩沖,1 行緩沖,其他 緩沖區(qū)大小,負(fù)值 系統(tǒng)緩沖
stdin, stdout, stderr： #分別表示程序的標(biāo)準(zhǔn)輸入、輸出恬砂、錯誤句柄
preexec_fn： #只在Unix平臺下有效咧纠，用于指定一個可執(zhí)行對象（callable object），它將在子進程運行之前被調(diào)用
close_sfs： #在windows平臺下泻骤，如果close_fds被設(shè)置為True漆羔，則新創(chuàng)建的子進程將不會繼承父進程的輸入、輸出狱掂、錯誤管道演痒。所以不能將close_fds設(shè)置為True同時重定向子進程的標(biāo)準(zhǔn)輸入、輸出與錯誤(stdin, stdout, stderr)趋惨。
shell： #同上
cwd： #用于設(shè)置子進程的當(dāng)前目錄
env： #用于指定子進程的環(huán)境變量鸟顺。如果env = None，子進程的環(huán)境變量將從父進程中繼承。
universal_newlines： #不同系統(tǒng)的換行符不同讯嫂，True -> 同意使用 \n
startupinfo與createionflags #只在windows下有效
將被傳遞給底層的CreateProcess()函數(shù)蹦锋，用于設(shè)置子進程的一些屬性，如：主窗口的外觀欧芽，進程的優(yōu)先級等等
import subprocess
ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True)
5莉掂、hashlib模塊
用于加密相關(guān)的操作，代替了md5模塊和sha模塊千扔，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 憎妙，MD5 算法
import hashlib
######## md5
hash = hashlib.md5()
hash.update('admin')
print hash.hexdigest()
######## sha1
hash = hashlib.sha1()
hash.update('admin')
print hash.hexdigest()
######## sha256
hash = hashlib.sha256()
hash.update('admin')
print hash.hexdigest()
######## sha384
hash = hashlib.sha384()
hash.update('admin')
print hash.hexdigest()
######## sha512
hash = hashlib.sha512()
hash.update('admin')
print hash.hexdigest()
以上加密算法雖然依然非常厲害，但時候存在缺陷曲楚，即：通過撞庫可以反解厘唾。所以，有必要對加密算法中添加自定義key再來做加密龙誊。
import hashlib
######## md5
hash = hashlib.md5('898oaFs09f')
hash.update('admin')
print hash.hexdigest()
還不夠吊抚垃？python 還有一個 hmac 模塊，它內(nèi)部對我們創(chuàng)建 key 和 內(nèi)容 再進行處理然后再加密
import hmac
h = hmac.new('wueiqi')
h.update('hellowo')
print h.hexdigest()
6,7载迄、json 和 pickle
用于序列化的兩個模塊
json讯柔，用于字符串 和 python數(shù)據(jù)類型間進行轉(zhuǎn)換
pickle，用于python特有的類型 和 python的數(shù)據(jù)類型間進行轉(zhuǎn)換
Json模塊提供了四個功能：dumps护昧、dump魂迄、loads、load
pickle模塊提供了四個功能：dumps惋耙、dump捣炬、loads、load
pickle
import pickle
data = {'k1' : 123, 'k2' : 'hello'}
p_str = pickle.dumps(data) #序列化
print p_str
loadsed = pickle.loads(p_str) #反序列化
print loadsed
序列化到文件
li = ['wsyht',11,22,'ok','yes']
pickle.dump(li,open('test.txt','w')) #序列化到文件
pickle.load(open('test.txt')) #從文件反序列化出來
json
import json
data = {'k1':123,'k2':'abc'}
str = json.dumps(data)
stt= json.loads(str)
序列化到文件
li = ['wsyht',11,22,'ok','yes']
json.dump(li,open('test.txt','w')) #序列化到文件
json.load(open('test.txt')) #從文件反序化出來
8绽榛、shutil模塊
shutil.make_archive(base_name, format,...)
創(chuàng)建壓縮包并返回文件路徑贱勃，例如：zip接剩、tar
base_name： 壓縮包的文件名江耀，也可以是壓縮包的路徑养盗。只是文件名時，則保存至當(dāng)前目錄届腐，否則保存至指定路徑铁坎，
如：www =>保存至當(dāng)前路徑
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format： 壓縮包種類，“zip”, “tar”, “bztar”犁苏，“gztar”
root_dir： 要壓縮的文件夾路徑（默認(rèn)當(dāng)前目錄）
owner： 用戶硬萍，默認(rèn)當(dāng)前用戶
group： 組，默認(rèn)當(dāng)前組
logger： 用于記錄日志围详，通常是logging.Logger對象
將 /Users/wupeiqi/Downloads/test 下的文件打包放置當(dāng)前程序目錄
import shutil
ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
將 /mnt下的文件打包放置 /tmp目錄
import shutil
ret = shutil.make_archive("/tmp/www", 'gztar', root_dir='/mnt') #2.6用不了朴乖，2.7或許可以
類似于高級API，而且主要強大之處在于其對文件的復(fù)制與刪除操作更是比較支持好。
相關(guān)API介紹
copyfile(src, dst)
從源src復(fù)制到dst中去买羞。當(dāng)然前提是目標(biāo)地址是具備可寫權(quán)限袁勺。拋出的異常信息為
IOException. 如果當(dāng)前的dst已存在的話就會被覆蓋掉。
copyfile( src, dst) 從源src復(fù)制到dst中去畜普。當(dāng)然前提是目標(biāo)地址是具備可寫權(quán)限魁兼。拋出的異常信息為IOException. 如果當(dāng)前的dst已存在的話就會被覆蓋掉
copymode( src, dst) 只是會復(fù)制其權(quán)限其他的東西是不會被復(fù)制的
copystat( src, dst) 復(fù)制權(quán)限、最后訪問時間漠嵌、最后修改時間
copy( src, dst) 復(fù)制一個文件到一個文件或一個目錄
copy2( src, dst) 在copy上的基礎(chǔ)上再復(fù)制文件最后訪問時間與修改時間也復(fù)制過來了，類似于cp –p的東西
copy2( src, dst) 如果兩個位置的文件系統(tǒng)是一樣的話相當(dāng)于是rename操作盖呼，只是改名儒鹿；如果是不在相同的文件系統(tǒng)的話就是做move操作
copytree(olddir,newdir,True/Flase) 把olddir拷貝一份newdir，如果第3個參數(shù)是True几晤，則復(fù)制目錄時將保持文件夾下的符號連接约炎，如果第3個參數(shù)是False，則將在復(fù)制的目錄下生成物理副本來替代符號連接
shutil.rmtree("te") 刪除一個目錄
import shutil
shutil.copyfile('f:/temp.txt', 'f:/os.txt') #復(fù)制文件
shutil.copytree('f:/temp', 'f:/os') #復(fù)制目錄
######## zip的用法
shutil 對壓縮包的處理是調(diào)用 ZipFile 和 TarFile 兩個模塊來進行的蟹瘾，詳細(xì)：
import zipfile
壓縮
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log') #壓縮包寫入a.log
z.write('data.data') #寫入data文件
z.close()
解壓
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()
9圾浅、time模塊
三種表示主式：
1、時間戳 1970年1月1日后的秒
2憾朴、元組包含了：年狸捕、日、星期等...time.struct_time
3众雷、格式化的字符串 2014-11-11 11:11 print time.time()
時間戳形式存在
print time.time()
print time.mktime(time.localtime()) #print (time.localtime())此為元組形式灸拍，這一整句意思是把元組形式轉(zhuǎn)化成時間戳形式
元組形式存在
print time.gmtime() #可加時間戳參數(shù)
print time.localtime() #可加時間戳參數(shù)
print time.strptime('2014-11-11','%Y-%m-%d') #字符串形式轉(zhuǎn)換成元組形式
字符串形式存在
print time.strftime('%Y-%m-%d') #默認(rèn)當(dāng)前時間，必須記住砾省，工作中用得最多
print time.strftime('%Y-%m-%d',time.localtime()) #默認(rèn)當(dāng)前時間
print time.asctime()
print time.asctime(time.localtime())
print time.ctime(time.time())
時間的三種表示方式演示
import time
print time.time()
1469014348.5 #秒鸡岗，時間戳的方式
print time.gmtime()
time.struct_time(tm_year=2016, tm_mon=7, tm_mday=20, tm_hour=11, tm_min=25, tm_sec=53, tm_wday=2, tm_yday=202, tm_isdst=0)
print time.strftime('%Y-%m-%d %H:%M:%S')
2016-07-20 19:36:16
10、datetime模塊
import datetime
'''
datetime.date：表示日期的類编兄。常用的屬性有year, month, day
datetime.time：表示時間的類轩性。常用的屬性有hour, minute, second, microsecond
datetime.datetime：表示日期時間
datetime.timedelta：表示時間間隔，即兩個時間點之間的長度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
import datetime
print datetime.datetime.now()
print datetime.datetime.now() - datetime.timedelta(days=5)
11狠鸳、re模塊
compile
match search findall
group groups
正則表達式常用格式：
字符：\d \w \t .
次數(shù)：* + ? {m} {m,n}
示例：
!#/usr/bin/env python
coding:utf-8
import re
result1 = re.match('\d+', '1afsfweasfcxvsfd123') #在你給的字符串起始位置去匹配,\d從數(shù)字開始找揣苏，+表示一個到多個
if result1: #當(dāng)result1等于True的時候，就是匹配碰煌，如果匹配就輸出里面的內(nèi)容
print result1.group() #用group方法把他匹配的內(nèi)容輸出出來
else:
print 'nothing'
result2 = re.search('\d+', 'alsfj3af') #在整個內(nèi)容里面去匹配舒岸，\d從數(shù)字開始找，+表示一個到多個
if result2:
print result2.group() #用group方法把他匹配的內(nèi)容輸出出來
result3 = re.findall('\d+', 'asfaf11sf22lj33') #只要匹配全都拿出來
print result3
com = re.compile('\d+')
print com.findall('asfaf11sf22lj33')
result5 = re.search('(\d+)\w*(\d+)','aasflsjfa12aaljsf22lj13bb')
print result5.group() #所有匹配內(nèi)容輸出
print result5.groups() #只把括號\d芦圾，也就是組里面的內(nèi)容輸出
result6 = re.search('a{3,5}','aaaaaa') #匹配3到5次的aaaaa輸出出來
print result6.group()
總結(jié)：
match：只在第一個字符串開始找蛾派，如果沒有匹配，則不再繼續(xù)找，如果第一個字符串中有洪乍，則只輸出第一個
searh: 在所有內(nèi)容里找眯杏，直到找到為止，但只輸出找到的第一個
findall：把所有找到的匹配的內(nèi)容壳澳，都通過列表的形式打印出來
compile: 編譯之后再去匹配岂贩，這樣可以加快匹配的速度
group: 把他匹配的內(nèi)容輸出出來
groups：分組
匹配的字符：
\d：表示數(shù)字的意思
\w: 代表下劃線，字母巷波，數(shù)字
\t：制表符萎津，除了回車以外的所有字符
匹配的次數(shù)：
- 大于等于0，0到多個
- 大于等于1抹镊，1個到多個
? 0或1
{m} 次數(shù)锉屈，如a{6}，出現(xiàn)6次a的進行匹配
{m,n} 如a{3,7} 出現(xiàn)3到7次的就進行匹配
例子1：
法1
ip = '12.23.84.dsfa.23s.3234lsjfw+23sfaf192.168.32.43_w342d@#9436'
import re
re.findall('[0-9]{1,3}',ip)
['12', '23', '84', '23', '323', '4', '23', '192', '168', '32', '43', '342', '943', '6']
re.findall('[0-9]{1,3}.[0-9]{1,3}',ip)
['12.23', '192.168', '32.43']
re.findall('[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}',ip)
['12.23.84', '192.168.32']
re.findall('[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}',ip)
['192.168.32.43']
法2:
re.findall('(\d+)',ip)
['12', '23', '84', '23', '3234', '23', '192', '168', '32', '43', '342', '9436']
re.findall('(.+\d+){1,3}',ip)
['.84', '.23', '.3234', '.43']
re.findall('(?:.+\d+){1,3}',ip) #?:表示匹配括號的那一組數(shù)據(jù)垮耳，必須連著
['.23.84', '.23', '.3234', '.168.32.43']
re.findall('[0-9]{1,3}(?:.+\d+){3}',ip)
['192.168.32.43']
法3：
re.findall('(?:\d+.+){3}\d{1,3}',ip)
['192.168.32.43']
法4：
re.findall('(?:\d{1,3}.){3}\d{1,3}',ip)
['192.168.32.43']
12颈渊、random模塊
import random
print random.random()
print random.randint(1,2)
print random.randrange(1,10)
隨機驗證碼實例：
import random
checkcode = ''
for i in range(4):
current = random.randrange(0,4)
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print checkcode
13、ConfigParser模塊
用于對特定的配置進行操作终佛，當(dāng)前模塊的名稱在 python 3.x 版本中變更為 configparser俊嗽。
1.讀取配置文件
-read(filename) 直接讀取ini文件內(nèi)容
-sections() 得到所有的section，并以列表的形式返回
-options(section) 得到該section的所有option
-items(section) 得到該section的所有鍵值對
-get(section,option) 得到section中option的值铃彰，返回為string類型
-getint(section,option) 得到section中option的值绍豁，返回為int類型
2.寫入配置文件
-add_section(section) 添加一個新的section
-set( section, option, value) 對section中的option進行設(shè)置
需要調(diào)用write將內(nèi)容寫入配置文件。
[root@test1 mnt]# cat data.txt
[sec_a]
a_key1 = 20
a_key2 = 10
[sec_b]
b_key1 = 121
b_key2 = b_value2
b_key3 = $r
b_key4 = 127.0.0.1
import ConfigParser
cf = ConfigParser.ConfigParser()
cf.read("data.txt")
['data.txt']
secs = cf.sections() #獲得所有區(qū)域
print 'sections:', secs
sections: ['sec_b', 'sec_a']
opts = cf.options("sec_a")
print 'options:', opts
options: ['a_key1', 'a_key2']
for sn in secs:
... print cf.options(sn) #打印出每個區(qū)域的所有屬性
...
['b_key4', 'b_key1', 'b_key2', 'b_key3']
['a_key1', 'a_key2']
str_val = cf.get("sec_a", "a_key1")
int_val = cf.getint("sec_a", "a_key2")
print "value for sec_a's a_key1:", str_val
value for sec_a's a_key1: 20
print "value for sec_a's a_key2:", int_val
value for sec_a's a_key2: 10
cf.set("sec_b", "b_key3", "new-$r")
cf.set("sec_b", "b_newkey", "new-value")
cf.add_section('a_new_section')
cf.set('a_new_section', 'new_key', 'new_value')
cf.write(open("data.txt", "w"))
cf.has_section('a_new_section') #判斷存不存在[sec_a]
True
cf.remove_section('sec_a') #刪除[sec_a]
True
cf.has_section('a_section') #判斷存不存在[sec_a]
False
cf.write(open("data.txt", "w"))
14牙捉、traceback模塊
[root@test1 mnt]# cat test.py
!/usr/bin/env python
coding:utf-8
import traceback
try:
1/0
except Exception,e:
#print e
traceback.print_exc(file=open('tb.txt','w+'))
else:
print 'success'
15妹田、yaml模塊的使用
yaml在python上的具體實現(xiàn)：PyYaml
將yaml寫成配置腳本test.yaml ,以下介紹如何讀寫yaml配置。
使用python的yaml庫PyYAML鹃共。http://pyyaml.org/
安裝到python lib下后就可以正常使用了鬼佣。
加載yaml
import yaml
f = open('test.yaml') #讀取文件
x = yaml.load(f) #導(dǎo)入
print x
f.close()
import yaml
f = open('d:/newtree.yaml', "w")
yaml.dump(dataMap, f)
f.close()
16、itertools模塊的使用
[root@test1 mnt]# cat test.py
######## count(1)
import itertools
natuals = itertools.count(1) #count創(chuàng)建無限個迭代器
for n in natuals:
print n
######## cycle()
cycle()會把傳入的一個序列無限重復(fù)下去：
import itertools
cs = itertools.cycle('ABC') # 注意字符串也是序列的一種
for c in cs:
... print c
######## repeat()
repeat()負(fù)責(zé)把一個元素?zé)o限重復(fù)下去霜浴，不過如果提供第二個參數(shù)就可以限定重復(fù)次數(shù)：
ns = itertools.repeat('A', 10)
for n in ns:
... print n
...
打印10次'A'
######## takewhile()
natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
for n in ns:
... print n
...
打印出1到10
######## chain()
for c in itertools.chain('ABC', 'XYZ'):
print c
迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'
######## groupby()
groupby()把迭代器中相鄰的重復(fù)元素挑出來放在一起：
for key, group in itertools.groupby('AAABBBCCAAA'):
... print key, list(group) # 為什么這里要用list()函數(shù)呢晶衷？
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
######## groupby()
實際上挑選規(guī)則是通過函數(shù)完成的，只要作用于函數(shù)的兩個元素返回的值相等阴孟，這兩個元素就被認(rèn)為是在一組的晌纫，而函數(shù)返回值作為組的key。如果我們要忽略大小寫分組永丝，就可以讓元素'A'和'a'都返回相同的key：
for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
... print key, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
######## imap()
for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
... print x
itertools
閱讀: 5044
Python的內(nèi)建模塊itertools提供了非常有用的用于操作迭代對象的函數(shù)锹漱。
首先，我們看看itertools提供的幾個“無限”迭代器：
import itertools
natuals = itertools.count(1)
for n in natuals:
... print n
...
1
2
3
...
因為count()會創(chuàng)建一個無限的迭代器慕嚷，所以上述代碼會打印出自然數(shù)序列哥牍，根本停不下來毕泌，只能按Ctrl+C退出。
cycle()會把傳入的一個序列無限重復(fù)下去：
import itertools
cs = itertools.cycle('ABC') # 注意字符串也是序列的一種
for c in cs:
... print c
...
'A'
'B'
'C'
'A'
'B'
'C'
...
同樣停不下來嗅辣。
repeat()負(fù)責(zé)把一個元素?zé)o限重復(fù)下去撼泛，不過如果提供第二個參數(shù)就可以限定重復(fù)次數(shù)：
ns = itertools.repeat('A', 10)
for n in ns:
... print n
...
打印10次'A'
無限序列只有在for迭代時才會無限地迭代下去，如果只是創(chuàng)建了一個迭代對象澡谭，它不會事先把無限個元素生成出來愿题，事實上也不可能在內(nèi)存中創(chuàng)建無限多個元素。
無限序列雖然可以無限迭代下去蛙奖，但是通常我們會通過takewhile()等函數(shù)根據(jù)條件判斷來截取出一個有限的序列：
natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
for n in ns:
... print n
...
打印出1到10
itertools提供的幾個迭代器操作函數(shù)更加有用：
chain()
chain()可以把一組迭代對象串聯(lián)起來潘酗，形成一個更大的迭代器：
for c in itertools.chain('ABC', 'XYZ'):
print c
迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()
groupby()把迭代器中相鄰的重復(fù)元素挑出來放在一起：
for key, group in itertools.groupby('AAABBBCCAAA'):
... print key, list(group) # 為什么這里要用list()函數(shù)呢？
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
實際上挑選規(guī)則是通過函數(shù)完成的雁仲，只要作用于函數(shù)的兩個元素返回的值相等崎脉，這兩個元素就被認(rèn)為是在一組的，而函數(shù)返回值作為組的key伯顶。如果我們要忽略大小寫分組，就可以讓元素'A'和'a'都返回相同的key：
for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
... print key, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
imap()
imap()和map()的區(qū)別在于骆膝，imap()可以作用于無窮序列祭衩，并且，如果兩個序列的長度不一致阅签，以短的那個為準(zhǔn)掐暮。
for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
... print x
注意imap()返回一個迭代對象，而map()返回list政钟。當(dāng)你調(diào)用map()時路克，已經(jīng)計算完畢：
r = map(lambda x: x*x, [1, 2, 3])
r # r已經(jīng)計算出來了
[1, 4, 9]
當(dāng)你調(diào)用imap()時，并沒有進行任何計算：
r = itertools.imap(lambda x: x*x, [1, 2, 3])
r
<itertools.imap object at 0x103d3ff90>
r只是一個迭代對象
itertools
閱讀: 5044
Python的內(nèi)建模塊itertools提供了非常有用的用于操作迭代對象的函數(shù)养交。
首先精算，我們看看itertools提供的幾個“無限”迭代器：
import itertools
natuals = itertools.count(1)
for n in natuals:
... print n
...
1
2
3
...
因為count()會創(chuàng)建一個無限的迭代器，所以上述代碼會打印出自然數(shù)序列碎连，根本停不下來灰羽，只能按Ctrl+C退出。
cycle()會把傳入的一個序列無限重復(fù)下去：
import itertools
cs = itertools.cycle('ABC') # 注意字符串也是序列的一種
for c in cs:
... print c
...
'A'
'B'
'C'
'A'
'B'
'C'
...
同樣停不下來鱼辙。
repeat()負(fù)責(zé)把一個元素?zé)o限重復(fù)下去廉嚼，不過如果提供第二個參數(shù)就可以限定重復(fù)次數(shù)：
ns = itertools.repeat('A', 10)
for n in ns:
... print n
...
打印10次'A'
無限序列只有在for迭代時才會無限地迭代下去，如果只是創(chuàng)建了一個迭代對象倒戏，它不會事先把無限個元素生成出來怠噪，事實上也不可能在內(nèi)存中創(chuàng)建無限多個元素。
無限序列雖然可以無限迭代下去杜跷，但是通常我們會通過takewhile()等函數(shù)根據(jù)條件判斷來截取出一個有限的序列：
natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
for n in ns:
... print n
...
打印出1到10
itertools提供的幾個迭代器操作函數(shù)更加有用：
chain()
chain()可以把一組迭代對象串聯(lián)起來傍念，形成一個更大的迭代器：
for c in itertools.chain('ABC', 'XYZ'):
print c
迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()
groupby()把迭代器中相鄰的重復(fù)元素挑出來放在一起：
for key, group in itertools.groupby('AAABBBCCAAA'):
... print key, list(group) # 為什么這里要用list()函數(shù)呢矫夷？
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
實際上挑選規(guī)則是通過函數(shù)完成的，只要作用于函數(shù)的兩個元素返回的值相等捂寿，這兩個元素就被認(rèn)為是在一組的口四，而函數(shù)返回值作為組的key。如果我們要忽略大小寫分組秦陋，就可以讓元素'A'和'a'都返回相同的key：
for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
... print key, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
imap()
imap()和map()的區(qū)別在于蔓彩，imap()可以作用于無窮序列，并且驳概，如果兩個序列的長度不一致赤嚼，以短的那個為準(zhǔn)。
for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
... print x
...
10
40
90
注意imap()返回一個迭代對象顺又，而map()返回list更卒。當(dāng)你調(diào)用map()時，已經(jīng)計算完畢：
r = map(lambda x: x*x, [1, 2, 3])
r # r已經(jīng)計算出來了
[1, 4, 9]
當(dāng)你調(diào)用imap()時稚照，并沒有進行任何計算：
r = itertools.imap(lambda x: x*x, [1, 2, 3])
r
<itertools.imap object at 0x103d3ff90>
r只是一個迭代對象
必須用for循環(huán)對r進行迭代蹂空，才會在每次循環(huán)過程中計算出下一個元素：
for x in r:
... print x
...
1
4
9
這說明imap()實現(xiàn)了“惰性計算”，也就是在需要獲得結(jié)果的時候才計算果录。類似imap()這樣能夠?qū)崿F(xiàn)惰性計算的函數(shù)就可以處理無限序列：
r = itertools.imap(lambda x: x*x, itertools.count(1))
for n in itertools.takewhile(lambda x: x<100, r):
... print n
17上枕、logging模塊
用于便捷記錄日志且線程安全的模塊
import logging
logging.basicConfig(filename='log.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=5)
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')
對于等級：
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
