模組，用一砣程式碼實現了某個功能的程式碼集合。

類似於函數語言程式設計和麵向過程程式設計，函數語言程式設計則完成一個功能，其他程式碼用來呼叫即可，提供了程式碼的重用性和程式碼間的耦合。而對於一個複雜的功能來，可能需要多個函式才能完成（函式又可以在不同的.py檔案中），n個 .py 檔案組成的程式碼集合就稱為模組。

如：os 是系統相關的模組；file是檔案操作相關的模組

模組分為三種：

自定義模組
第三方模組
內建模組

自定義模組

1、定義模組：

情景一：

情景二：

情景三：

2、匯入模組：

Python之所以應用越來越廣泛，在一定程度上也依賴於其為程式設計師提供了大量的模組以供使用，如果想要使用模組，則需要匯入。匯入模組有一下幾種方法：

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename 
from module.xx.xx import *

匯入模組其實就是告訴Python直譯器去解釋那個py檔案

匯入一個py檔案，直譯器解釋該py檔案
匯入一個包，直譯器解釋該包下的 __init__.py 檔案 【py2.7】

那麼問題來了，匯入模組時是根據那個路徑作為基準來進行的呢？即：sys.path

print sys.path

#如果sys.path路徑列表沒有你想要的路徑，可以通過 sys.path.append
 
('路徑') 新增。

import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path)

模組介紹

sys模組：
用於提供對Python直譯器相關的操作

sys.argv    可以接收外部傳入的引數,傳入引數變為列表的形式

sys.path    檢視模組預設地址

sys.path.append("E:\\")可以新增模組的搜尋地址

    sys.path.append("D:\python"
 
)    #在D盤下找到python找模組

sys.exit(n)        退出程式，正常退出時exit(0)

sys.version        獲取Python解釋程式的版本資訊

sys.maxint         最大的Int值

sys.platform       返回作業系統平臺名稱

sys.stdin          輸入相關

sys.stdout         輸出相關
    sys.stdout.flush()  輸出清空
    sys.stdout.write(變數或文字) 不會換行直接寫

sys.stderror       錯誤相關

sys舉例–進度條：

import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r = '\r%d%%' % (rate_num, )     #\r 回到當前行的首個位置 就是把內容抹去
    sys.stdout.write(r)
    sys.stdout.flush()

if __name__ == '__main__':
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)

sys舉例–進度條 帶進度的：

import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r = '\r%s%d%%' % ("="*num,rate_num)     #\r 回到當前行的首個位置 就是把內容抹去
    sys.stdout.write(r)
    sys.stdout.flush()

if __name__ == '__main__':
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)

os模組：
用於提供系統級別的操作

os.path.abspath()   #獲取絕對路徑 #路徑的作用主要用於程式跨機器和平臺
    os.path.abspath(__file__)

os.path.dirname()   #獲取檔案的上級目錄
    os.path.dirname(os.path.abspath(__file__))  #找到上一級目錄    
    sys.path.append()os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
        #找到/bin下內容的主目錄，主要用於在其他機器也能正常執行 必加！！！
        sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

os.getcwd()                 獲取當前工作目錄，即當前python指令碼工作的目錄路徑

os.chdir("dirname")         改變當前指令碼工作目錄；相當於shell下cd

os.curdir                   返回當前目錄: ('.')

os.pardir                   獲取當前目錄的父目錄字串名：('..')

os.makedirs('dir1/dir2')    可生成多層遞迴目錄

os.removedirs('dirname1')   若目錄為空，則刪除，並遞迴到上一級目錄，如若也為空，則刪除，依此類推

os.mkdir('dirname')         生成單級目錄；相當於shell中mkdir dirname

os.rmdir('dirname')         刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname

os.listdir('dirname')       列出指定目錄下的所有檔案和子目錄，包括隱藏檔案，並以列表方式列印

os.remove()                 刪除一個檔案

os.rename("oldname","new")  重新命名檔案/目錄

