【python自動化第五篇：python入門進階】

今天內容：

1. 模塊的定義
2. 導入方法
3. import的本質
4. 導入優化
5. 模塊分類
6. 模塊介紹

一、模塊定義：

　　　　用來在邏輯上組織python代碼（變量，函數，邏輯，類）；本質就是為了實現一個功能（就是以.py結尾的python文件）

　　　　比如說：文件名為test.py的文件，他的模塊名就是test

例如：在同一個文件夾下創建main.py（導入模塊的程序）,test.py(模塊文件)

 

#main.py文件內容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import test
printtest.name)                              #導入test模塊下的變量
print(test.say_hello())                    #導入test模塊下的函數say_hello()##要注意調用函數要加括號



#test.py文件內容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
name = "wanghui"
def say_hello():
    print('hello %s'%name)

　　

二、導入方法：

　　import module_name         (單個導入)

　　import module1,module2,module3.....           （多個導入用英文逗號隔開）

　　from module_name import *                         (導入所有的module_name下的所有代碼拿到當前的程序下先執行一遍，建議不要這樣使用)

　　from module_name import logger as logger_module_name               (導入module_name模塊下的logger函數，並重命名為logger_module_name使用的時候用logger_module_name函數)

三、import的本質

　　import導入：相當於是將模塊的內容解釋之后賦值給需要導入該模塊的程序，調用的時候需要以module.func(模塊對應的方法)來調用這個模塊的方法

　　from module import func這樣的導入：相當於是打開module這個文件並找到遁影的func方法執行一遍，直接用func名來調用即可。

示例如下：

#main.py文件內容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import test
print（test.name)                              #導入test模塊下的變量
print(test.say_hello())                       #導入test模塊下的函數say_hello()##要注意調用函數要加括號，還有要將模塊名寫上，否則出錯
#from導入
from module1 import name,logger               #from導入test模塊下的name，logger方法，調用時只需調用這個name和logger方法即可
print(name)
logger()



#test.py文件內容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
name = "wanghui"
def say_hello():
    print('hello %s'%name)
def logger():
    print("in the test!!!")

　　包的定義：本質就是一個目錄（必須帶有一個__init.py__的文件），

　　　　用法：從邏輯上組織模塊的

　　包的導入：導入包的目的就是為了解釋包下的init.py文件

　　路徑搜索的意義：就是為了能在import的時候找到正確的模塊路徑（也就是跨目錄的模塊搜索功能），方便找到模塊予以執行；否則將在自己所在的文件目錄下查找模塊，找的到的話 就能夠使用模塊，找不到的話就報錯。

　　路徑搜索用到的模塊：sys,os

import sys,os
print(os.path.abspath(__file__))   #獲取當前文件的路徑絕對路徑（結果D:\project\s14\day5\review\main.py）
#n那么這會兒要是往上走一級目錄的話就是要os.path.dirname(),線來獲取此文件所在的目錄
print(os.path.dirname(os.path.abspath(__file__)))   #這會兒就到文件所在的目錄了（結果D:\project\s14\day5\review）
#因為你的module1.py模塊在day5下呢，所以現在還是找不到的，那我們就再上一層吧，還是用os.path.dirname()結合上一個os.path.dirname(os.path.abspath(__file__))就可以實現往上一級目錄定位了。
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #這樣子就可以找到day5這個目錄了
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))   #將這個路徑加載到當前程序的環境變量中，以便調用模塊的時候能夠找的到模塊（當然也可以使用insert來添加到指定位置）
import module1
print(module1.name)

　這樣的話就可以實現跨目錄的調用了，一定要記得加載到環境變量中，不然還是找不到呢。

　完整的導入技巧如下： 

#import 跨路徑導入模塊
import sys,os
BASE_DIR=os.path.dirname(os.path.abspath(__file__))  #定義當前文件完整路徑
MODULE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  #可已通過os.path.dirname()往上一級目錄，
sys.path.append(MODULE_DIR)   #將當前模塊路徑寫入當前調用程序的環境變量
import module_name                    #現在就可以導入跨路徑的模塊了       絕對路徑
from day5 import package_name

四、導入優化

　　像是有些模塊的重復使用對的情況下，import的導入方法要弱於from module import func；畢竟重復使用的時候也只是使用模塊對應的方法。要單純使用import的時候多個函數的模塊調用會導致運行效率不高。故引入from modue import func 來直接定義好要調用的func，從而提高多多個函數的模塊調用的效率！

