Day05 - Python 經常使用模塊

時間 2019-11-12

原文原文鏈接

1. 模塊簡介

模塊就是一個保存了 Python 代碼的文件。模塊能定義函數，類和變量。模塊裏也能包含可執行的代碼。python

模塊也是 Python 對象，具備隨機的名字屬性用來綁定或引用。linux

下例是個簡單的模塊support.pygit

1 def print_func( par ):
2      print("Hello : ", par)
3      return

1）import 語句程序員

想使用 Python 源文件，只需在另外一個源文件裏執行 import 語句，語法以下：正則表達式

import module1[, module2[,... moduleN]

當解釋器遇到 import 語句，若是模塊在當前的搜索路徑就會被導入。shell

搜索路徑是一個解釋器會先進行搜索的全部目錄的列表。如想要導入模塊 support.py ，須要把命令放在腳本的頂端：apache

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3  
4 # 導入模塊
5 import support
6  
7 # 如今能夠調用模塊裏包含的函數了
8 support.print_func("Zara")

輸出結果：json

1 Hello : Zara

一個模塊只會被導入一次，無論你執行了多少次 import ，這樣能夠防止導入模塊被一遍又一遍地執行。vim

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 2001

7）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.0

python中時間日期格式化符號：

%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 30

time 模塊

time 模塊包含如下內置函數

time.altzone 返回格林威治西部的夏令時地區的偏移秒數（與UTC的時間差）。若是該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啓用地區才能使用

1 >>> time.altzone
2 -32400

time.asctime([tupletime]) 接受時間元組並返回一個可讀的形式爲 'Mon Nov 14 21:45:06 2016' 的24個字符的字符串

1 >>> time.asctime(time.localtime())
2 'Mon Nov 14 21:45:06 2016'

time.clock() 用以浮點數計算的秒數返回當前的CPU時間。用來衡量不一樣程序的耗時，比time.time()更有用

1 >>> time.clock()
2 2.83648743983101e-06

time.ctime([secs]) 做用至關於asctime(localtime(secs))，未給參數至關於asctime()

1 >>> time.ctime()
2 'Mon Nov 14 21:48:23 2016'

time.gmtime([secs]) 接收時間輟（1970紀元後通過的浮點秒數）並返回格林威治天文時間下的時間元組t。注：t.tm_isdst 始終爲0

1 >>> time.gmtime()
2 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=13, tm_min=49, tm_sec=3, tm_wday=0, tm_yday=319, tm_isdst=0)

time.localtime([secs]) 接收時間輟（1970紀元後通過的浮點秒數）並返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決於當地當時是否是夏令時）

1 >>> time.localtime()
2 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=21, tm_min=50, tm_sec=10, tm_wday=0, tm_yday=319, tm_isdst=0)

time.mktime(tupletime) 接受時間元組並返回時間輟（1970紀元後通過的浮點秒數）

1 >>> time.mktime(time.localtime())
2 1479131695.0

time.sleep(secs) 推遲調用線程的運行，secs指秒數

1 >>> print("Start : %s" % time.ctime())
2 Start : Mon Nov 14 21:59:15 2016
3 >>> time.sleep(5)
4 >>> print("End : %s" % time.ctime())
5 End : Mon Nov 14 21:59:20 2016

time.strftime(fmt[,tupletime]) 接收以時間元組，並返回以可讀字符串表示的當地時間，格式由fmt決定

1 >>> time.strftime("%b %d %Y %H:%M:%S", time.gmtime())
2 'Nov 14 2016 14:01:42'

time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根據fmt的格式把一個時間字符串解析爲時間元組

1 >>> struct_time = time.strptime("30 Nov 16", "%d %b %y")
2 >>> print(struct_time)
3 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

time.time( ) 返回當前時間的時間戳（1970紀元後通過的浮點秒數）

1 >>> time.time()
2 1479132293.9487014

時間轉換

日曆（Calendar）模塊

此模塊的函數都是日曆相關的，例如打印某月的字符月曆。

星期一是默認的每週第一天，星期天是默認的最後一天。

更改設置需調用 calendar.setfirstweekday() 函數。

模塊包含了如下內置函數：

calendar.calendar(year,w=2,l=1,c=6) 返回一個多行字符串格式的year年年曆，3個月一行，間隔距離爲c，每日寬度間隔爲w字符，每行長度爲21* W+18+2* C，l是每星期行數

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.calendar(2016, w=2, l=1, c=6))

輸出結果：

 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，即星期一。

1 >>> calendar.firstweekday()
2 0

calendar.isleap(year) 是閏年返回True，不然爲false。

1 >>> calendar.isleap(2016)
2 True

calendar.leapdays(y1,y2) 返回在Y1，Y2兩年之間的閏年總數。

1 >>> calendar.leapdays(2000, 2016)
2 4

calendar.month(year,month,w=2,l=1) 返回一個多行字符串格式的 year 年 month 月日曆，兩行標題，一週一行，每日寬度間隔爲 w 字符，每行的長度爲7* w+6，l是每星期的行數

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.month(2016, 11, w=2, l=1))

輸出結果：

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.monthcalendar(2016, 11)
[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], [21, 22, 23, 24, 25, 26, 27], [28, 29, 30, 0, 0, 0, 0]]

calendar.monthrange(year,month) 返回兩個整數。第一個是該月的星期幾的日期碼，第二個是該月的日期碼，日從0（星期一）到6（星期日），月從1到12