os.stat('path/filename')    獲取檔案/目錄資訊,會用檔案大小

os.sep                      作業系統特定的路徑分隔符，win下為"\\",Linux下為"/"

os.linesep                  當前平臺使用的行終止符，win下為"\t\n",Linux下為"\n"

os.pathsep                  用於分割檔案路徑的字串

os.name                     字串指示當前使用平臺。win->'nt'; Linux->'posix'

os.system("bash command")   執行shell命令，直接顯示

os.environ                  獲取系統環境變數

os.path.abspath(path)       必會！！返回path規範化的絕對路徑

os.path.split(path)         將path分割成目錄和檔名二元組返回

os.path.dirname(path)       必會！！返回path的目錄。其實就是
os.path.split(path)的第一個元素

os.path.basename(path)      返回path最後的檔名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素

os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)         如果path是絕對路徑，返回True

os.path.isfile(path)        如果path是一個存在的檔案，返回True。否則返回False

os.path.isdir(path)         如果path是一個存在的目錄，則返回True。否則返回False

os.path.join(path1[, path2[, ...]]) 將多個路徑組合後返回，第一個絕對路徑之前的引數將被忽略，這個必會，日後用途非常廣泛！

os.path.getatime(path)      返回path所指向的檔案或者目錄的最後存取時間

os.path.getmtime(path)      返回path所指向的檔案或者目錄的最後修改時間

hashlib加密模組：
用於加密相關的操作，代替了md5模組和sha模組，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 演算法

import hashlib
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())

######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())


# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

以上加密演算法雖然依然非常厲害，但時候存在缺陷，即：通過撞庫可以反解。所以，有必要對加密演算法中新增自定義key再來做加密。

import hashlib

# ######## md5 ########

hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

re模組：
正則表示式處理模組

flags: 便宜標誌位，用於修改正則的表示式的匹配方式，如：是否區分大小寫，多行匹配等等

re.findall() 將結果分別儲存列表中的元素中

refindall("規則","要搜尋的內容")

re.match()  只匹配字串的啟示位置，並將結果返回成物件的形式通過呼叫物件的方法獲得具體的值
    re.match("規則","要搜尋的內容",flags=0)

start() 返回匹配開始的位置

end()   返回匹配結束的位置

span()  返回一個元祖包含匹配(開始,結束)的位置

group() 返回re整個匹配的字串，可以一次輸入多個組號，對應組號匹配的字串

re.search() 匹配字串內任意字元，並將第一個匹配結果返回成物件，通過呼叫物件的方法獲得值，物件的方法同match

re.search("規則","要搜尋的內容",flags=0)

re.finditer()   同findall一樣，但finditer返回的是物件

re.sub()        匹配替換
    re.sub("模式","替換的新字串","要被搜尋的字串",max)   max為數字，意思是替換的最大次數   
re.split()  對字串做分割

re.split("\d+","one1two2three3four4")   #返回：['one', 'two', 'three', 'four', '']

# 無分組
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r)

# 有分組
origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)
print(r1)
r2 = re.split("(al(ex))", origin, 1)
print(r2)

