Day05 - Python 常用模块
1. 模塊簡介
模塊就是一個保存了 Python 代碼的文件。模塊能定義函數，類和變量。模塊里也能包含可執行的代碼。
模塊也是 Python 對象，具有隨機的名字屬性用來綁定或引用。
下例是個簡單的模塊support.py
1 def print_func( par ): 2 print("Hello : ", par) 3 return1）import 語句
想使用 Python 源文件，只需在另一個源文件里執行 import 語句，語法如下：
import module1[, module2[,... moduleN]當解釋器遇到 import 語句，如果模塊在當前的搜索路徑就會被導入。
搜索路徑是一個解釋器會先進行搜索的所有目錄的列表。如想要導入模塊 support.py ，需要把命令放在腳本的頂端：
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 # 導入模塊 5 import support 6 7 # 現在可以調用模塊里包含的函數了 8 support.print_func("Zara")輸出結果：
1 Hello : Zara一個模塊只會被導入一次，不管你執行了多少次 import ，這樣可以防止導入模塊被一遍又一遍地執行。
2）from … import 語句
Python 的 from 語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法如下：
from modname import name1[, name2[, ... nameN]]例如，要導入模塊 fib 的 fibonacci 函數，使用如下語句：
from fib import fibonacci這個聲明不會把整個 fib 模塊導入到當前的命名空間中，它只會將 fib 里的 fibonacci 單個引入到執行這個聲明的模塊的全局符號表。
3）from … import * 語句
把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明：
from modname import *這提供了一個簡單的方法來導入一個模塊中的所有項目，然而這種聲明不該被過多地使用。
4）定位模塊
當你導入一個模塊，Python 解析器對模塊位置的搜索順序是：
- 當前目錄
- 如果不在當前目錄，Python 則搜索在 shell 變量 PYTHONPATH 下的每個目錄
- 如果都找不到，Python 會察看默認路徑。UNIX 下，默認路徑一般為 /usr/local/lib/python/ 。
模塊搜索路徑存儲在 system 模塊的 sys.path 變量中。變量里包含當前目錄，PYTHONPATH 和由安裝過程決定的默認目錄。
5) PYTHONPATH變量
作為環境變量，PYTHONPATH 由裝在一個列表里的許多目錄組成。PYTHONPATH 的語法和 shel l 變量的 PATH 一樣。
在Windows系統，典型的PYTHONPATH如下：
1 >>> import sys 2 >>> sys.path 3 ['', 'C:\\Python35\\Lib\\idlelib', 'C:\\Python35\\python35.zip', 'C:\\Python35\\DLLs', 'C:\\Python35\\lib', 'C:\\Python35', 'C:\\Python35\\lib\\site-packages']在UNIX系統，典型的PYTHONPATH如下：
1 >>> import sys 2 >>> sys.path 3 ['', '/usr/local/python35/lib/python35.zip', '/usr/local/python35/lib/python3.5', '/usr/local/python35/lib/python3.5/plat-linux', '/usr/local/python35/lib/python3.5/lib-dynload', '/usr/local/python35/lib/python3.5/site-packages']6) 命名空間和作用域
變量是擁有匹配對象的名字（標識符）。命名空間是一個包含了變量名稱們（鍵）和它們各自相應的對象們（值）的字典。
一個 Python 表達式可以訪問局部命名空間和全局命名空間里的變量。
如果一個局部變量和一個全局變量重名，則局部變量會覆蓋全局變量。
每個函數都有自己的命名空間。類的方法的作用域規則和通常函數的一樣。
Python 會智能地猜測一個變量是局部的還是全局的，它假設任何在函數內賦值的變量都是局部的。
因此，如果要給全局變量在一個函數里賦值，必須使用 global ?語句。
global VarName 的表達式會告訴 Python ， VarName 是一個全局變量，這樣 Python 就不會在局部命名空間里尋找這個變量了。
例如，我們在全局命名空間里定義一個變量 money ，我們再在函數內給變量 money 賦值，然后 Python 會假定 money 是一個局部變量。然而，我們并沒有在訪問前聲明一個局部變量 money ，結果就是會出現一個 UnboundLocalError 的錯誤。取消 global 語句的注釋就能解決這個問題。
1 >>> money = 2000 2 >>> def add_money(): 3 # 想改正代碼就取消以下注釋 4 # global money 5 money += 1 6 7 8 >>> print(money) 9 2000 10 >>> add_money() 11 Traceback (most recent call last): 12 File "<pyshell#7>", line 1, in <module> 13 add_money() 14 File "<pyshell#5>", line 4, in add_money 15 money += 1 16 UnboundLocalError: local variable 'money' referenced before assignment 17 >>> print(money)取消注釋：
1 >>> money = 2000 2 >>> def add_money(): 3 global money 4 money += 1 5 6 7 >>> print(money) 8 2000 9 >>> add_money() 10 >>> print(money) 11 20017）Python 中的包
包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。
考慮一個在 Phone 目錄下的 pots.py 文件。這個文件有如下源代碼：
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 def Pots(): 5 print("I'm Pots Phone")同樣地，我們有另外兩個保存了不同函數的文件：
- Phone/Isdn.py 含有函數 Isdn()
- Phone/G3.py 含有函數 G3()
現在，在 Phone 目錄下創建file __init__.py：
- Phone/__init__.py
當你導入 Phone 時，為了能夠使用所有函數，你需要在 __init__.py 里使用顯式的導入語句，如下：
from Pots import Pots from Isdn import Isdn from G3 import G3當你把這些代碼添加到 __init__.py 之后，導入Phone包的時候這些類就全都是可用的了。
1 #!/usr/bin/python 2 # -*- coding: UTF-8 -*- 3 4 # 導入 Phone 包 5 import Phone 6 7 Phone.Pots() 8 Phone.Isdn() 9 Phone.G3()輸出結果:
1 I'm Pots Phone 2 I'm 3G Phone 3 I'm ISDN Phone如上，為了舉例，我們只在每個文件里放置了一個函數，但其實你可以放置許多函數。
也可以在這些文件里定義Python的類，然后為這些類建一個包。
8) dir() 函數
dir() 函數一個排好序的字符串列表，內容是一個模塊里定義過的名字。
返回的列表容納了在一個模塊里定義的所有模塊、變量和函數。
如下一個簡單的實例：
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 # 導入內置 math 模塊 5 import math 6 7 dir(math)以上實例輸出結果：
1 ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']在這里，特殊字符串變量 __name__ 指向模塊的名字，__file__ 指向該模塊的導入文件名。
9) globals() 和 locals() 函數
根據調用地方的不同，globals() 和 locals() 函數可被用來返回全局和局部命名空間里的名字。
如果在函數內部調用 locals() ，返回的是所有能在該函數里訪問的命名。
1 >>> locals() 2 {'__spec__': None, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, 'math': <module 'math' (built-in)>, '__package__': None}如果在函數內部調用 globals()，返回的是所有在該函數里能訪問的全局名字。
1 >>> globals() 2 {'__spec__': None, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, 'math': <module 'math' (built-in)>, '__package__': None}兩個函數的返回類型都是字典，所以名字能用 keys() 函數獲取。
10) reload() 函數
當一個模塊被導入到一個腳本，模塊頂層部分的代碼只會被執行一次。
因此，如果你想重新執行模塊里頂層部分的代碼，可以用 reload() 函數。
該函數會重新導入之前導入過的模塊。語法如下：
reload(module_name)在這里，module_name 要直接放模塊的名字，而不是一個字符串形式。比如想重載 hello 模塊，如下：
reload(hello)2. 常用模塊
1) time & calendar?& datetime
Python?日期和時間
Python 程序能用很多方式處理日期和時間，轉換日期格式是一個常見的功能。
Python 提供了一個 time 和 calendar 模塊可以用于格式化日期和時間。
時間間隔是以秒為單位的浮點小數。
每個時間戳都以自從1970年1月1日午夜（歷元）經過了多長時間來表示。
Python 的 time 模塊下有很多函數可以轉換常見日期格式。如函數time.time()用于獲取當前時間戳, 如下實例:
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 import time # 引入time模塊 5 6 ticks = time.time() 7 print("當前時間戳為:", ticks)輸出結果：
1 當前時間戳為: 1479129524.694309時間戳單位最適于做日期運算。但是1970年之前的日期就無法以此表示了。太遙遠的日期也不行，UNIX和Windows只支持到2038年。
時間元組
很多Python函數用一個元組裝起來的9組數字處理時間:
| 0 | 4位數年 | 2008 |
| 1 | 月 | 1 到 12 |
| 2 | 日 | 1到31 |
| 3 | 小時 | 0到23 |
| 4 | 分鐘 | 0到59 |
| 5 | 秒 | 0到61 (60或61 是閏秒) |
| 6 | 一周的第幾日 | 0到6 (0是周一) |
| 7 | 一年的第幾日 | 1到366 (儒略歷) |
| 8 | 夏令時 | -1, 0, 1, -1是決定是否為夏令時的旗幟 |
上述也就是struct_time元組。這種結構具有如下屬性：
| 0 | tm_year | 2008 |
| 1 | tm_mon | 1 到 12 |
| 2 | tm_mday | 1 到 31 |
| 3 | tm_hour | 0 到 23 |
| 4 | tm_min | 0 到 59 |
| 5 | tm_sec | 0 到 61 (60或61 是閏秒) |
| 6 | tm_wday | 0到6 (0是周一) |
| 7 | tm_yday | 1 到 366(儒略歷) |
| 8 | tm_isdst | -1, 0, 1, -1是決定是否為夏令時的旗幟 |
獲取當前時間
從返回浮點數的時間輟方式向時間元組轉換，只要將浮點數傳遞給如localtime之類的函數。
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 import time 5 6 localtime = time.localtime(time.time()) 7 print("本地時間為 :", localtime)輸出結果：
1 本地時間為 : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=21, tm_min=21, tm_sec=2, tm_wday=0, tm_yday=319, tm_isdst=0)獲取格式化的時間
可以根據需求選取各種格式的時間，但是最簡單的獲取可讀時間模式的函數是asctime():
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 import time 5 6 localtime = time.asctime(time.localtime(time.time())) 7 print("本地時間為 :", localtime)輸出結果：
1 本地時間為 : Mon Nov 14 21:24:39 2016格式化日期
可以使用 time 模塊的 strftime 方法來格式化日期
time.strftime(format[, t])1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 import time 5 6 # 格式化成2016-03-20 11:45:39形式 7 print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) 8 9 # 格式化成Sat Mar 28 22:24:24 2016形式 10 print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())) 11 12 # 將格式字符串轉換為時間戳 13 a = "Mon Nov 14 21:31:45 2016" 14 print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))
輸出結果：
2016-11-14 21:32:21 Mon Nov 14 21:32:21 2016 1479130305.0python中時間日期格式化符號：
- %y 兩位數的年份表示（00-99）
- %Y 四位數的年份表示（000-9999）
- %m 月份（01-12）
- %d 月內中的一天（0-31）
- %H 24小時制小時數（0-23）
- %I 12小時制小時數（01-12）
- %M 分鐘數（00=59）
- %S 秒（00-59）
- %a 本地簡化星期名稱
- %A 本地完整星期名稱
- %b 本地簡化的月份名稱
- %B 本地完整的月份名稱
- %c 本地相應的日期表示和時間表示
- %j 年內的一天（001-366）
- %p 本地A.M.或P.M.的等價符
- %U 一年中的星期數（00-53）星期天為星期的開始
- %w 星期（0-6），星期天為星期的開始
- %W 一年中的星期數（00-53）星期一為星期的開始
- %x 本地相應的日期表示
- %X 本地相應的時間表示
- %Z 當前時區的名稱
- %% %號本身
獲取某月日歷
Calendar模塊有很廣泛的方法用來處理年歷和月歷，例如打印某月的月歷：
1 #!/usr/bin/env python 2 # -*- coding: UTF-8 -*- 3 4 import calendar 5 6 cal = calendar.month(2016, 11) 7 print("以下輸出2016年11月份的日歷:") 8 print(cal)輸出結果：
1 以下輸出2016年11月份的日歷: 2 November 2016 3 Mo Tu We Th Fr Sa Su 4 1 2 3 4 5 6 5 7 8 9 10 11 12 13 6 14 15 16 17 18 19 20 7 21 22 23 24 25 26 27 8 28 29 30time 模塊
time 模塊包含以下內置函數
- time.altzone?返回格林威治西部的夏令時地區的偏移秒數（與UTC的時間差）。如果該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啟用地區才能使用
- time.asctime([tupletime])?接受時間元組并返回一個可讀的形式為?'Mon Nov 14 21:45:06 2016'?的24個字符的字符串
- time.clock()?用以浮點數計算的秒數返回當前的CPU時間。用來衡量不同程序的耗時，比time.time()更有用
- time.ctime([secs]) 作用相當于asctime(localtime(secs))，未給參數相當于asctime()
- time.gmtime([secs]) 接收時間輟（1970紀元后經過的浮點秒數）并返回格林威治天文時間下的時間元組t。注：t.tm_isdst 始終為0
- time.localtime([secs]) 接收時間輟（1970紀元后經過的浮點秒數）并返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決于當地當時是不是夏令時）
- time.mktime(tupletime) 接受時間元組并返回時間輟（1970紀元后經過的浮點秒數）
- time.sleep(secs) 推遲調用線程的運行，secs指秒數
- time.strftime(fmt[,tupletime]) 接收以時間元組，并返回以可讀字符串表示的當地時間，格式由fmt決定
- time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根據fmt的格式把一個時間字符串解析為時間元組
- time.time( ) 返回當前時間的時間戳（1970紀元后經過的浮點秒數）
時間轉換
日歷（Calendar）模塊
此模塊的函數都是日歷相關的，例如打印某月的字符月歷。
星期一是默認的每周第一天，星期天是默認的最后一天。
更改設置需調用 calendar.setfirstweekday() 函數。
模塊包含了以下內置函數：
- calendar.calendar(year,w=2,l=1,c=6) 返回一個多行字符串格式的year年年歷，3個月一行，間隔距離為c，每日寬度間隔為w字符，每行長度為21* W+18+2* C，l是每星期行數
輸出結果：
1 2016 2 3 January February March 4 Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su 5 1 2 3 1 2 3 4 5 6 7 1 2 3 4 5 6 6 4 5 6 7 8 9 10 8 9 10 11 12 13 14 7 8 9 10 11 12 13 7 11 12 13 14 15 16 17 15 16 17 18 19 20 21 14 15 16 17 18 19 20 8 18 19 20 21 22 23 24 22 23 24 25 26 27 28 21 22 23 24 25 26 27 9 25 26 27 28 29 30 31 29 28 29 30 31 10 11 April May June 12 Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su 13 1 2 3 1 1 2 3 4 5 14 4 5 6 7 8 9 10 2 3 4 5 6 7 8 6 7 8 9 10 11 12 15 11 12 13 14 15 16 17 9 10 11 12 13 14 15 13 14 15 16 17 18 19 16 18 19 20 21 22 23 24 16 17 18 19 20 21 22 20 21 22 23 24 25 26 17 25 26 27 28 29 30 23 24 25 26 27 28 29 27 28 29 30 18 30 31 19 20 July August September 21 Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su 22 1 2 3 1 2 3 4 5 6 7 1 2 3 4 23 4 5 6 7 8 9 10 8 9 10 11 12 13 14 5 6 7 8 9 10 11 24 11 12 13 14 15 16 17 15 16 17 18 19 20 21 12 13 14 15 16 17 18 25 18 19 20 21 22 23 24 22 23 24 25 26 27 28 19 20 21 22 23 24 25 26 25 26 27 28 29 30 31 29 30 31 26 27 28 29 30 27 28 October November December 29 Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su 30 1 2 1 2 3 4 5 6 1 2 3 4 31 3 4 5 6 7 8 9 7 8 9 10 11 12 13 5 6 7 8 9 10 11 32 10 11 12 13 14 15 16 14 15 16 17 18 19 20 12 13 14 15 16 17 18 33 17 18 19 20 21 22 23 21 22 23 24 25 26 27 19 20 21 22 23 24 25 34 24 25 26 27 28 29 30 28 29 30 26 27 28 29 30 31 35 31- calendar.firstweekday() 返回當前每周起始日期的設置。默認情況下，首次載入 calendar 模塊時返回0，即星期一。
- calendar.isleap(year) 是閏年返回True，否則為false。
- calendar.leapdays(y1,y2) 返回在Y1，Y2兩年之間的閏年總數。
- calendar.month(year,month,w=2,l=1) 返回一個多行字符串格式的 year 年 month 月日歷，兩行標題，一周一行，每日寬度間隔為 w 字符，每行的長度為7* w+6，l是每星期的行數
輸出結果：
1 November 2016 2 Mo Tu We Th Fr Sa Su 3 1 2 3 4 5 6 4 7 8 9 10 11 12 13 5 14 15 16 17 18 19 20 6 21 22 23 24 25 26 27 7 28 29 30- calendar.monthcalendar(year, month) 返回一個整數的單層嵌套列表。每個子列表裝載代表一個星期的整數，Year 年month 月外的日期都設為0，范圍內的日子都由該月第幾日表示，從1開始
- calendar.monthrange(year,month) 返回兩個整數。第一個是該月的星期幾的日期碼，第二個是該月的日期碼，日從0（星期一）到6（星期日），月從1到12
- calendar.prcal(year,w=2,l=1,c=6) 相當于 print(calendar.calendar(year,w,l,c))
輸出結果：
2016January February March Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su1 2 3 1 2 3 4 5 6 7 1 2 3 4 5 64 5 6 7 8 9 10 8 9 10 11 12 13 14 7 8 9 10 11 12 13 11 12 13 14 15 16 17 15 16 17 18 19 20 21 14 15 16 17 18 19 20 18 19 20 21 22 23 24 22 23 24 25 26 27 28 21 22 23 24 25 26 27 25 26 27 28 29 30 31 29 28 29 30 31April May June Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su1 2 3 1 1 2 3 4 54 5 6 7 8 9 10 2 3 4 5 6 7 8 6 7 8 9 10 11 12 11 12 13 14 15 16 17 9 10 11 12 13 14 15 13 14 15 16 17 18 19 18 19 20 21 22 23 24 16 17 18 19 20 21 22 20 21 22 23 24 25 26 25 26 27 28 29 30 23 24 25 26 27 28 29 27 28 29 3030 31July August September Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su1 2 3 1 2 3 4 5 6 7 1 2 3 44 5 6 7 8 9 10 8 9 10 11 12 13 14 5 6 7 8 9 10 11 11 12 13 14 15 16 17 15 16 17 18 19 20 21 12 13 14 15 16 17 18 18 19 20 21 22 23 24 22 23 24 25 26 27 28 19 20 21 22 23 24 25 25 26 27 28 29 30 31 29 30 31 26 27 28 29 30October November December Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su1 2 1 2 3 4 5 6 1 2 3 43 4 5 6 7 8 9 7 8 9 10 11 12 13 5 6 7 8 9 10 11 10 11 12 13 14 15 16 14 15 16 17 18 19 20 12 13 14 15 16 17 18 17 18 19 20 21 22 23 21 22 23 24 25 26 27 19 20 21 22 23 24 25 24 25 26 27 28 29 30 28 29 30 26 27 28 29 30 31 31None- calendar.prmonth(year,month,w=2,l=1) 相當于 print(calendar.calendar(year，w，l，c))
輸出結果：
1 November 2016 2 Mo Tu We Th Fr Sa Su 3 1 2 3 4 5 6 4 7 8 9 10 11 12 13 5 14 15 16 17 18 19 20 6 21 22 23 24 25 26 27 7 28 29 30- calendar.setfirstweekday(weekday) 設置每周的起始日期碼。0（星期一）到6（星期日）
- calendar.timegm(tupletime) 和 time.gmtime 相反：接受一個時間元組形式，返回該時刻的時間輟（1970紀元后經過的浮點秒數）
- calendar.weekday(year,month,day) 返回給定日期的日期碼。0（星期一）到6（星期日）。月份為 1（一月） 到 12（12月）
datetime 模塊
- datetime.datetime.now() 返回當前時間
- datetime.date.fromtimestamp(time.time()) 時間戳直接轉成日期格式
- datetime.datetime.now() + datetime.timedelta(3)) 當前時間+3天
- datetime.datetime.now() + datetime.timedelta(-3)) 當前時間-3天
- datetime.datetime.now() + datetime.timedelta(hours=3)) 當前時間+3小時
- datetime.datetime.now() + datetime.timedelta(minutes=30) 當前時間+30分
- replace(minute, hour)?時間替換
2）random
Python中的random模塊用于生成隨機數
random.random()
用于生成一個0到1的隨機浮點數: 0 <= n < 1.0
1 >>> import random 2 >>> random.random() 3 0.99107532292498801random.uniform(a, b)
用于生成一個指定范圍內的隨機浮點數，兩個參數其中一個是上限，一個是下限。如果a > b，則生成的隨機數n: a <= n <= b；如果 a <b， 則 b <= n <= a。
1 >>> import random 2 >>> random.uniform(10, 20) 3 12.893035403821591 4 >>> random.uniform(20, 10) 5 15.344944314032574random.randint(a, b)
用于生成一個指定范圍內的整數。其中參數a是下限，參數b是上限，生成的隨機數n: a <= n <= b
1 >>> import random 2 >>> random.randint(12, 20) # 生成的隨機數n: 12 <= n <= 20 3 16 4 >>> random.randint(20, 20) # 結果永遠是20 5 20 6 >>> random.randint(20, 10) # 該語句是錯誤的，下限必須小于上限 7 Traceback (most recent call last): 8 File "<stdin>", line 1, in <module> 9 File "/usr/lib64/python2.6/random.py", line 228, in randint 10 return self.randrange(a, b+1) 11 File "/usr/lib64/python2.6/random.py", line 204, in randrange 12 raise ValueError, "empty range for randrange() (%d,%d, %d)" % (istart, istop, width) 13 ValueError: empty range for randrange() (20,11, -9)random.randrange([start], stop[, step])
從指定范圍內，按指定基數遞增的集合中獲取一個隨機數。
1 >>> import random 2 >>> random.randrange(10, 100, 2) 3 80結果相當于從 [10, 12, 14, 16, ... 96, 98] 序列中獲取一個隨機數。
random.randrange(10, 100, 2)在結果上與 random.choice(range(10, 100, 2) 等效。
random.choice(sequence)
從序列中獲取一個隨機元素，參數 sequence 表示一個有序類型。這里要說明?一下：sequence 在python 不是一種特定的類型，而是泛指一系列的類型。list, tuple, 字符串都屬于sequence。
1 >>> import random 2 >>> random.choice("學習Python") 3 '\xe4' 4 >>> random.choice(["JGood", "is", "a", "handsome", "boy"]) 5 'boy' 6 >>> random.choice(("Tuple", "List", "Dict")) 7 'List'random.shuffle(x[, random])
用于將一個列表中的元素打亂
1 >>> import random 2 >>> p = ["Python", "is", "powerful", "simple", "and so on..."] 3 >>> random.shuffle(p) 4 >>> p 5 ['is', 'Python', 'and so on...', 'powerful', 'simple']random.sample(sequence, k)
從指定序列中隨機獲取指定長度的片，sample函數不會修改原有序列
1 >>> import random 2 >>> list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 3 >>> slice = random.sample(list, 5) 4 >>> slice 5 [8, 6, 9, 3, 7] 6 >>> list 7 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]多個字符中選取特定數量的字符
1 >>> import random 2 >>> random.sample('abcdefghij',3) 3 ['i', 'c', 'b']random.sample 驗證碼應用
方式一：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import random 5 import string 6 7 str_source = string.ascii_letters + string.digits 8 code = random.sample(str_source, 6) 9 for i in code: 10 print(i, end="")輸出結果：
1 0sHxSZ方式二：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import random 5 6 check_code = "" 7 for i in range(6): 8 current = random.randrange(0, 6) 9 if current != i: 10 temp = chr(random.randint(65, 90)) 11 else: 12 temp = random.randint(0, 9) 13 check_code += str(temp) 14 print(check_code)輸出結果：
1 HY5YNN3）os
os.name
輸出字符串指示正在使用的平臺。
如果是window 則用'nt'表示:
1 >>> import os 2 >>> os.name 3 'nt'對于Linux/Unix用戶，它是'posix':
1 >>> import os 2 >>> os.name 3 'posix'os.getcwd()
獲取當前工作目錄，即當前 python 腳本工作的目錄路徑
1 >>> import os 2 >>> os.getcwd() 3 '/home/test'os.chdir("dirname")
改變當前腳本工作目錄，相當于shell下cd
1 >>> import os 2 >>> os.getcwd() 3 '/home/test' 4 >>> os.chdir("Python35") 5 >>> os.getcwd() 6 '/usr/local/python35'os.curdir
返回當前目錄: ('.')
1 >>> import os 2 >>> os.curdir 3 '.'os.pardir
獲取當前目錄的父目錄字符串名：('..')
1 >>> import os 2 >>> os.pardir 3 '..'os.makedirs('dirname1/dirname2')
可生成多層遞歸目錄
1 >>> import os 2 >>> os.getcwd() 3 '/home/test' 4 >>> os.makedirs('test1/test2') 5 >>> os.chdir('test1') 6 >>> os.getcwd() 7 '/home/test/test1' 8 >>> os.chdir('test2') 9 >>> os.getcwd() 10 '/home/test/test1/test2'os.removedirs('dirname1')
若目錄為空，則刪除，并遞歸到上一級目錄，如若也為空，則刪除，依此類推
1 >>> import os 2 >>> os.getcwd() 3 '/home/test/test1/test2' 4 >>> os.chdir('..') 5 >>> os.getcwd() 6 '/home/test/test1' 7 >>> os.removedirs('test2') 8 >>> os.getcwd() 9 '/home/test/test1' 10 >>> os.chdir('test2') 11 Traceback (most recent call last): 12 File "<stdin>", line 1, in <module> 13 OSError: [Errno 2] No such file or directory: 'test2'os.mkdir('dirname')
生成單級目錄，相當于 shell 中 mkdir dirname
1 >>> import os 2 >>> os.getcwd() 3 '/home/test' 4 >>> os.chdir('test1') 5 >>> os.getcwd() 6 '/home/test/test1' 7 >>> os.listdir('.') 8 [] 9 >>> os.mkdir('test2') 10 >>> os.listdir('.') 11 ['test2']os.listdir('dirname')
列出指定目錄下的所有文件和子目錄，包括隱藏文件，并以列表方式打印
1 >>> import os 2 >>> os.listdir('.') 3 ['.zshrc', '.subversion', '.dbshell', '.mozilla', '.bash_logout', '.gnome2', '.bash_history', '.bashrc', 'test1', '.viminfo', '.emacs', '.bash_profile']os.rmdir('dirname')
刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當于shell中rmdir dirname
1 >>> import os 2 >>> os.getcwd() 3 '/home/test/test1' 4 >>> os.listdir('.') 5 ['test2'] 6 >>> os.rmdir('test2') 7 >>> os.listdir('.') 8 []os.remove()
刪除一個文件
1 >>> import os 2 >>> os.listdir('.') 3 ['test.log'] 4 >>> os.remove('test.log') 5 >>> os.listdir('.') 6 []os.rename("oldname","newname")
重命名文件/目錄
1 >>> import os 2 >>> os.listdir('.') 3 ['test.log'] 4 >>> os.rename('test.log','hello.txt') 5 >>> os.listdir('.') 6 ['hello.txt']os.stat('path/filename')
獲取文件/目錄信息
1 >>> import os 2 >>> os.listdir('.') 3 ['hello.txt'] 4 >>> os.stat('hello.txt') 5 posix.stat_result(st_mode=33188, st_ino=2629852, st_dev=64768L, st_nlink=1, st_uid=505, st_gid=301, st_size=0, st_atime=1478588652, st_mtime=1478588652, st_ctime=1478588686)os.sep
輸出操作系統特定的路徑分隔符
win下為"\\"
1 >>> import os 2 >>> os.sep 3 '\\'Linux下為"/"
>>> import os >>> os.sep '/'os.linesep
輸出當前平臺使用的行終止符
win下為"\r\n"
1 >>> import os 2 >>> os.linesep 3 '\r\n'Linux下為"\n"
1 >>> import os 2 >>> os.linesep 3 '\n'os.pathsep
輸出用于分割文件路徑的字符串
win下為';'
1 >>> import os 2 >>> os.pathsep 3 ';'Linux下為':'
1 >>> import os 2 >>> os.pathsep 3 ':'os.system("bash command")
運行shell命令，直接顯示
1 >>> import os 2 >>> os.system('date') 3 Tue Nov 8 15:15:26 CST 2016 4 0os.environ
獲取系統環境變量
1 >>> import os 2 >>> os.environ 3 environ({'OS': 'Windows_NT', 'PROCESSOR_REVISION': '1706', 'HOMEPATH': '\\Users\\test', 'APPDATA': 'C:\\Users\\test\\AppData\\Roaming', 'PUBLIC': 'C:\\Users\\Public', 'PROGRAMFILES(X86)': 'C:\\Program Files (x86)', 'COMPUTERNAME': 'TEST-PC', 'SYSTEMDRIVE': 'C:', 'LOCALAPPDATA': 'C:\\Users\\test\\AppData\\Local', 'COMMONPROGRAMFILES': 'C:\\Program Files\\Common Files', 'SESSIONNAME': 'Console', 'FP_NO_HOST_CHECK': 'NO', 'PROCESSOR_IDENTIFIER': 'Intel64 Family 6 Model 23 Stepping 6, GenuineIntel', 'PROGRAMDATA': 'C:\\ProgramData', 'USERNAME': 'test','PROGRAMFILES': 'C:\\Program Files', 'CATALINA_HOME': 'D:\\apache-tomcat-6.0.45', 'NUMBER_OF_PROCESSORS': '2', 'TMP': 'C:\\Users\\test\\AppData\\Local\\Temp','PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY;.PYW', 'PROMPT': '$P$G', 'COMMONPROGRAMFILES(X86)': 'C:\\Program Files (x86)\\Common Files', 'COMSPEC': 'C:\\Windows\\system32\\cmd.exe', 'PROGRAMW6432': 'C:\\Program Files', 'SYSTEMROOT': 'C:\\Windows', 'PATH': 'D:\\Python35\\Scripts\\;D:\\Python35\\;D:\\oracle\\product\\10.2.0\\client_1\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;D:\\Program Files\\TortoiseSVN\\bin;C:\\Redis\\;C:\\Java\\jdk1.6\\bin;D:\\MongoDB\\Server\\3.2\\bin', 'TEMP': 'C:\\Users\\test\\AppData\\Local\\Temp', 'USERDOMAIN': 'test-PC', 'COMMONPROGRAMW6432': 'C:\\Program Files\\Common Files', 'PROCESSOR_LEVEL': '6', 'PSMODULEPATH': 'C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\Modules\\;C:\\Program Files\\Intel\\', 'USERPROFILE': 'C:\\Users\\test', 'ALLUSERSPROFILE': 'C:\\ProgramData', 'LOGONSERVER': '\\\\TEST-PC', 'WINDIR': 'C:\\Windows', 'JAVA_HOME': 'C:\\Java\\jdk1.6', 'HOMEDRIVE': 'C:', 'PROCESSOR_ARCHITECTURE': 'AMD64'})os.path.abspath(path)
返回path規范化的絕對路徑
1 >>> import os 2 >>> os.path.abspath('test1') 3 '/home/test/test1/test1'os.path.split(path)
將path分割成目錄和文件名二元組返回
1 >>> import os 2 >>> os.path.split('/home/test') 3 ('/home', 'test')os.path.dirname(path)
返回 path 的目錄，其實就是os.path.split(path)的第一個元素
1 >>> import os 2 >>> os.path.dirname('/home/test') 3 '/home'os.path.basename(path)
返回path最后的文件名，如果 path 以 ／ 或 \ 結尾，那么就會返回空值，即os.path.split(path)的第二個元素
1 >>> import os 2 >>> os.path.basename('home/test') 3 'test' 4 >>> os.path.basename('home/test/') 5 ''os.path.exists(path)
如果path存在，返回True；如果path不存在，返回False
1 >>> import os 2 >>> os.getcwd() 3 '/home/test/test1' 4 >>> os.listdir('.') 5 ['test2', 'hello.txt'] 6 >>> os.path.exists('test1') 7 False 8 >>> os.path.exists('test2') 9 Trueos.path.isabs(path)
如果path是絕對路徑，返回True
1 >>> import os 2 >>> os.path.isabs('/home/test/test1') 3 True 4 >>> os.path.isabs('test1') 5 Falseos.path.isfile(path)
如果path是一個存在的文件，返回True。否則返回False
1 >>> import os 2 >>> os.listdir('.') 3 ['test2', 'hello.txt'] 4 >>> os.path.isfile('hello.txt') 5 True 6 >>> os.path.isfile('test.log') 7 Falseos.path.isdir(path)
如果path是一個存在的目錄，則返回True。否則返回False
1 >>> import os 2 >>> os.listdir('.') 3 ['test2', 'hello.txt'] 4 >>> os.path.isdir('test2') 5 True 6 >>> os.path.isdir('hello.txt') 7 Falseos.path.join(path1[, path2[, ...]])
將多個路徑組合后返回，第一個絕對路徑之前的參數將被忽略
1 >>> import os 2 >>> os.path.join('test1','test2','test') 3 'test1/test2/test' 4 >>> os.path.join('/home/test/test1','test2','test') 5 '/home/test/test1/test2/test' 6 >>> os.path.join('test1','/home/test/test1/test2','test') 7 '/home/test/test1/test2/test'os.path.getatime(path)
返回path所指向的文件或者目錄的最后存取時間
1 >>> import os 2 >>> os.listdir('.') 3 ['test2', 'hello.txt'] 4 >>> os.path.getatime('hello.txt') 5 1478588652.6452732os.path.getmtime(path)
返回path所指向的文件或者目錄的最后修改時間
1 >>> import os 2 >>> os.listdir('.') 3 ['test2', 'hello.txt'] 4 >>> os.path.getmtime('hello.txt') 5 1478588652.6452732os.path.split(path)
返回一個路徑的目錄名和文件名
1 >>> import os 2 >>> os.path.split('/home/test/test1/hello.txt') 3 ('/home/test/test1', 'hello.txt')os.path.getsize(name)
獲得文件大小
1 >>> import os 2 >>> os.listdir('.') 3 ['test2', 'hello.txt'] 4 >>> os.path.getsize('hello.txt') 5 12 6 >>> os.path.getsize('test2') 7 40964）sys
sys.argv
在外部向程序內部傳遞參數，以list的形式返回參數列表
1 >>> import sys 2 >>> sys.argv 3 ['']示例：
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import sys 5 6 print(sys.argv[0]) 7 print(sys.argv[1])運行結果：
1 $ python sys.py argv1 2 sys.py 3 argv1sys.exit(n)
執行到主程序末尾，解釋器自動退出，但是如果需要中途退出程序，可以調用sys.exit函數，帶有一個可選的整數參數返回給調用它的程序，表示你可以在主程序中捕獲對sys.exit的調用。（0是正常退出，其他為異常）
1 >>> import sys 2 >>> sys.exit(1) 3 [root@test ~]$ echo $? 4 1sys.version
獲取Python解釋程序的版本信息
1 >>> import sys 2 >>> sys.version 3 '3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AMD64)]'sys.maxint
獲取最大的int值
1 >>> import sys 2 >>> sys.maxint 3 9223372036854775807sys.path
返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值 >>> import sys >>> sys.path ['', '/usr/local/python35/lib/python35.zip', '/usr/local/python35/lib/python3.5', '/usr/local/python35/lib/python3.5/plat-linux', '/usr/local/python35/lib/python3.5/lib-dynload', '/usr/local/python35/lib/python3.5/site-packages']sys.platform
返回操作系統平臺名稱 1 >>> import sys 2 >>> sys.platform 3 'linux' sys.modules sys.modules是一個全局字典，該字典是python啟動后就加載在內存中。每當程序員導入新的模塊，sys.modules將自動記錄該模塊。當第二次再導入該模塊時，python會直接到字典中查找，從而加快了程序運行的速度。它擁有字典所擁有的一切方法。 1 >>> import sys 2 >>> sys.modules 3 {'_sitebuiltins': <module '_sitebuiltins' from '/usr/local/python35/lib/python3.5/_sitebuiltins.py'>, 'encodings.aliases': <module 'encodings.aliases' from '/usr/local/python35/lib/python3.5/encodings/aliases.py'>, 'errno': <module 'errno' (built-in)>, '_collections_abc': <module '_collections_abc' from '/usr/local/python35/lib/python3.5/_collections_abc.py'>, 'atexit': <module 'atexit' (built-in)>, 'posixpath': <module 'posixpath' from '/usr/local/python35/lib/python3.5/posixpath.py'>, '_codecs': <module '_codecs' (built-in)>, '__main__': <module '__main__' (built-in)>, 'builtins': <module 'builtins' (built-in)>, 'io': <module 'io' from '/usr/local/python35/lib/python3.5/io.py'>, 'genericpath': <module 'genericpath' from '/usr/local/python35/lib/python3.5/genericpath.py'>, 'site': <module 'site' from '/usr/local/python35/lib/python3.5/site.py'>, '_io': <module 'io' (built-in)>, '_frozen_importlib_external': <module '_frozen_importlib_external' (frozen)>, '_stat': <module '_stat' (built-in)>, '_thread': <module '_thread' (built-in)>, 'encodings.latin_1': <module 'encodings.latin_1' from '/usr/local/python35/lib/python3.5/encodings/latin_1.py'>, 'encodings.utf_8': <module 'encodings.utf_8' from '/usr/local/python35/lib/python3.5/encodings/utf_8.py'>, '_imp': <module '_imp' (built-in)>, 'os': <module 'os' from '/usr/local/python35/lib/python3.5/os.py'>, '_weakref': <module '_weakref' (built-in)>, 'zipimport': <module 'zipimport' (built-in)>, 'posix': <module 'posix' (built-in)>, 'stat': <module 'stat' from '/usr/local/python35/lib/python3.5/stat.py'>, 'os.path': <module 'posixpath' from '/usr/local/python35/lib/python3.5/posixpath.py'>, 'codecs': <module 'codecs' from '/usr/local/python35/lib/python3.5/codecs.py'>, 'abc': <module 'abc' from '/usr/local/python35/lib/python3.5/abc.py'>, '_frozen_importlib': <module '_frozen_importlib' (frozen)>, 'encodings': <module 'encodings' from '/usr/local/python35/lib/python3.5/encodings/__init__.py'>, 'marshal': <module 'marshal' (built-in)>, '_signal': <module '_signal' (built-in)>, '_weakrefset': <module '_weakrefset' from '/usr/local/python35/lib/python3.5/_weakrefset.py'>, 'sys': <module 'sys' (built-in)>, 'sysconfig': <module 'sysconfig' from '/usr/local/python35/lib/python3.5/sysconfig.py'>, '_warnings': <module '_warnings' (built-in)>, '_sysconfigdata': <module '_sysconfigdata' from '/usr/local/python35/lib/python3.5/_sysconfigdata.py'>} sys.stdout.write('please:') 1 >>> import sys 2 >>> sys.stdout.write('please:') 3 please:7val?=?sys.stdin.readline()[:-1]
1 >>> import sys 2 >>> val = sys.stdin.readline()[:-1] 3 Hello World 4 >>> val 5 'Hello World'5）shutil
高級的對文件、文件夾、壓縮包處理的模塊
| ?copyfile( src, dst) | ?從源src復制到dst中去。當然前提是目標地址是具備可寫權限。拋出的異常信息為IOException. 如果當前的dst已存在的話就會被覆蓋掉 |
| ?copymode( src, dst) | ?只是會復制其權限其他的東西是不會被復制的 |
| ?copystat( src, dst) | ?復制權限、最后訪問時間、最后修改時間 |
| ?copy( src, dst)??? | ?復制一個文件到一個文件或一個目錄 |
| ?copy2( src, dst)? | ?在copy上的基礎上再復制文件最后訪問時間與修改時間也復制過來了，類似于cp –p的東西 |
| ?copy2( src, dst)? | ?如果兩個位置的文件系統是一樣的話相當于是rename操作，只是改名；如果是不在相同的文件系統的話就是做move操作 |
| ?copytree(olddir,newdir,True/Flase) | ?把olddir拷貝一份newdir，如果第3個參數是True，則復制目錄時將保持文件夾下的符號連接，如果第3個參數是False，則將在復制的目錄下生成物理副本來替代符號連接 |
shutil.copyfileobj(fsrc, fdst[, length])
將文件內容拷貝到另一個文件中，可以部分內容
?View Codeshutil.copyfile(src, dst)
拷貝文件
shutil.copymode(src, dst)
僅拷貝權限。內容、組、用戶均不變
shutil.copystat(src, dst)
拷貝狀態的信息，包括：mode bits, atime, mtime, flags
shutil.copy(src, dst)
拷貝文件和權限
shutil.copy2(src, dst)
拷貝文件和狀態信息
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
遞歸的去拷貝文件
例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))
?View Codeshutil.rmtree(path[, ignore_errors[, onerror]])
遞歸的去刪除文件
shutil.move(src, dst)
遞歸的去移動文件
shutil.make_archive(base_name, format,...)
創建壓縮包并返回文件路徑，例如：zip、tar
- base_name： 壓縮包的文件名，也可以是壓縮包的路徑。只是文件名時，則保存至當前目錄，否則保存至指定路徑，
如：www ? ? ? ? ? ? ? ? ? ? ? ?=>保存至當前路徑
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/ - format： 壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要壓縮的文件夾路徑（默認當前目錄）
- owner： 用戶，默認當前用戶
- group： 組，默認當前組
- logger： 用于記錄日志，通常是logging.Logger對象
| 1 2 3 4 5 6 7 8 9 | #將 /Users/wupeiqi/Downloads/test 下的文件打包放置當前程序目錄 import?shutil ret?=?shutil.make_archive("wwwwwwwwww",?'gztar', root_dir='/Users/wupeiqi/Downloads/test') #將 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目錄 import?shutil ret?=?shutil.make_archive("/Users/wupeiqi/wwwwwwwwww",?'gztar', root_dir='/Users/wupeiqi/Downloads/test') |
shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的，詳細：
?zipfile 壓縮解壓 ?tarfile 壓縮解壓 ?ZipFile ?TarFile??
6）json & pickle
用于序列化的兩個模塊
- json，用于字符串和 python 數據類型間進行轉換
- pickle，用于 python 特有的類型和 python 數據類型間進行轉換
Json 模塊提供了四個功能：dumps、dump、loads、load
pickle 模塊提供了四個功能：dumps、dump、loads、load
?
JSON 模塊
JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式，易于閱讀和編寫，同時也易于機器解析和生成，它基于?JavaScript Programming Language,?Standard ECMA-262 3rd Edition - December 1999?的一個子集。 JSON采用完全獨立于語言的文本格式，但是也使用了類似于C語言家族的習慣（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 這些特性使JSON成為理想的數據交換語言。
Python3 中可以使用 json 模塊來對 JSON 數據進行編解碼，它包含了兩個函數:
json.dumps與json.loads實例
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import json 5 # 將python的基礎數據類型轉化成字符串 6 dic = {"k1": "v1", "k2": "v2"} 7 print("Python原始數據:", repr(dic), type(dic)) 8 result = json.dumps(dic) # 將字典類型轉換為字符串類型 9 print("JSON對象:", result, type(result))輸出結果：
1 Python原始數據: {'k2': 'v2', 'k1': 'v1'} <class 'dict'> 2 JSON對象: {"k2": "v2", "k1": "v1"} <class 'str'>JSON 編碼的字符串轉換回 Python 數據結構
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import json 5 # 將 python 的基礎數據類型轉化成字符串 6 dic = {"k1": "v1", "k2": "v2"} 7 print("Python原始數據:", repr(dic), type(dic)) 8 result = json.dumps(dic) # 將字典類型轉換為字符串類型 9 print("JSON對象:", result, type(result)) 10 11 # 將 python 字符串類型轉化為 python 基本數據類型 12 result = json.loads(result) 13 print("result['k1']:", result['k1']) 14 print("result['k2']:", result['k2'])輸出結果：
1 Python原始數據: {'k1': 'v1', 'k2': 'v2'} <class 'dict'> 2 JSON對象: {"k1": "v1", "k2": "v2"} <class 'str'> 3 result['k1']: v1 4 result['k2']: v2如果要處理的是文件而不是字符串，可以使用?json.dump()?和?json.load()?來編碼和解碼JSON數據
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import json 5 6 data = { 7 'name': "James", 8 'age': 24, 9 'job': "IT" 10 } 11 # 寫入 json 數據 12 with open('db.json', 'w', encoding="UTF-8") as f: 13 json.dump(data, f) 14 15 # 讀取json數據 16 with open('db.json', 'r', encoding="UTF-8") as f: 17 res = json.load(f) 18 print(res,type(res))輸出結果：
1 {'name': 'James', 'age': 24, 'job': 'IT'} <class 'dict'>PICKLE 模塊
pickle 模塊使用的數據格式是 python 專用的，并且不同版本不向后兼容，同時也不能被其他語言說識別。要和其他語言交互，可以使用內置的 json 包使用 pickle 模塊你可以把Python對象直接保存到文件，而不需要把他們轉化為字符串，也不用底層的文件訪問操作把它們寫入到一個二進制文件里。 pickle模塊會創建一個python語言專用的二進制格式，基本上不用考慮任何文件細節，它會幫你干凈利落地完成讀寫獨享操作，唯一需要的只是一個合法的文件句柄。
python3中可以使用pickle模塊，對數據進行編解碼。它包含兩個函數：
pickle.dumps與pickle.loads實例
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import pickle 5 6 data = { 7 'name': "James", 8 'age': 24, 9 'job': "IT" 10 } 11 12 print("原始python對象：", repr(data)) 13 r = pickle.dumps(data) 14 print("pickle轉換后的對象：", r) 15 res = pickle.loads(r) 16 print("res['name']:", res['name']) 17 print("res['age']:", res['age']) 18 print("res['job']:", res['job'])輸出結果：
1 原始python對象： {'name': 'James', 'job': 'IT', 'age': 24} 2 pickle轉換后的對象： b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00Jamesq\x02X\x03\x00\x00\x00jobq\x03X\x02\x00\x00\x00ITq\x04X\x03\x00\x00\x00ageq\x05K\x18u.' 3 res['name']: James 4 res['age']: 24 5 res['job']: IT如果要處理的是文件而不是字符串，你可以使用?pickle.dump()?和?pickle.load()?來編碼和解碼JSON數據
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 import pickle 5 6 data = { 7 'name': "James", 8 'age': 24, 9 'job': "IT" 10 } 11 # 寫入數據，要以wb格式寫入 12 pickle.dump(data, open('db', 'wb')) 13 # 讀取數據，要以rb格式讀取 14 f = open('db', 'rb') 15 res = pickle.load(f) 16 print(res)輸出結果：
1 {'name': 'James', 'age': 24, 'job': 'IT'}pickle和json的區別：
- json 適合跨語言，對于 python 而言僅適用于 Python 基本數據類型
- pickle 僅適用于 python，pickle 適用于 python 所有數據類型的序列化
- pickle 寫入和讀取文件時，用的是 ‘b’模式，而 json 沒有。
- json 只能序列化最基本的數據類型，而 pickle 可以序列化所有的數據類型，包括類，函數都可以序列化。
7）shelve
8）xml 處理
9）yaml 處理
10）configparser
11) hashlib
12) subprocess
subprocess模塊是子進程管理器，用戶來生成子進程，并可以通過管道連接他們的輸入、輸出、錯誤，以及獲取它們的返回值。
subprocess模塊用來代替多個舊模塊和函數，例如：
- os.system
- os.spawn*
- os.popen*
- popen2.*
- commands.*
subprocess.call
語法:
? ? ?subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)
語義:
? ? ?運行由args指定的命令，直到命令結束后，返回返回碼的屬性值。
上面的參數是最常見的方式，下面是示例代碼:
>>>
>>> subprocess.call(["ls", "-l"])
0
>>> subprocess.call("exit 1", shell=True)
1
使用 shell=True 是一種安全保護機制。
在使用這個函數時，不要使用 stdout=PIPE 或 stderr=PIPE 參數，不然會導致子進程輸出的死鎖。
如果要使用管道，可以在 communicate()方法中使用Popen
示例代碼:
import subprocess
rc = subprocess.call(["ls","-l"])
可以通過一個shell來解釋一整個字符串:
import subprocess
out = subprocess.call("ls -l", shell=True)
out = subprocess.call("cd ..", shell=True)
使用了shell=True這個參數。
這個時候，我們使用一整個字符串，而不是一個表來運行子進程。
Python將先運行一個shell，再用這個shell來解釋這整個字符串。
shell命令中有一些是shell的內建命令，這些命令必須通過shell運行，$cd。
shell=True允許我們運行這樣一些命令。
2. subprocess.check_call
語法:?
? ? ?subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False)
語義:
? ? ?運行由args指定的命令，直到命令執行完成。
? ? ?如果返回碼為零，則返回。否則，拋出 CalledProcessError異常。
? ? ?CalledProcessError對象包含有返回碼的屬性值。
上面顯示的參數僅僅是最常見的，下面是用戶更常用的參數。
示例代碼如下:
>>>
>>> subprocess.check_call(["ls", "-l"])
0
>>> subprocess.check_call("exit 1", shell=True)
Traceback (most recent call last):
? ?...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
這個函數在python 2.5版本中引入。
WARNING: 使用 shell=True 是一種安全機制。
NOTE: 不要在這個函數中使用 stdout=PIPE 或 stderr=PIPE, 否則會造成子進程死鎖。
? ? ? 如果需要使用管道，可以在 communicate()方法中使用Popen.
3. subprocess.check_output
語法:?
? ? ? subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)
語義:
? ? ?運行args定義的命令，并返回一個字符串表示的輸出值。
? ? ?如果返回碼為非零，則拋出 CalledProcessError異常。
示例代碼:
>>>
>>> subprocess.check_output(["echo", "Hello World!"])
'Hello World!\n'
>>> subprocess.check_output("exit 1", shell=True)
Traceback (most recent call last):
? ?...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
如果要捕捉結果中的標準錯誤，使用 stderr=subprocess.STDOUT參數:
>>>
>>> subprocess.check_output(
... ? ? "ls non_existent_file; exit 0",
... ? ? stderr=subprocess.STDOUT,
... ? ? shell=True)
'ls: non_existent_file: No such file or directory\n'
這個函數在python 2.7版本中引入。
WARNING: 使用 shell=True 是一種安全機制。
NOTE: 不要在這個函數中使用 stdout=PIPE 或 stderr=PIPE, 否則會造成子進程死鎖。
? ? ? 如果需要使用管道，可以在 communicate()方法中使用Popen.
4. subprocess.PIPE
? ?使用Popen時，用于 stdin, stdout和stderr參數的特殊值，表示打開連接標準流的管道。
5. subprocess.STDOUT
? ?使用Popen時，用于 stderr 參數的特殊值，表示將標準錯誤重定向到標準輸出的同一個句柄。
6. 異常 subprocess.CalledProcessError
? ?當由 check_call()或 check_output()運行的進程返回非零狀態值時拋出的異常。
7. returncode
? ?子進程的退出狀態。
8. cmd
? ?子進程執行的命令。
9. output
? ?如果check_output()拋出異常時，子進程的輸出值。
? ?否則，沒有這個值。
1.1.1. 常用的參數
為了支持各種用戶使用情況 ，Popen構建函數接收多種可選參數。
對于最典型的情況，許多參數都保留有安全的默認值，這些最常用的方式如下:
1. args
所有的函數都需要這個參數，并且它是一個字符串，或者是程序的參數序列。
提供一個參數序列是更推薦的方式，因為這樣能允許模塊接收空格 或 引號中的參數。
如果傳遞的是單個字符串，要么 shell=True, 或都要么 字符串就程序名字，并且不能帶參數。
2. stdin, stdout 和 stderr
stdin, stdout和stderr指定了執行程序的標準輸入，標準輸出和標準錯誤的文件句柄。
它們的值可以是PIPE, 一個存在的文件描述符(正整數)，一個存在的文件對象，或 None.
PIPE 表示創建一個連接子進程的新管道。
默認值 為 None, 表示不做重定向。
子進程的文件句柄可以從父進程中繼承得到。
另外，stderr可以設置值為 STDOUT,表示子進程的錯誤數據可以和標準輸出是同一個文件句柄。
當stdout 或 stderr的值為管道 并且 ?universal_newlines的值為真時，
對于以 ‘U'模式參數打開的新行，所有行的結束都會轉換成'\n'。
3. shell
如果 shell的值為 True， 則指定的命令行會通過shell來執行。
如果你使用Python來作為流程控制，那這樣的設置會很有用，因為它提供了絕大多數的系統shell命令且可以很方便地使用
shell的各種功能，如 shell 管道，文件名通配符，環境變量擴展，以及用戶目錄擴展符 ~。
但是，需要注意的是，Python 提供了類似shell功能的實現。
WARNING: 執行不受信任來源的shell命令會是一個嚴重的安全問題。
? ? ? ? ?基于這一點，shell=True 是不建議的。
示例代碼如下:
>>>
>>> from subprocess import call
>>> filename = input("What file would you like to display?\n")
What file would you like to display?
non_existent; rm -rf / #
>>> call("cat " + filename, shell=True) # Uh-oh. This will end badly...
shell=False 關閉了shell的所有基本功能 ，從而不會有上面所說的安全漏洞。
可以在Popen構建函數的幫助文檔中看到，它只有在 shell=False時才能工作。
當使用 ?shell=True時，pipes.quote()可以被用于轉譯空格，shell的字符等。
1.1.2. Popen構建函數
subprocess中更底層的進程創建和管理可以通過Popen類實現。
它提供了更多的靈活性，程序員通過它能處理更多復雜的情況。
語法:
? ? ?class subprocess.Popen(args, bufsize=0, executable=None,?
? ? ? ? ? ? ? ? ? ? ? ? ? ? stdin=None, stdout=None, stderr=None,?
? ? ? ? ? ? ? ? ? ? ? ? ? ? preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None,
? ? ? ? ? ? ? ? ? ? ? ? ? ? universal_newlines=False, startupinfo=None, creationflags=0)
語義:
? ? ?在新進程中執行一個子程序。
? ? ?在Unix中，這個類使用 類似于 os.execvp()方式來執行子程序。
? ? ?在Windows中，這個類使用Windows的 CreateProcess()函數來執行子程序。
參數解析:
args: 一個程序參數序列，或者單個字符串。
? ? ? 默認的，要執行的程序應該是序列的第一個字段。
? ? ? 如果單個字符串，它的解析依賴于平臺
在Unix中，如果 args是一個字符串，那么這個字符串解釋成被執行程序的名字或路徑。
然而，這種情況只能用在不需要參數的程序。
NOTE: 當對args確定了正確的分隔符后，shlex.split()就很有用，特別是在復雜的情況下：
>>>
>>> import shlex, subprocess
>>> command_line = raw_input()
/bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'"
>>> args = shlex.split(command_line)
>>> print args
['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"]
>>> p = subprocess.Popen(args) # Success!
NOTE: 選項(如 -input) 和 參數(如 eggs.txt) 在shell中是用空格分隔成分離的列表元素。
? ? ? 如果參數需要引號或反斜線，則它們會是一個單一列表元素。
shell參數(默認值為False)聲明了是否使用shell來執行程序。
如果 shell=True, 它將args看作是一個字符串，而不是一個序列。
在Unix系統，且 shell=True時，shell默認使用 /bin/sh.
如果 args是一個字符串，則它聲明了通過shell執行的命令。這意味著，字符串必須要使用正確的格式。
如果 args是一個序列，則第一個元素就是命令字符串，而其它的元素都作為參數使用。
可以這樣說，Popen等價于:
? ? ? Popen(['/bin/sh', '-c', args[0], args[1], ...])
bufsize: 如果指定了值，則它和內建函數 open()對應的參數有相同的意義:
? ? ? ? ?0 -- 表示不緩沖
? ? ? ? ?1 -- 表示緩沖
? ? ? ? ?任何其它的正數值表示buffer的大小。
? ? ? ? ?負數值表示使用系統默認值，通常表示完全緩沖。
? ? ? ? ?它的默認值為零。
NOTE: 如果遇到性能問題，建議將bufsize設置成 -1 或足夠大的正數(如 4096）。
executable: 指定了用于代替執行的程序。它極少會用到。
stdin, stdout, stderr：指定了執行程序的標準輸入，標準輸出和標準錯誤的文件句柄。
? ? ? ? ?有效的值可以是 PIPE, 一個存在的文件描述符，或存在的文件對象，或 None.
? ? ? ? ?默認值為 None。?
? ? ? ? ?stderr可以設置成STDOUT, 它表示將子進程的stderr數據重定向到stdout.
preexec_fn: 如果它被設置成可調用對象，那么這個對象會在子進程執行前被子進程調用，只用于Unix.
close_fds: ?如果設置為True， 則在子進程被執行前，除0，1和2之外的所有文件描述符都將被關閉，只用于Unix。
cwd: 當它不為 None時，子程序在執行前，它的當前路徑會被替換成 cwd的值。
? ? ?這個路徑并不會被添加到可執行程序的搜索路徑，所以cwd不能是相對路徑。
env: 當它不為 None時，它是新進程的環境變量的映射。
? ? ?可以用它來代替當前進程的環境。?
universal_newlines: 為真時，文件對象 stdout和 stderr都被以文本文件的方式打開
示例代碼:
1. Popen對象創建后，主程序不會自動等待子進程完成。
我們必須調用對象的wait()方法，父進程才會等待 (也就是阻塞block)：
? ? import subprocess
? ? child = subprocess.Popen(["ping","-c","5","www.google.com"])
? ? print("parent process")
從運行結果中看到，父進程在開啟子進程之后并沒有等待child的完成，而是直接運行print。
2. 對比等待的情況:
? ?import subprocess
? ?child = subprocess.Popen(["ping","-c","5","www.google.com"])
? ?child.wait()
? ?print("parent process")
此外，你還可以在父進程中對子進程進行其它操作，比如我們上面例子中的child對象:
child.poll() ? ? ? ? ? # 檢查子進程狀態
child.kill() ? ? ? ? ? # 終止子進程
child.send_signal() ? ?# 向子進程發送信號
child.terminate() ? ? ?# 終止子進程
子進程的PID存儲在child.pid
3. 可以在Popen()建立子進程的時候改變標準輸入、標準輸出和標準錯誤，
并可以利用subprocess.PIPE將多個子進程的輸入和輸出連接在一起，構成管道(pipe):
? ? import subprocess
? ? child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
? ? child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)
? ? out = child2.communicate()
? ? print(out)
subprocess.PIPE實際上為文本流提供一個緩存區。
child1的stdout將文本輸出到緩存區，隨后child2的stdin從該PIPE中將文本讀取走。
child2的輸出文本也被存放在PIPE中，直到communicate()方法從PIPE中讀取出PIPE中的文本。
要注意的是，communicate()是Popen對象的一個方法，該方法會阻塞父進程，直到子進程完成。
4. 還可以利用communicate()方法來使用PIPE給子進程輸入:
? ? import subprocess
? ? child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
? ? child.communicate("vamei")
我們啟動子進程之后，cat會等待輸入，直到我們用communicate()輸入"vamei"。
通過使用subprocess包，我們可以運行外部程序。這極大的拓展了Python的功能。
如果你已經了解了操作系統的某些應用，你可以從Python中直接調用該應用(而不是完全依賴Python)，
并將應用的結果輸出給Python，并讓Python繼續處理。
shell的功能(比如利用文本流連接各個應用)，就可以在Python中實現。
1.1.3.異常
在開始執行新程序之前，子進程拋出的異常，會被重新拋出到父進程。
另外，異常對象會有一個額外的屬性，叫做 child_traceback, 它是一個字符串，包含從子程序的觀察點追蹤到的信息。
最常見的拋出的異常是 OSError， 當它發生時，通常是我們執行了一個不存在的文件。應用程序應當要能處理這個異常。
如果使用無效的參數調用 Popen，會拋出 ValueError異常。
如果被調用進程的返回碼不為零，則check_call()和check_output()會拋出 CalledProcessError異常。
1.1.4. 安全
Unlike some other popen functions, this implementation will never call a system shell implicitly.?
This means that all characters, including shell metacharacters, can safely be passed to child processes.?
Obviously, if the shell is invoked explicitly, then it is the application’s responsibility to ensure that?
all whitespace and metacharacters are quoted appropriately.
13) logging
將日志打印到屏幕
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 6 logging.debug("This is debug message.") 7 logging.info("This is info message.") 8 logging.warn("This warning message.") 9 logging.error("This is error message.") 10 logging.critical("This is critical message.")輸出結果：
1 WARNING:root:This warning message. 2 ERROR:root:This is error message. 3 CRITICAL:root:This is critical message.默認情況下，logging將日志打印到屏幕，日志級別為warning。
日志級別大小關系為：CRITICAL > ERROR > WARNING > INFO > DEBUG
通過 logging.basicConfig 函數對日志的輸出格式及方式做相關配置
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 6 logging.basicConfig(level=logging.DEBUG, 7 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', 8 datefmt='%a, %d %b %Y %H:%M:%S', 9 filename='mylog.log', 10 filemode='w') 11 12 logging.debug("This is debug message.") 13 logging.info("This is info message.") 14 logging.warn("This warning message.") 15 logging.error("This is error message.") 16 logging.critical("This is critical message.")輸出文件中的內容為：
1 Fri, 18 Nov 2016 23:19:16 re_module.py[line:12] DEBUG This is debug message. 2 Fri, 18 Nov 2016 23:19:16 re_module.py[line:13] INFO This is info message. 3 Fri, 18 Nov 2016 23:19:16 re_module.py[line:14] WARNING This warning message. 4 Fri, 18 Nov 2016 23:19:16 re_module.py[line:15] ERROR This is error message. 5 Fri, 18 Nov 2016 23:19:16 re_module.py[line:16] CRITICAL This is critical message.logging.basicConfig 函數參數說明
- filename: 指定日志文件名
- filemode: 和 file 函數意義相同，指定日志文件的打開模式，'w'或'a'
- format: 指定輸出的格式和內容，format可以輸出很多有用信息，如上例所示:
- %(name)s: logger 的名字
- %(levelno)s: 打印日志級別的數值
- %(levelname)s: 打印日志級別名稱
- %(pathname)s: 打印當前執行程序的路徑，其實就是 sys.argv[0]
- %(filename)s: 打印當前執行程序名
- %(funcName)s: 打印日志的當前函數
- %(lineno)d: 打印日志的當前行號
- %(asctime)s: 打印字符串形式的日志時間，默認格式是 “2016-11-19 00:06:49,620”，逗號后面的是毫秒
- %(created)f: 當前時間，用 UNIX 標準的表示時間的浮點數表示
- %(relativeCreated)d: 輸出日志信息時的，自 Logger 創建以來的毫秒數
- %(thread)d: 打印線程 ID
- %(threadName)s: 打印線程名稱
- %(process)d: 打印進程 ID
- %(message)s: 打印日志信息
- datefmt: 指定時間格式，同 time.strftime()
- level: 設置日志級別，默認為 logging.WARNING
- stream: 指定將日志的輸出流，可以指定輸出到 sys.stderr，sys.stdout 或者文件，默認輸出到 sys.stderr，當 stream 和 filenam e同時指定時，stream 被忽略
將日志同時輸出到文件和屏幕
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 6 logging.basicConfig(level=logging.DEBUG, 7 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', 8 datefmt='%a, %d %b %Y %H:%M:%S', 9 filename='mylog.log', 10 filemode='w') 11 12 ################################################################################################### 13 # 定義一個StreamHandler，將INFO級別或更高的日志信息打印到標準錯誤，并將其添加到當前的日志處理對象 14 console = logging.StreamHandler() 15 console.setLevel(logging.INFO) 16 formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') 17 console.setFormatter(formatter) 18 logging.getLogger('').addHandler(console) 19 ################################################################################################### 20 21 logging.debug("This is debug message.") 22 logging.info("This is info message.") 23 logging.warn("This warning message.") 24 logging.error("This is error message.") 25 logging.critical("This is critical message.")輸出結果：
1 root : INFO This is info message. 2 root : WARNING This warning message. 3 root : ERROR This is error message. 4 root : CRITICAL This is critical message.輸出到文件中的內容：
1 Sat, 19 Nov 2016 00:27:17 re_module.py[line:20] DEBUG This is debug message. 2 Sat, 19 Nov 2016 00:27:17 re_module.py[line:21] INFO This is info message. 3 Sat, 19 Nov 2016 00:27:17 re_module.py[line:22] WARNING This warning message. 4 Sat, 19 Nov 2016 00:27:17 re_module.py[line:23] ERROR This is error message. 5 Sat, 19 Nov 2016 00:27:17 re_module.py[line:24] CRITICAL This is critical message.logging之日志回滾
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 from logging.handlers import RotatingFileHandler 6 7 ################################################################################################### 8 # 定義一個RotatingFileHandler，最多備份5個日志文件，每個日志文件最大10M 9 handler = RotatingFileHandler('mylog.log', maxBytes=10*1024*1024, backupCount=5) 10 handler.setLevel(logging.INFO) 11 formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') 12 handler.setFormatter(formatter) 13 logging.getLogger('').addHandler(handler) 14 ###################################################################################################logging有一個日志處理的主對象，其它處理方式都是通過addHandler添加進去的。
logging的幾種handle方式如下：
- logging.StreamHandler: 日志輸出到流，可以是sys.stderr、sys.stdout或者文件
- logging.FileHandler: 日志輸出到文件
- 日志回滾方式，實際使用時用RotatingFileHandler和TimedRotatingFileHandler
- logging.handlers.BaseRotatingHandler
- logging.handlers.RotatingFileHandler
- logging.handlers.TimedRotatingFileHandler
- logging.handlers.SocketHandler: 遠程輸出日志到TCP/IP sockets
- logging.handlers.DatagramHandler: 遠程輸出日志到UDP sockets
- logging.handlers.SMTPHandler: 遠程輸出日志到郵件地址
- logging.handlers.SysLogHandler: 日志輸出到syslog
- logging.handlers.NTEventLogHandler: 遠程輸出日志到Windows NT/2000/XP的事件日志
- logging.handlers.MemoryHandler: 日志輸出到內存中的制定buffer
- logging.handlers.HTTPHandler: 通過"GET"或"POST"遠程輸出到HTTP服務器
由于StreamHandler和FileHandler是常用的日志處理方式，所以直接包含在logging模塊中，而其他方式則包含在logging.handlers模塊中
通過logging.config模塊配置日志
logger.conf：
1 #logger.conf 2 ############################################### 3 [loggers] 4 keys=root,example01,example02 5 [logger_root] 6 level=DEBUG 7 handlers=hand01,hand02 8 [logger_example01] 9 handlers=hand01,hand02 10 qualname=example01 11 propagate=0 12 [logger_example02] 13 handlers=hand01,hand03 14 qualname=example02 15 propagate=0 16 ############################################### 17 [handlers] 18 keys=hand01,hand02,hand03 19 [handler_hand01] 20 class=StreamHandler 21 level=INFO 22 formatter=form02 23 args=(sys.stderr,) 24 [handler_hand02] 25 class=FileHandler 26 level=DEBUG 27 formatter=form01 28 args=('myapp.log', 'a') 29 [handler_hand03] 30 class=handlers.RotatingFileHandler 31 level=INFO 32 formatter=form02 33 args=('myapp.log', 'a', 10*1024*1024, 5) 34 ############################################### 35 [formatters] 36 keys=form01,form02 37 [formatter_form01] 38 format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s 39 datefmt=%a, %d %b %Y %H:%M:%S 40 [formatter_form02] 41 format=%(name)-12s: %(levelname)-8s %(message)s 42 datefmt=示例一：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 import logging.config 6 7 logging.config.fileConfig("logger.conf") 8 logger = logging.getLogger("example01") 9 10 logger.debug('This is debug message.') 11 logger.info('This is info message.') 12 logger.warn('This is warning message.')輸出結果：
1 example01 : INFO This is info message. 2 example01 : WARNING This is warning message.輸出文件內容：
1 Sat, 19 Nov 2016 00:54:02 re_module.py[line:10] DEBUG This is debug message. 2 Sat, 19 Nov 2016 00:54:02 re_module.py[line:11] INFO This is info message. 3 Sat, 19 Nov 2016 00:54:02 re_module.py[line:12] WARNING This is warning message.示例二：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import logging 5 import logging.config 6 7 logging.config.fileConfig("logger.conf") 8 logger = logging.getLogger("example02") 9 10 logger.debug('This is debug message.') 11 logger.info('This is info message.') 12 logger.warn('This is warning message.')輸出結果：
1 example02 : INFO This is info message. 2 example02 : WARNING This is warning message.輸出文件內容：
1 example02 : INFO This is info message. 2 example02 : WARNING This is warning message.logging是線程安全的
14) re 正則表達式
正則表達式是一個特殊的字符序列，他它能幫你方便的檢查一個字符串是否與某種模式匹配。
re 模塊使 Python 語言擁有全部的正則表達式功能。
compile 函數根據一個模式字符串和可選的標志參數生成一個正則表達式對象。該對象擁有一系列方法用于正則表達式匹配和替換。
re 模塊也提供了與這些方法功能完全一致的函數，這些函數使用一個模式字符串做為它們的第一個參數。
re.match 函數
re.match 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match() 就返回 none 。
函數語法：
re.match(pattern, string, flags=0)函數參數說明：
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| flags | 標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。 |
匹配成功 re.match 方法返回一個匹配的對象，否則返回None。
可以使用 group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
| group(num=0) | 匹配的整個表達式的字符串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組 |
| groups() | 返回一個包含所有小組字符串的元組，從 1 到 所含的小組號 |
實例1：
實例2：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import re 5 6 line = "Cats are smarter than dogs." 7 8 matchObj = re.match(r'(.*) are (.*) .*', line, re.M|re.I) 9 10 if matchObj: 11 print("matchObj.group():", matchObj.group()) 12 print("matchObj.group(1):", matchObj.group(1)) 13 print("matchObj.group(2):", matchObj.group(2)) 14 else: 15 print("No match!")輸出結果：
1 matchObj.group(): Cats are smarter than dogs. 2 matchObj.group(1): Cats 3 matchObj.group(2): smarter thanre.search 方法
re.search 掃描整個字符串并返回第一個成功的匹配。
函數語法：
re.search(pattern, string, flags=0)函數參數說明：
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| flags | 標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等 |
匹配成功 re.search 方法返回一個匹配的對象，否則返回None。
可以使用 group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
| group(num=0) | 匹配的整個表達式的字符串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組 |
| groups() | 返回一個包含所有小組字符串的元組，從 1 到 所含的小組號 |
實例1：
1 >>> import re 2 >>> re.search('www', 'www.cnblogs.com') 3 <_sre.SRE_Match object; span=(0, 3), match='www'> 4 >>> re.search('www', 'www.cnblogs.com').span() 5 (0, 3) 6 >>> re.search('com', 'www.cnblogs.com') 7 <_sre.SRE_Match object; span=(12, 15), match='com'> 8 >>> re.search('com', 'www.cnblogs.com').span() 9 (12, 15)實例2：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import re 5 6 line = "Cats are smarter than dogs." 7 8 searchObj = re.search(r'(.*) are (.*) .*', line, re.M|re.I) 9 10 if searchObj: 11 print("searchObj.group():", searchObj.group()) 12 print("searchObj.group(1):", searchObj.group(1)) 13 print("searchObj.group(2):", searchObj.group(2)) 14 else: 15 print("Nothing found!")輸出結果：
1 searchObj.group(): Cats are smarter than dogs. 2 searchObj.group(1): Cats 3 searchObj.group(2): smarter thanre.match與re.search的區別
re.match 只匹配字符串的開始，如果字符串開始不符合正則表達式，則匹配失敗，函數返回None；而 re.search 匹配整個字符串，直到找到一個匹配。
實例：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import re 5 6 line = "Cats are smarter than dogs." 7 8 matchObj = re.match(r'dogs', line, re.M|re.I) 9 if matchObj: 10 print("match --> matchObj.group():", matchObj.group()) 11 else: 12 print("No match!") 13 14 searchObj = re.search(r'dogs', line, re.M|re.I) 15 if searchObj: 16 print("search --> searchObj.group():", searchObj.group()) 17 else: 18 print("No match!")輸出結果：
1 No match! 2 search --> searchObj.group(): dogs檢索和替換
Python 的 re 模塊提供了re.sub 用于替換字符串中的匹配項。
語法：
re.sub(pattern, repl, string, count=0, flags=0)參數：
- pattern : 正則中的模式字符串。
- repl : 替換的字符串，也可為一個函數。
- string : 要被查找替換的原始字符串。
- count : 模式匹配后替換的最大次數，默認 0 表示替換所有的匹配。
實例：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import re 5 6 phone = "2004-959-559 # 這是一個國外電話號碼" 7 8 # 刪除字符串中的 Python 注釋 9 num = re.sub(r'#.*$', "", phone) 10 print("電話號碼是:", num) 11 12 # 刪除非數字(-)的字符串 13 num = re.sub(r'\D', "", phone) 14 print("電話號碼是:", num)輸出結果：
1 電話號碼是: 2004-959-559 2 電話號碼是: 2004959559當 repl 參數是一個函數時：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import re 5 6 7 # 將匹配的數字乘于 2 8 def double(matched): 9 value = int(matched.group('value')) 10 return str(value * 2) 11 12 s = 'A23G4HFD567' 13 print(re.sub('(?P<value>\d+)', double, s))輸出結果：
1 A46G8HFD1134正則表達式修飾符 - 可選標志
正則表達式可以包含一些可選標志修飾符來控制匹配的模式。修飾符被指定為一個可選的標志。多個標志可以通過按位 OR(|) 它們來指定。如 re.I | re.M 被設置成 I 和 M 標志：
| re.I | 使匹配對大小寫不敏感 |
| re.L | 做本地化識別（locale-aware）匹配 |
| re.M | 多行匹配，影響 ^ 和 $ |
| re.S | 使 . 匹配包括換行在內的所有字符 |
| re.U | 根據Unicode字符集解析字符。這個標志影響 \w, \W, \b, \B. |
| re.X | 該標志通過給予你更靈活的格式以便你將正則表達式寫得更易于理解。 |
正則表達式模式
模式字符串使用特殊的語法來表示一個正則表達式：
字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配同樣的字符串。
多數字母和數字前加一個反斜杠時會擁有不同的含義。
標點符號只有被轉義時才匹配自身，否則它們表示特殊的含義。
反斜杠本身需要使用反斜杠轉義。
由于正則表達式通常都包含反斜杠，所以最好使用原始字符串來表示它們。模式元素(如 r'/t'，等價于'//t')匹配相應的特殊字符。
下表列出了正則表達式模式語法中的特殊元素。如果你使用模式的同時提供了可選的標志參數，某些模式元素的含義會改變。
| ^ | 匹配字符串的開頭 |
| $ | 匹配字符串的末尾 |
| . | 匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字符 |
| [...] | 用來表示一組字符,單獨列出：[amk] 匹配 'a'，'m'或'k' |
| [^...] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符 |
| re* | 匹配0個或多個的表達式 |
| re+ | 匹配1個或多個的表達式 |
| re? | 匹配0個或1個由前面的正則表達式定義的片段，非貪婪方式 |
| re{n} | ?精確匹配n個前面表達式 |
| re{n,} | 精確匹配n個前面表達式 |
| re{n, m} | 匹配 n 到 m 次由前面的正則表達式定義的片段，貪婪方式 |
| a|b | 匹配a或b |
| (re) | G匹配括號內的表達式，也表示一個組 |
| (?imx) | 正則表達式包含三種可選標志：i, m, 或 x ，只影響括號中的區域 |
| (?-imx) | 正則表達式關閉 i, m, 或 x 可選標志，只影響括號中的區域。 |
| (?: re) | 類似 (...), 但是不表示一個組 |
| (?imx: re) | 在括號中使用i, m, 或 x 可選標志 |
| (?-imx: re) | 在括號中不使用i, m, 或 x 可選標志 |
| (?#...) | 注釋. |
| (?= re) | 前向肯定界定符，如果所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，否則失敗，但一旦所含表達式已經嘗試，匹配引擎根本沒有提高；模式的剩余部分還要嘗試界定符的右邊 |
| (?! re) | 前向否定界定符，與肯定界定符相反；當所含表達式不能在字符串當前位置匹配時成功 |
| (?> re) | 匹配的獨立模式，省去回溯 |
| \w | 匹配字母數字及下劃線 |
| \W | 匹配非字母數字及下劃線 |
| \s | 匹配任意空白字符，等價于 [\t\n\r\f]. |
| \S | 匹配任意非空字符 |
| \d | 匹配任意數字，等價于 [0-9]. |
| \D | 匹配任意非數字 |
| \A | 匹配字符串開始 |
| \Z | 匹配字符串結束，如果是存在換行，只匹配到換行前的結束字符串。c |
| \z | 匹配字符串結束 |
| \G | 匹配最后匹配完成的位置 |
| \b | 匹配一個單詞邊界，也就是指單詞和空格間的位置，例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er' |
| \B | 匹配非單詞邊界，'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er' |
| \n, \t, 等. | 匹配一個換行符，匹配一個制表符等 |
| \1...\9 | 匹配第n個分組的子表達式 |
| \10 | 匹配第n個分組的子表達式，如果它經匹配。否則指的是八進制字符碼的表達式 |
正則表達式實例
字符匹配
| python | 匹配 "python". |
字符類
| [Pp]ython | 匹配 "Python" 或 "python" |
| rub[ye] | 匹配 "ruby" 或 "rube" |
| [aeiou] | 匹配中括號內的任意一個字母 |
| [0-9] | 匹配任何數字。類似于 [0123456789] |
| [a-z] | 匹配任何小寫字母 |
| [A-Z] | 匹配任何大寫字母 |
| [a-zA-Z0-9] | 匹配任何字母及數字 |
| [^aeiou] | 除了aeiou字母以外的所有字符 |
| [^0-9] | 匹配除了數字外的字符 |
特殊字符類
| . | 匹配除 "\n" 之外的任何單個字符。要匹配包括 '\n' 在內的任何字符，請使用象 '[.\n]' 的模式 |
| \d | 匹配一個數字字符，等價于 [0-9] |
| \D | 匹配一個非數字字符，等價于 [^0-9] |
| \s | 匹配任何空白字符，包括空格、制表符、換頁符等等，等價于 [ \f\n\r\t\v] |
| \S | 匹配任何非空白字符，等價于 [^ \f\n\r\t\v] |
| \w | 匹配包括下劃線的任何單詞字符，等價于'[A-Za-z0-9_]' |
| \W | 匹配任何非單詞字符，等價于 '[^A-Za-z0-9_]' |
本節作業
開發一個簡單的python計算器
?
hint:
re.search(r'\([^()]+\)',s).group()
'(-40/5)'
轉載于:https://www.cnblogs.com/RUReady/p/6039800.html
總結
以上是生活随笔為你收集整理的Day05 - Python 常用模块的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： check $m2_home envir
- 下一篇： (转载)jQuery 1.6 源码学习（