模塊

(1)模塊

定義 : 用一段代碼實現某個功能的代碼集合，對於一個複雜的功能來，可能須要多個函數才能完成（函數又能夠在不一樣的.py文件中），n個 .py 文件組成的代碼集合就稱爲模塊。

常見的模塊 : os>>>>>>>>>>>>>>系統模塊

　　　　　　file>>>>>>>>>>>>>>文件操做相關模塊

按性質可分爲三種: 自定義模塊, 內置模塊, 第三方模塊

(2)模塊導入方法

1.import(在同個包裏用import調用文件名)

import方法實質就是按照系統的環境變量sys.path中去尋找調用的文件

注意:在當前目錄下存在與要引入的模塊同名的文件,就會把要引入的模塊屏蔽掉.(time,sys除外)

環境變量修改:

1 import sys,os
2 
3 BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
4 sys.path.append(BASE_DIR)

2.包(package)

定義：按目錄來組織模塊的方法，稱爲包

引入了包之後，只要頂層的包名不與別人衝突，那全部模塊都不會與別人衝突。

每個包目錄下面都會有一個__init__.py的文件，這個文件是必須存在的，不然，Python就把這個目錄當成普通目錄(文件夾)，而不是一個包。__init__.py能夠是空文件，也能夠有Python代碼，由於__init__.py自己就是一個模塊，而它的模塊名就是對應包的名字。

3.if__name__ == "__main__":

做用：做爲調試代碼時使用，聲明在它下面的代碼做爲調試做用，在執行頁name系統默認等於「main」,在調用頁name=路徑4.，顯然與__main__不相等，這樣別人在調用的時候，不會將調試代碼執行

4.time模塊

import time#調用系統內置time模塊（time模塊是用C語言編寫的，與程序同在，並非調用py文件來實現的）

時間戳：時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。(只有時間戳才能夠進行計算)

結構化時間：struct_time元組共有9個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時)

 1 import time
 2 #time.sleep()#推遲指定的時間運行
 3 print(time.time())#打印從1970年1月日凌晨至如今的時間用秒錶示
 4 #1481537054.002029
 5 print(time.localtime())#將一個時間戳結構化，默認以當前時間爲準
 6 #time.struct_time(tm_year=2016, tm_mon=12, tm_mday=12, tm_hour=18, tm_min=4, tm_sec=14, tm_wday=0, tm_yday=347, tm_isdst=0)
 7 print(time.gmtime())#將一個時間戳轉換爲當前UTC時區，默認格林尼治時間
 8 #time.struct_time(tm_year=2016, tm_mon=12, tm_mday=12, tm_hour=10, tm_min=5, tm_sec=12, tm_wday=0, tm_yday=347, tm_isdst=0)
 9 print(time.mktime(time.localtime()))#將結構化時間轉換爲時間戳
10 #1481537602.0
11 print(time.strftime("%Y-%m-%d %X",time.localtime()))#將結構化時間以自定義格式轉換爲字符串時間
12 #2016-12-12 18:15:35
13 print(time.strptime("2016-09-12 12:03:24","%Y-%m-%d %X"))#將字符串時間按格式轉換爲結構化時間
14 #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=12, tm_hour=12, tm_min=3, tm_sec=24, tm_wday=0, tm_yday=256, tm_isdst=-1)
15 print(time.clock())#cpu運行時間
16 #1.61984329635951e-06
17 print(time.ctime())#將時間戳直接轉換爲字符串時間
18 #Mon Dec 12 18:22:42 2016
19 print(time.asctime())#將時間戳直接轉換爲字符串時間
20 #Mon Dec 12 18:24:06 2016

time方法

另外，調用datetime能夠直接將當前時間直接以字符串形式顯示

1 1 import datetime
2 2 print(datetime.datetime.now())#以字符串形式顯示當前時間
3 3 #2016-12-12 18:26:56.154939

5.random(隨機數模塊)

import random#導入random模塊

 1 import random#導入random模塊
 2 print(random.random())#隨機產生一個浮點數，只能在0-1之間取
 3 
 4 print(random.uniform(1,3))#在指定範圍內隨機產生一個浮點數
 5 
 6 print(random.randint(1,3))#在範圍內隨機產生一個整形數，兩邊均可取到
 7 
 8 print(random.choice("hello"))#在可迭代對象內隨機取出一個對象
 9 #h
10 print(random.randrange(1,5))#在範圍內隨機產生一個整形數，右邊爲閉區間
11 
12 v = [1,2,3,4,5]
13 random.shuffle(v)#打亂原有次序
14 print(v)
15 #[2, 1, 5, 3, 4]
16 
17 print(random.sample([1,2,3,4],2))#在對象中隨機取出指定個數元素
18 #[4, 1]

random

import random
def cod():
    s = ""
    for i in range(5):
        ret = random.choice([(random.randint(0,9)),chr(random.randint(66,122)),chr(random.randint(97,122))])
        s += str(ret)
    print(s)
cod()

6.os模塊

os模塊時與系統交互的一個接口

 1 os.getcwd()# 獲取當前工做目錄，即當前python腳本工做的目錄路徑
 2 os.chdir("dirname")  #改變當前腳本工做目錄；至關於shell下cd
 3 os.curdir  #返回當前目錄: ('.')
 4 os.pardir  #獲取當前目錄的父目錄字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    #可生成多層遞歸目錄
 6 os.removedirs('dirname1')    #若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
 7 os.mkdir('dirname')    #生成單級目錄；至關於shell中mkdir dirname
 8 os.rmdir('dirname')    #刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
 9 os.listdir('dirname')    #列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