re.compile() 將模式封裝成物件，然後呼叫物件可以批量匹配字串
    text = "sad123oo123dff"
    regex=re.compile(r'\w*oo\w*)    #先把模式封裝成regex的物件，r的意思是讓python直譯器不轉譯，將原生字元直接傳送給函式
    print regex.findall(text)       #查詢text裡oo字元    

正則分組：
去已經提取到的資料中再提取資料

match和search分組：
r = re.match("h(\w+).*(?P<name>\d)$", origin)
print(r.group())     # 獲取匹配到的所有結果
print(r.groups())    # 獲取模型中匹配到的分組結果
print(r.groupdict()) # 獲取模型中匹配到的分組中所有執行了key的組
多層括號會從外層逐層取值

正則表示式基礎用法:
元字元

.   單個任意字元
^   鎖定起始位置
$  鎖定結束位置
*   匹配其前面的字元任意次

a*b  的含義是b前面可以有任意一個a
    .*任意長度的任意字元


+   必須最少有一個字元
    a+b ab之間至少有一個字元


{}  規定ab之間可以有多少個字元可以匹配

a.{1，5}b        指的是ab之間可以匹配1-5個字元

a.{1，}b     任意多次

a.{，5}b     從0次開始
    如果不加. 就會重複a

[]  字元範圍，元字元在中括號裡不起任何作用，除了-(範圍),^(非),\（轉義）

a[bc]d  可以匹配acd、abd

[a-z]   可以匹配a-z

[a-z]+  可以匹配個a-z

[^f]    可以比配不是f的任意一個字元，相當於否定

|       或者
    C|cat  匹配是C或者Cat
    (C|c)at 匹配是Cat或者cat   

()      分組
        a（ab）*c 可以匹配a和c之間出現任意一次ab

\   第一個功能是轉譯，跟後面字幕實現特殊功能
\d  匹配任何十進位制數(後面是相當於)        [0-9]
\D  匹配任意非數字字元：              [^0-9]
\s  匹配任何空白字元                    [\t\n\r\f\v]
\S  匹配任何非空白字元                   [^\t\n\r\f\v]
\w  匹配任何字母數字字元              [a-zA-Z0-9_]
\W  匹配任何非字母數字字元             [a-zA-Z0-9_]
\b  匹配一個單詞（連續字幕、數字、下劃線組成的字串）邊界，以空格、非字幕數字都可以匹配

#IP：
    ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$

#手機號：
    ^1[3|4|5|8][0-9]\d{8}$

#郵箱：
    [a-zA-Z0-9_-][email protected][a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

configparser模組：
用於處理特定格式的檔案，其本質上是利用open來操作檔案。

只支援以下兩種註釋方法：
# 註釋1
; 註釋2

[section1] # 節點
k1 = v1    # 值
k2:v2       # 值

[section2] # 節點
k1 = v1    # 值

1、獲取所有節點

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.sections()
print(ret)

2、獲取指定節點下所有的鍵值對

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.items('section1')
print(ret)

3、獲取指定節點下所有的鍵

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.options('section1')
print(ret)

4、獲取指定節點下指定key的值

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8') 
v = config.get('section1', 'k1')
# v = config.getint('section1', 'k1')       #可以將數值轉換成int
# v = config.getfloat('section1', 'k1')
# v = config.getboolean('section1', 'k1')
print(v)

5、檢查、刪除、新增節點

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
# 檢查
has_sec = config.has_section('section1')
print(has_sec)      #返回Ture和False
# 新增節點
config.add_section("SEC_1")
config.write(open('xxxooo', 'w'))
# 刪除節點
config.remove_section("SEC_1")
config.write(open('xxxooo', 'w'))

6、檢查、刪除、設定指定組內的鍵值對

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
# 檢查
has_opt = config.has_option('section1', 'k1')
print(has_opt)
# 刪除
config.remove_option('section1', 'k1')
config.write(open('xxxooo', 'w'))
# 設定
config.set('section1', 'k10', "123")
config.write(open('xxxooo', 'w'))

XML模組：

引用模組：
from xml.etree import ElementTree as ET

1 解析XML：

#利用ElementTree.XML將字串解析成xml物件
from xml.etree import ElementTree as ET

# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

#利用ElementTree.parse將檔案直接解析成xml物件:
from xml.etree import ElementTree as ET

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

2、操作XML ：
XML格式型別是節點巢狀節點，對於每一個節點均有以下功能，以便對當前節點進行操作

Example form:
<tag attrib>text</tag>

salf    相當於Element的節點(node)名稱
tag     標籤
attrib  屬性
text    文字
salf.tag,salf.attrib,salf.text

def makeelement(self, tag, attrib): 
#建立一個新節點

def copy(self):                     
#同列表複製

def append(self, subelement):       
#為當前節點追加一個子節點

def extend(self, elements):         
#為當前節點擴充套件 n 個子節點

def insert(self, index, subelement):
#在當前節點的子節點中插入某個節點，即：為當前節點建立子節點，然後插入指定位置

def remove(self, subelement):
#在當前節點在子節點中刪除某個節點

def getchildren(self):
#獲取所有的子節點（廢棄）

def find(self, path, namespaces=None):
#獲取第一個尋找到的子節點

def findtext(self, path, default=None, namespaces=None):
#獲取第一個尋找到的子節點的內容

def findall(self, path, namespaces=None):
#獲取所有的子節點

def iterfind(self, path, namespaces=None):
#獲取所有指定的節點，並建立一個迭代器（可以被for迴圈）

def clear(self):
#清空節點

def get(self, key, default=None):
#獲取當前節點的屬性值

def set(self, key, value):
#為當前節點設定屬性值

def keys(self):
#獲取當前節點的所有屬性的 key

def items(self):
#獲取當前節點的所有屬性值，每個屬性都是一個鍵值對

def iter(self, tag=None):
#在當前節點的子孫中根據節點名稱尋找所有指定的節點，並返回一個迭代器（可以被for迴圈）。

def itertext(self):
#在當前節點的子孫中根據節點名稱尋找所有指定的節點的內容，並返回一個迭代器（可以被for迴圈）。 

由於 每個節點 都具有以上的方法，並且在上一步驟中解析時均得到了root（xml檔案的根節點），so 可以利用以上方法進行操作xml檔案

a. 遍歷XML文件的所有內容

############ 解析方式一 ############
# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

############ 解析方式二 ############
# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

### 操作
# 頂層標籤
print(root.tag)

# 遍歷XML文件的第二層
for child in root:
    # 第二層節點的標籤名稱和標籤屬性
    print(child.tag, child.attrib)
    # 遍歷XML文件的第三層
    for i in child:
        # 第二層節點的標籤名稱和內容
        print(i.tag,i.text)

b、遍歷XML中指定的節點

rom xml.etree import ElementTree as ET
############ 解析方式一 ############
"""
# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)
"""
############ 解析方式二 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

### 操作

# 頂層標籤
print(root.tag)

# 遍歷XML中所有的year節點
for node in root.iter('year'):

# 節點的標籤名稱和內容
print(node.tag, node.text)

c、修改節點內容
由於修改的節點時，均是在記憶體中進行，其不會影響檔案中的內容。所以，如果想要修改，則需要重新將記憶體中的內容寫到檔案。

#解析字串方式，修改，儲存
from xml.etree import ElementTree as ET
############ 解析方式一 ############     

# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

############ 操作 ############

# 頂層標籤
print(root.tag)

# 迴圈所有的year節點
for node in root.iter('year'):
# 將year節點中的內容自增一
new_year = int(node.text) + 1
node.text = str(new_year)

# 設定屬性
node.set('name', 'alex')
node.set('age', '18')
# 刪除屬性
del node.attrib['name']
############ 儲存檔案 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')

#解析檔案方式，修改，儲存
from xml.etree import ElementTree as ET
############ 解析方式二 ############ 

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

############ 操作 ############

# 頂層標籤
print(root.tag)

# 迴圈所有的year節點
for node in root.iter('year'):
    # 將year節點中的內容自增一
    new_year = int(node.text) + 1
    node.text = str(new_year)

    # 設定屬性
    node.set('name', 'alex')
    node.set('age', '18')
    # 刪除屬性
    del node.attrib['name']


############ 儲存檔案 ############
tree.write("newnew.xml", encoding='utf-8')

d、刪除節點

#解析字串方式開啟，刪除，儲存
from xml.etree import ElementTree as ET
############ 解析字串方式開啟 ############
# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)
############ 操作 ############
# 頂層標籤
print(root.tag)

# 遍歷data下的所有country節點
for country in root.findall('country'):
    # 獲取每一個country節點下rank節點的內容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 刪除指定country節點
        root.remove(country)
############ 儲存檔案 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')

#解析檔案方式開啟，刪除，儲存
from xml.etree import ElementTree as ET
############ 解析檔案方式 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

############ 操作 ############

# 頂層標籤
print(root.tag)

# 遍歷data下的所有country節點
for country in root.findall('country'):
    # 獲取每一個country節點下rank節點的內容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 刪除指定country節點
        root.remove(country)

############ 儲存檔案 ############
tree.write("newnew.xml", encoding='utf-8')

3、建立XML文件：

#第一種 基礎
from xml.etree import ElementTree as ET
# 建立根節點
root = ET.Element("famliy")
# 建立節點大兒子
son1 = ET.Element('son', {'name': '兒1'})
# 建立小兒子
son2 = ET.Element('son', {"name": '兒2'})
# 在大兒子中建立兩個孫子
grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson2 = ET.Element('grandson', {'name': '兒12'})
son1.append(grandson1)
son1.append(grandson2)
# 把兒子新增到根節點中
root.append(son1)
root.append(son1)
tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

#第二種 使用makeelement
from xml.etree import ElementTree as ET
# 建立根節點

root = ET.Element("famliy")
# 建立大兒子

# son1 = ET.Element('son', {'name': '兒1'})
son1 = root.makeelement('son', {'name': '兒1'})
# 建立小兒子

# son2 = ET.Element('son', {"name": '兒2'})
son2 = root.makeelement('son', {"name": '兒2'})
# 在大兒子中建立兩個孫子

# grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson1 = son1.makeelement('grandson', {'name': '兒11'})
# grandson2 = ET.Element('grandson', {'name': '兒12'})
grandson2 = son1.makeelement('grandson', {'name': '兒12'})
son1.append(grandson1)
son1.append(grandson2)
# 把兒子新增到根節點中

root.append(son1)
root.append(son1)
tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

#第三種 使用SubElement
from xml.etree import ElementTree as ET
# 建立根節點

root = ET.Element("famliy")
# 建立節點大兒子

son1 = ET.SubElement(root, "son", attrib={'name': '兒1'})
# 建立小兒子

son2 = ET.SubElement(root, "son", attrib={"name": "兒2"})
# 在大兒子中建立一個孫子

grandson1 = ET.SubElement(son1, "age", attrib={'name': '兒11'})
grandson1.text = '孫子'
et = ET.ElementTree(root)  #生成文件物件
et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False)

4、建立XML帶有縮排：
由於原生儲存的XML時預設無縮排，如果想要設定縮排的話， 需要修改儲存方式

rom xml.etree import ElementTree as ET
from xml.dom import minidom
def prettify(elem):
    #將節點轉換成字串，並新增縮排。
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="\t")
# 建立根節點
root = ET.Element("famliy")