五、模塊的分類：

1. 標准庫（內置模塊）
2. 第三方庫（開源模塊）
3. 自定義模塊

六、標准庫

　　1.時間模塊

　　　　時間格式：時間戳，格式化的時間，元組話表示

　　        time： 

#Author:wanghui
import time
t = time.time()          #時間戳格式顯示，單位是秒
x = t          #遮掩算出來的就是從1970.1.1-00:00:00到現在經歷的年
print(x)

q = time.localtime()     #時間元組格式的時間
print(q)                 #time.struct_time(tm_year=2016, tm_mon=8, tm_mday=22, tm_hour=2, tm_min=57, tm_sec=59, tm_wday=0, tm_yday=235, tm_isdst=0)

w = time.timezone        #格里尼治時間和本地時間的差（按秒計算）
print(w/3600)            #打印時區差

e = time.altzone         #夏令時（DST）和UTC時間差    time.daylight 是否使用夏令時
print(e/3600)            #打印小時差

#time.sleep(10)          #休息10秒

r = time.gmtime()        #需要傳入秒數，然后就轉換成時間元組（time.timezone）,
print(r)                 #不加時間戳參數則表示打印的是格林尼治時間元組

y = time.localtime()     #轉換成當地時間元組形式
print(y)                 #加參數則能夠隨着本地的時間格式轉換
d = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())        #將元組結構時間轉換成格式化時間
print(d)

f = time.strptime('2016-08-23 00:30:32',"%Y-%m-%d %H:%M:%S")   #格式化時間轉換成元組結構時間
print(f)

g = time.asctime()                              #將時間轉換成Tue Aug 23 00:35:52 2016格式
print(g)

k = time.ctime()                                #將時間戳格式轉換成Tue Aug 23 00:35:52 2016格式
print(k)

　　操作圖如下：

　　timedate模塊：

import datetime
print(datetime.date)
print(datetime.time)
print(datetime.datetime.now())                #獲取當前時間
print(datetime.datetime.now()+datetime.timedelta(3))    #獲取到的三天后的時間
print(datetime.datetime.now()+datetime.timedelta(-3))   #獲取三天前的時間
print(datetime.datetime.now()+datetime.timedelta(hours=3))   #獲取三小時以后的時間
print(datetime.datetime.now()+datetime.timedelta(hours=-3))  #獲取三小時錢的時間
print(datetime.datetime.now()+datetime.timedelta(minutes=3)) #獲取三分鍾以后的時間
print(datetime.datetime.now()+datetime.timedelta(minutes=-3)) #獲取三分鍾之前的時間

#時間替換
c_time = datetime.datetime.now()                       #獲取當前時間
print(c_time.replace(minute=4,hour=2))                 #replace當前時間

　　2.random

 　　random基礎操作：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import random

print(random.random())      #打印生成的0到1之間的隨機額浮點數
print(random.uniform(1,9))  #打印1到9之間的隨機浮點數
print(random.randint(1,9))  #打印1到9之間的隨機整數
print(random.randrange(1,9)) #打印1到9之間除了9之外的隨機整數（顧頭不顧尾，類似於range(9)）
# #random.choie()         其中可以傳入任意的數據類型並隨機選其一
print(random.choice("abcdefghijklmn"))     #隨機選擇一個字符串
print(random.choice((1,2,3,[4,5,6],7,8)))      #隨機選擇元組中的一個參數（序列都能這么玩）
#print(random.choice({'name':"wanghui",'age':"24",'job':"IT"}))           #金測試字典中的元素不能被隨機打印（因為時間支隊，不能被拆散）

print(random.sample("hello",2))       #sample()對於定義的字符春后面的數字代表能夠隨機取出的個數（以列表的方式打印）

#洗牌效果：實現對其中的列表或者元組元素順序的打亂
li_old = [1,2,3,4,5,6]
li_new = random.shuffle(li_old)     #洗牌操作
print(li_old)               #將li_old列表的元素亂序排列

　　random實戰生成六位驗證碼：