10 os.remove()  #刪除一個文件
11 os.rename("oldname","newname")  #重命名文件/目錄
12 os.stat('path/filename')  #獲取文件/目錄信息
13 os.sep    #輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
14 os.linesep    #輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
15 os.pathsep    #輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
16 os.name    #輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
17 os.system("bash command")  #運行shell命令，直接顯示
18 os.environ  #獲取系統環境變量
19 os.path.abspath(path)  #返回path規範化的絕對路徑
20 os.path.split(path)  #將path分割成目錄和文件名二元組返回
21 os.path.dirname(path)  #返回path的目錄。其實就是os.path.split(path)的第一個元素
22 os.path.basename(path)  #返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
23 os.path.exists(path)  #若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)  #若是path是絕對路徑，返回True
25 os.path.isfile(path) # 若是path是一個存在的文件，返回True。不然返回False
26 os.path.isdir(path)  #若是path是一個存在的目錄，則返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  #將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
28 os.path.getatime(path)  #返回path所指向的文件或者目錄的最後存取時間
29 os.path.getmtime(path)  #返回path所指向的文件或者目錄的最後修改時間

os

7.sys模塊

1 sys.argv           命令行參數List，第一個元素是程序自己路徑#在調試時，能夠在前面定義參數，不用再執行過程當中一個個添加
2 sys.exit(n)        退出程序，正常退出時exit(0)
3 sys.version        獲取Python解釋程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
6 sys.platform       返回操做系統平臺名稱

進度條

1 import sys,time
2 for i in range(50):
3     sys.stdout.write("%")
4     sys.stdout.flush()
5     time.sleep(1)

8.json/pickle

json能夠將特殊字符串及普通字符串序列化

若是咱們要在不一樣的編程語言之間傳遞對象，就必須把對象序列化爲標準格式，好比XML，但更好的方法是序列化爲JSON，由於JSON表示出來就是一個字符串，能夠被全部語言讀取，也能夠方便地存儲到磁盤或者經過網絡傳輸。JSON不只是標準格式，而且比XML更快，並且能夠直接在Web頁面中讀取，很是方便。

1 import json
2 dic = {"a":"b"}
3 print(type(dic))#<class 'dict'>
4 v = json.dumps(dic)
5 print(type(v))#<class 'str'>#json將對象經過json特有的方法處理成了能被各類語言識別的字符串形式

1 f=open('序列化對象','w')
2 f.write(j)  #-------------------等價於json.dump(dic,f)
3 f.close()
4 #-----------------------------反序列化<br>
5 import json
6 f=open('序列化對象')
7 data=json.loads(f.read())#  等價於data=json.load(f)

pickle

 1 ##----------------------------序列化
 2 import pickle
 3  
 4 dic={'name':'alvin','age':23,'sex':'male'}
 5  
 6 print(type(dic))#<class 'dict'>
 7  
 8 j=pickle.dumps(dic)
 9 print(type(j))#<class 'bytes'>
10  
11  
12 f=open('序列化對象_pickle','wb')#注意是w是寫入str,wb是寫入bytes,j是'bytes'
13 f.write(j)  #-------------------等價於pickle.dump(dic,f)
14  
15 f.close()
16 #-------------------------反序列化
17 import pickle
18 f=open('序列化對象_pickle','rb')
19  
20 data=pickle.loads(f.read())#  等價於data=pickle.load(f)
21  
22  
23 print(data['age'])    
24       Pickle的問題和全部其餘編程語言特有的序列化問題同樣，就是它只能用於Python，而且可能不一樣版本的Python彼此都不兼容，所以，只能用Pickle保存那些不重要的數據，不能成功地反序列化也不要緊。

9.shelve模塊

shelve模塊比pickle模塊簡單，只有一個open函數，返回相似字典的對象，可讀可寫;key必須爲字符串，而值能夠是python所支持的數據類型

 1 import shelve
 2  
 3 f = shelve.open(r'shelve.txt')
 4  
 5 # f['stu1_info']={'name':'alex','age':'18'}
 6 # f['stu2_info']={'name':'alvin','age':'20'}
 7 # f['school_info']={'website':'oldboyedu.com','city':'beijing'}
 8 #
 9 #
10 # f.close()
11  
12 print(f.get('stu_info')['age'])

10.hashlib模塊>>>>>加密操做

主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

 1 import hashlib
 2  
 3 m=hashlib.md5()# m=hashlib.sha256()
 4  
 5 m.update('hello'.encode('utf8'))
 6 print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 7  
 8 m.update('alvin'.encode('utf8'))
 9  
10 print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
11  
12 m2=hashlib.md5()
13 m2.update('helloalvin'.encode('utf8'))
14 print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

以上加密算法雖然依然很是厲害，但時候存在缺陷，即：經過撞庫能夠反解。因此，有必要對加密算法中添加自定義key再來作加密。

1 import hashlib
2  
3 # ######## 256 ########
4  
5 hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
6 hash.update('alvin'.encode('utf8'))
7 print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

python 還有一個 hmac 模塊，它內部對咱們建立 key 和 內容 再進行處理而後再加密:

1 import hmac
2 h = hmac.new('alvin'.encode('utf8'))
3 h.update('hello'.encode('utf8'))
4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940