1 >>> calendar.monthrange(2016, 11)
2 (1, 30)

calendar.prcal(year,w=2,l=1,c=6) 至關於 print(calendar.calendar(year,w,l,c))

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.prcal(2016, w=2, l=1, c=6))

輸出結果：

                                  2016

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7          1  2  3  4  5  6
 4  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 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3                         1             1  2  3  4  5
 4  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 30
                          30 31

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7                1  2  3  4
 4  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 30

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                1  2  3  4
 3  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
31

None

calendar.prmonth(year,month,w=2,l=1) 至關於 print(calendar.calendar(year，w，l，c))

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 calendar.prmonth(2016, 11, w=2, l=1)

輸出結果：

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（星期日）

1 >>> calendar.setfirstweekday(2)
2 >>> calendar.firstweekday( )
3 2

calendar.timegm(tupletime) 和 time.gmtime 相反：接受一個時間元組形式，返回該時刻的時間輟（1970紀元後通過的浮點秒數）

1 >>> calendar.timegm(time.localtime())
2 1479164045

calendar.weekday(year,month,day) 返回給定日期的日期碼。0（星期一）到6（星期日）。月份爲 1（一月）到 12（12月）

1 >>> calendar.weekday(2016,11,14)
2 0

datetime 模塊

datetime.datetime.now() 返回當前時間

1 >>> print(datetime.datetime.now())
2 2016-11-14 23:02:30.931429

datetime.date.fromtimestamp(time.time()) 時間戳直接轉成日期格式

1 >>> print(datetime.date.fromtimestamp(time.time()))
2 2016-11-14

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分

 1 >>> print(datetime.datetime.now())
 2 2016-11-14 23:05:03.731169
 3 >>> print(datetime.datetime.now() + datetime.timedelta(3)) # 當前時間+3天
 4 2016-11-17 23:05:03.743169
 5 >>> print(datetime.datetime.now() + datetime.timedelta(-3)) # 當前時間-3天
 6 2016-11-11 23:05:03.755170
 7 >>> print(datetime.datetime.now() + datetime.timedelta(hours=3)) # 當前時間+3小時
 8 2016-11-15 02:05:03.765171
 9 >>> print(datetime.datetime.now() + datetime.timedelta(minutes=30)) # 當前時間+30分
10 2016-11-14 23:35:04.858233

replace(minute, hour) 時間替換

1 >>> c_time = datetime.datetime.now()
2 >>> print(c_time)
3 2016-11-14 23:07:37.762979
4 >>> print(c_time.replace(minute=3, hour=2))
5 2016-11-14 02:03:37.762979

2）random

Python中的random模塊用於生成隨機數

random.random()

用於生成一個0到1的隨機浮點數: 0 <= n < 1.0

1 >>> import random
2 >>> random.random()
3 0.99107532292498801

random.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.344944314032574

random.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 HY5YNN

3）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 0

os.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 True

os.path.isabs(path)

若是path是絕對路徑，返回True

1 >>> import os
2 >>> os.path.isabs('/home/test/test1')
3 True
4 >>> os.path.isabs('test1')
5 False

os.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 False

os.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 False

os.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.6452732

os.path.getmtime(path)

返回path所指向的文件或者目錄的最後修改時間

1 >>> import os
2 >>> os.listdir('.')
3 ['test2', 'hello.txt']
4 >>> os.path.getmtime('hello.txt')
5 1478588652.6452732

os.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 4096

4）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 argv1

sys.exit(n)

執行到主程序末尾，解釋器自動退出，可是若是須要中途退出程序，能夠調用sys.exit函數，帶有一個可選的整數參數返回給調用它的程序，表示你能夠在主程序中捕獲對sys.exit的調用。（0是正常退出，其餘爲異常）

1 >>> import sys
2 >>> sys.exit(1)
3 [root@test ~]$ echo $?
4 1

sys.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 9223372036854775807

sys.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:7

val = 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 Code

shutil.copyfile(src, dst)
拷貝文件

View Code

shutil.copymode(src, dst)
僅拷貝權限。內容、組、用戶均不變

View Code

shutil.copystat(src, dst)
拷貝狀態的信息，包括：mode bits, atime, mtime, flags

View Code

shutil.copy(src, dst)
拷貝文件和權限

View Code

shutil.copy2(src, dst)
拷貝文件和狀態信息

View Code

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
遞歸的去拷貝文件

例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

View Code

shutil.rmtree(path[, ignore_errors[, onerror]])
遞歸的去刪除文件

View Code

shutil.move(src, dst)
遞歸的去移動文件

View Code

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對象

 
         #將 /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' 
         )

View Code

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()：對數據進行解碼

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()

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：

1 >>> import re
2 >>> re.match('www', 'www.chblogs.com') # 在起始位置匹配
3 <_sre.SRE_Match object; span=(0, 3), match='www'>
4 >>> re.match('www', 'www.chblogs.com').span() # 在起始位置匹配
5 (0, 3)
6 >>> re.match('com', 'www.chblogs.com') # 不在起始位置匹配
7 >>>

實例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 than

re.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 than

re.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計算器

實現加減乘除及拓號優先級解析
用戶輸入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等相似公式後，必須本身解析裏面的(),+,-,*,/符號和公式(不能調用eval等相似功能偷懶實現)，運算後得出結果，結果必須與真實的計算器所得出的結果一致

hint:

re.search(r'$[^()]+$',s).group()

'(-40/5)'