# 建立大兒子
# son1 = ET.Element('son', {'name': '兒1'})
son1 = root.makeelement('son', {'name': '兒1'})

# 建立小兒子
# son2 = ET.Element('son', {"name": '兒2'})
son2 = root.makeelement('son', {"name": '兒2'})

# 在大兒子中建立兩個孫子
# grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson1 = son1.makeelement('grandson', {'name': '兒11'})
# grandson2 = ET.Element('grandson', {'name': '兒12'})
grandson2 = son1.makeelement('grandson', {'name': '兒12'})

son1.append(grandson1)
son1.append(grandson2)

# 把兒子新增到根節點中
root.append(son1)
root.append(son1)

raw_str = prettify(root)

f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()

5、其他技巧
tree.write 增加引數，xml_declaration=True 即可輸出帶有頭部標識的xml

shutil模組：
高階的 檔案、資料夾、壓縮包 處理模組

shutil.copyfileobj(fsrc, fdst[, length])        #將檔案內容拷貝到另一個檔案中
    shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)                       #拷貝檔案
    shutil.copyfile('f1.log', 'f2.log')

shutil.copymode(src, dst)                       #僅拷貝許可權。內容、組、使用者均不變
    shutil.copymode('f1.log', 'f2.log')

shutil.copystat(src, dst)                       #僅拷貝狀態的資訊，包括：mode bits, atime, mtime, flags
    shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)  #遞迴的去拷貝資料夾
    shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