#方法一：
import random
check_code = []                           #定義空列表，用於傳遞驗證碼用
for i in range(6):                       #定義驗證碼位數
    r = random.randint(0,5)               #定義生成驗證碼的次數
    if i == 2 or r == 4:                 #第二位或者第四次生成數字。將其加入空列表
        num = random.randint(0,9)
        check_code.append(str(num))
    else:                                #其他情況
        word = random.randint(65,90)     #定義字母並見此追加到列表中
        word_str = chr(word)
        check_code.append(str(word_str))
final_code = "".join(check_code)        #將最后生成的列表中的字符串去掉標點符號來join到一起
print(final_code)

#方法二：
import random
checkcode = ''
for m in range(6):                     #定義驗證碼位數
    current = random.randint(0,9)       #讓數字活動起來
    if m ==2 or current ==4:           #位數和次數    (完全隨機的話current == m)
        tmp = random.randint(0,9)       #如果次數隨機等於m，則將其任意值賦給tmp
    else:
        tmp = chr(random.randint(65,90))   #其余的為字母
    checkcode+=str(tmp)                    #拼接字符串
print(checkcode)                           #打印驗證碼

　　3.os模塊：

os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir("dirname")  改變當前腳本工作目錄；相當於shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
os.removedirs('dirname1')    若目錄為空，則刪除，並遞歸到上一級目錄，如若也為空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；相當於shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove()  刪除一個文件
os.rename("oldname","newname")  重命名文件/目錄
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所指向的文件或者目錄的最后修改時間

　　3.sys模塊：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#sys模塊

import sys
print(sys.agv[1])   #竄入第一個參數
sys.exit(7)         #按照狀態碼為7退出
sys.maxint          #最大的int值
print(sys.platform) #打印操作系統平台
sys.stdout.write('please')   #系統輸出，用於打印進度條

　　4.phutil：高級的 文件、文件夾、壓縮包 處理模塊

#shutil模塊：進行文件的copy，還能打包
import shutil
f_old = open('test1.txt',encoding='utf-8')           #源文件
f_new = open('test2.txt','w',encoding='utf-8')       #復制后的文件
shutil.copyfileobj(f_old,f_new)                      #復制操作
shutil.copyfile("test2.txt","test3.txt")            #不需要讀取文件，直接復制
shutil.copymode("test1.txt","test4.txt")            #僅拷貝權限。內容、組、用戶均不變
shutil.copystat("test4.txt","test5.txt")            #拷貝狀態的信息，包括：mode bits, atime, mtime, flags
shutil.copy("test5.txt","test6.txt")                #拷貝文件和權限
shutil.copytree("a","a_test")                       #遞歸拷貝目錄以及其內容
shutil.rmtree("a_test")                             #刪除遞歸目錄

shutil.make_archive('test','zip','D:\pytest')     #對D:\pytest下的文件進行壓縮
import zipfile
#使用zip壓縮
m = zipfile.ZipFile('D:\pytest\day5.zip','w')      #以寫的方式打開文件
m.write("test.zip")                        #傳入文件
print("-----")
m.write("test1.txt")                      #再來一發
m.close()                                   #文件關閉
#解壓
m = zipfile.ZipFile('D:\pytest\day4.zip','r')       #讀的方式打開文件
m.extractall()                               #解壓文件
m.close()                                    #解壓完成關閉文件

import tarfile
#使用tar壓縮
tar = tarfile.open("test.tar",'w')
tar.add('D:\pytest\day3.zip',arcname="day3.zip")
tar.add('D:\pytest\day4.zip',arcname="day4.zip")
tar.close()
#使用tar解壓
tar = tarfile.open('test.tar','r')
tar.extractall()  # 可設置解壓地址
tar.close()

　　5.stelve模塊： 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
#由於不能多次dump或者load多次，效率低下
import shelve,datetime
#簡單的將key,value數據持久化的一個模塊，可以持久化任何pickle支持的python數據格式
d = shelve.open("test.txt")
info = {'name':'wanghui','age':25}
job = ['IT','WORKER','DESIGNER']
d["job"] = job
d["info"] = info
d['date'] = datetime.datetime.now()
d.close()