shutil.rmtree(path[, ignore_errors[, onerror]])         #遞迴的去刪除檔案
    shutil.rmtree('folder1')

shutil.move(src, dst)                           #遞迴的去移動檔案，它類似mv命令，其實就是重新命名。
    shutil.move('folder1', 'folder3')

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物件

        zip壓縮
            import zipfile
            # 壓縮
            z = zipfile.ZipFile('laxi.zip', 'w')
            z.write('a.log')
            z.write('data.data')
            z.close()

            # 解壓
            z = zipfile.ZipFile('laxi.zip', 'r')
            z.extractall()
            z.close()


        tar壓縮
            import tarfile
            # 壓縮
            tar = tarfile.open('your.tar','w')
            tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')
            tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')
            tar.close()

            # 解壓
            tar = tarfile.open('your.tar','r')
            tar.extractall()  # 可設定解壓地址
            tar.close()

系統命令：subprocess模組

call        #執行命令，返回狀態碼
    ret = subprocess.call(["ls", "-l"], shell=False)
    ret = subprocess.call("ls -l", shell=True)

check_call  #執行命令，如果執行狀態碼是 0 ，則返回0，否則拋異常
    subprocess.check_call(["ls", "-l"])
    subprocess.check_call("exit 1", shell=True)

check_output    #執行命令，如果狀態碼是 0 ，則返回執行結果，否則拋異常
    subprocess.check_output(["echo", "Hello World!"])
    subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)   #用於執行復雜的系統命令（不常用）
    args：shell命令，可以是字串或者序列型別（如：list，元組）

    bufsize：指定緩衝。0 無緩衝,1 行緩衝,其他 緩衝區大小,負值 系統緩衝

    stdin, stdout, stderr：分別表示程式的標準輸入、輸出、錯誤控制代碼

    preexec_fn：只在Unix平臺下有效，用於指定一個可執行物件（callable object），它將在子程序執行之前被呼叫

    close_sfs：在windows平臺下，如果close_fds被設定為True，則新建立的子程序將不會繼承父程序的輸入、輸出、錯誤管道。所以不能將close_fds設定為True同時重定向子程序的標準輸入、輸出與錯誤(stdin, stdout, stderr)。

    shell：同上

    cwd：用於設定子程序的當前目錄

    env：用於指定子程序的環境變數。如果env = None，子程序的環境變數將從父程序中繼承。

    universal_newlines：不同系統的換行符不同，True -> 同意使用 \n

    startupinfo與createionflags只在windows下有效

    將被傳遞給底層的CreateProcess()函式，用於設定子程序的一些屬性，如：主視窗的外觀，程序的優先順序等等 

執行普通命令：

import subprocess
            ret1 = subprocess.Popen(["mkdir","t1"])
            ret2 = subprocess.Popen("mkdir t2", shell=True)

終端輸入的命令分為兩種：
輸入即可得到輸出，如：ifconfig
輸入進行某環境，依賴再輸入，如：python #互動式

#第一段
import subprocess
obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

#第二段
import subprocess
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
obj.stdin.close()

cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close()

print(cmd_out)
print(cmd_error)

#第三段
import subprocess
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
out_error_list = obj.communicate()      #相當於第二段程式碼的  cmd_out = obj.stdout.read()及往下四行
print(out_error_list)

#第四段
import subprocess
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
out_error_list = obj.communicate('print("hello")')  #簡單的互動式命令
print(out_error_list)