print(d.get('job'))    #獲取job列表
print(d.get('info'))   #獲取字典
print(d.get('date')   #獲取時間

　　6.xml模塊

 需要處理的test.xml文件：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

 調用xml模塊的方法處理xml文件：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import xml.etree.ElementTree as ET
tree = ET.parse('test.xml')        #定義要處理的文件
first = tree.getroot()                #獲取根節點參數
print(first.tag)                      #.tag就是將內存數據轉化成可以讀取的形式

#遍歷xml文檔
for second in first:                  #讀取第二級節點
    print(second.tag,second.attrib)
    for third in second:              #讀取第三級節點
        print(third.tag,third.attrib)
        for forth in third:
            print(forth.tag,forth.attrib)
#只遍歷其中的year節點
for node in first.iter("year"):
    print(node.tag,node.text)


#修改xml文件
for node in first.iter('year'):
    new = int(node.text) + 1          #year + 1
    node.text = str(new)              #轉換成str
    node.set("updated",'yes')       #添加新的屬性
tree.write("test.xml")

#刪除節點
for country in first.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        first.remove(country)
tree.write('out.xml')

#創建xml文件
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")            #聲明namelist
personinfo = ET.SubElement(new_xml,'personinfo',attrib={'enrolled':'yes'})
name = ET.SubElement(personinfo,"age",atrrib={'checked','no'})
name.text = 'wanghui'
age = ET.SubElement(personinfo,"age",atrrib={'checked','no'})
sex = ET.SubElement(name,'sex')
age.text = '25'
personinfo2 = ET.SubElement(new_xml,'personinfo',attrib={'enrolled':'no'})
name = ET.SubElement(personinfo2,"age",atrrib={'checked','no'})
name.text = "alex"
age = ET.SubElement(personinfo2,"age")
age.text = '12'

ex = ET.ElementTree(new_xml)                   #生成文檔對象
ex.write('test1.xml',encoding='utf-8',xml_declaration=True)
ET.dump(new_xml)       #打印生成的格式

　　7.configparser模塊：用於處理配置文件

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#configparser:處理配置文件
import configparser
conf = configparser.ConfigParser()      #生成configparser對象
conf["DEFAULT"] = {'ServerAliveInterval':'45',   #生成第一個實例
                   'Compression':'yes',
                   "CompressionLevel":9
}
conf['bitbucher.org'] = {}                         #第二個實例
conf['bitbucher.org'] ['User'] = 'hg'

conf["topsecret.server.com"] = {}               #第三個實例
topsecret = conf["topsecret.server.com"]
topsecret['Host Port'] = "52333"
topsecret['ForwardXll'] = 'no'

with open('example.ini','w',encoding='utf-8') as configfile:
    conf.write(configfile)                                    #寫入配置文件

　　其他操作：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# import configparser
# conf = configparser.ConfigParser()        #讀取文件前戲
# conf.read('example.ini')
# print(conf.sections())
# print(conf.defaults())   #打印所有
# print(conf['bitbucher.org']['User'])   #讀取bitbucher.org的user信息
# for key in conf['bitbucher.org']:      #利用循環讀取
#     print(key)

#增刪改查語法
import configparser
conf = configparser.ConfigParser()
conf.read('example.ini')
#讀取一把
print(conf.sections())
print(conf['bitbucher.org']['User'])               #讀取配置文件
#增刪操作
ret = conf.remove_section('bitbucher.org')          #刪除
conf.write(open('exaple.ini','w'))                  #寫入文件

　　8.hashlib模塊：提供加密算法

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import hashlib
m = hashlib.md5()        #創建md5加密對象
m.update(b'hello')      #對象中插入數值
print(m.hexdigest())      #以十六進制打印md5值
m.update(b"it's me!!")
print(m.hexdigest())
m.update(b'as long as you love me!')
print(m.hexdigest())
#拼接
m2 = hashlib.md5()
m2.update(b"helloit's me!!")  #更新之后的和拼接的md5一樣
print(m2.hexdigest())

s1 = hashlib.sha512()
s1.update(b"helloit's me!!")  #復雜算法
print(s1.hexdigest())
#帶中文的加密
f1 = hashlib.md5()
f1.update("你妹呀！！".encode(encoding='utf-8'))
print(f1.hexdigest())
#更吊的版本
import hmac
k1 = hmac.new(b'wanghui',b'message')      #僅支持ascii碼，不支持中文
print(k1.hexdigest())
print(k1.digest())
#帶中文的加密
k2 = hmac.new("你大爺的！！".encode(encoding='utf-8'),"呵呵噠！".encode(encoding='utf-8'))
print(k2.hexdigest())

　　9.re模塊：匹配字符串（模糊匹配）