一、模塊

1、什麽是模塊：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴

　　模塊的本質：模塊的本質是一個py文件

2、模塊分為三類：1）內置模塊；2）第三方模塊；3）自定義模塊

3、使用模塊的目的：

　　退出python解釋器然後重新進入，那麽你之前定義的函數或者變量都將丟失，因此我們通常將程序寫到文件中以便永久保存下來，需要時就通過python test.py方式去執行，此時test.py被稱為腳本script。

　　隨著程序的發展，功能越來越多，為了方便管理，我們通常將程序分成一個個的文件，這樣做程序的結構更清晰，方便管理。這時我們不僅僅可以把這些文件當做腳本去執行，還可以把他們當做模塊來導入到其他的模塊中，實現了功能的重復利用

4、模塊的使用：通過import 調用

示例文件：spam.py，文件名spam.py,模塊名spam

 1 #spam.py
 2 print(‘from the spam.py‘)
 3 
 4 money=1000
 5 
 6 def read1():
 7     print(‘spam->read1->money‘,money)
 8 
 9 def read2():
10     print(‘spam->read2 calling read‘)
11     read1()
12 
13 def change():
14     global money
15     money=0
 

4.1模塊可以包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行（import語句是可以在程序中的任意位置使用的,且針對同一個模塊很import多次,為了防止你重復導入，python的優化手段是：第一次導入後就將模塊名加載到內存了，後續的import語句僅是對已經加載大內存中的模塊對象增加了一次引用，不會重新執行模塊內的語句），如下

 1 #test.py
 2 import spam #只在第一次導入時才執行spam.py內代碼,此處的顯式效果是只打印一次‘from the spam.py‘,當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.
 
 3 import spam
 4 import spam
 5 import spam
 6 
 7 ‘‘‘
 8 執行結果：
 9 from the spam.py
10 ‘‘‘

我們可以從sys.module中找到當前已經加載的模塊，sys.module是一個字典，內部包含模塊名與模塊對象的映射，該字典決定了導入模塊時是否需要重新導入。

4.2 每個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當做全局名稱空間，這樣我們在編寫自己的模塊時，就不用擔心我們定義在自己模塊中全局變量會在被導入時，與使用者的全局變量沖突

 1 #測試一:money與spam.money不沖突
 2 #test.py
 3 import spam 
 4 money=10
 5 print(spam.money)
 6 
 7 ‘‘‘
 8 執行結果：
 9 from the spam.py
10 1000
11 ‘‘‘

 1 #測試二：read1與spam.read1不沖突
 2 #test.py
 3 import spam
 4 def read1():
 5     print(‘========‘)
 6 spam.read1()
 7 
 8 ‘‘‘
 9 執行結果:
10 from the spam.py
11 spam->read1->money 1000
12 ‘‘‘

 1 #測試三：執行spam.change()操作的全局變量money仍然是spam中的
 2 #test.py
 3 import spam
 4 money=1
 5 spam.change()
 6 print(money)
 7 
 8 ‘‘‘
 9 執行結果：
10 from the spam.py
11 1
12 ‘‘‘

總結：首次導入模塊spam時會做三件事：

　　1.為源文件(spam模塊)創建新的名稱空間，在spam中定義的函數和方法若是使用到了global時訪問的就是這個名稱空間。

　　2.在新創建的命名空間中執行模塊中包含的代碼，見初始導入import spam

　　3.創建名字spam來引用該命名空間

1.#為模塊名起別名，相當於m1=1;m2=m1 
2.import spam as sm
3.print(sm.money)

#在一行導入多個模塊
1.import sys,os,re

二、常用內置模塊

1、time模塊

　　1、時間的表示形式　　　　

　　　　在Python中，通常有這三種方式來表示時間：時間戳、元組(struct_time)、格式化的時間字符串：

　　　　(1)時間戳(timestamp) ：通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。我們運行“type(time.time())”，返回的是float類型。

　　　　(2)格式化的時間字符串(Format String)： ‘1988-03-16’

　　　　(3)元組(struct_time) ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）

 1 # <1> 時間戳
 2 >>> import time
 3 >>> time.time()      #--------------返回當前時間的時間戳
 4 1493136727.099066
 5 
 6 # <2> 時間字符串
 7 >>> time.strftime("%Y-%m-%d %X")
 8 ‘2017-04-26 00:32:18‘
 9 
10 # <3> 時間元組
11 >>> time.localtime()
12 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26,
13                  tm_hour=0, tm_min=32, tm_sec=42, tm_wday=2,
14                  tm_yday=116, tm_isdst=0)

　　　　小結：時間戳是計算機能夠識別的時間；時間字符串是人能夠看懂的時間；元組則是用來操作時間的

　　2、幾種時間形式的轉換

　　　　（1）

 1 # print(time.time())   #  僅僅是當前時間的時間戳     float型
 2 #------------------------------------------------
 3 #print(time.localtime())  #  當前時間的結構化時間對象
 4 
 5 s=time.localtime(312431212)      #  結構化時間對象         將時間戳------->結構化時間
 6 s2=time.gmtime()        #  結構化時間對象   UTC時間
 7 
 8 # print(s.tm_year)
 9 # print(s.tm_wday)
10 #------------------------------------------------
11 t="2012-12-12"
12 ret=time.mktime(time.localtime())  #  將結構化時間------->時間戳
13 print(ret)
14 #------------------------------------------------
15 ret2=time.strftime("%Y-%m-%d",time.localtime())  # 將結構化時間------>字符串時間
16 print(ret2)
17 #------------------------------------------------
18 ret3=time.strptime("1900:03:12","%Y:%m:%d")               # 將字符串時間----->結構化時間
19 print(ret3)

　　　　（2）

1 >>> time.asctime(time.localtime(312343423))
2 ‘Sun Nov 25 10:03:43 1979‘
3 >>> time.ctime(312343423)
4 ‘Sun Nov 25 10:03:43 1979‘

#--------------------------其他方法
# sleep(secs)
# 線程推遲指定的時間運行，單位為秒。

2、random模塊

　　1、random模塊的使用

>>> import random
>>> random.random()      # 大於0且小於1之間的小數
0.7664338663654585

>>> random.randint(1,5)  # 大於等於1且小於等於5之間的整數

>>> random.randrange(1,3) # 大於等於1且小於3之間的整數

>>> random.choice([1,‘23‘,[4,5]])  # #1或者23或者[4,5]

>>> random.sample([1,‘23‘,[4,5]],2) # #列表元素任意2個組合
[[4, 5], ‘23‘]

>>> random.uniform(1,3) #大於1小於3的小數
1.6270147180533838

>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打亂次序
>>> item
[5, 1, 3, 7, 9]

>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

　　2、random模塊的應用：最近生成五位數的驗證碼

#練習： 隨機生成五位數驗證碼
def valdate_code():
    ret=""
    for i in range(5):
        num=random.randint(0,9)
        alfa=chr(random.randint(97, 122))
        alfa2=chr(random.randint(65, 90))
        s=random.choice([str(num),alfa,alfa2])
        ret=ret+s
    return ret

    # 思路2
    # ret=random.sample([1,2,3,4,5,6,7,8,9,0],5)
    # print(ret)
    # print(type(ret))
    # #
    # ret=‘‘.join(ret)
    # # return ret

print(valdate_code())

3、hashlib

　　1、hash：一種摘要算法 ,3.x裏代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

　　2、摘要算法又稱哈希算法、散列算法。它通過一個函數，把任意長度的數據轉換為一個長度固定的數據串（通常用16進制的字符串表示）
　　三個特點：
　　　　1.內容相同則hash運算結果相同，內容稍微改變則hash值則變
　　　　2.不可逆推
　　　　3.相同算法：無論校驗多長的數據，得到的哈希值長度固定。

　　3、以常見的摘要算法MD5為例，計算出一個字符串的MD5值：

import hashlib
 
md5 = hashlib.md5()
md5.update(‘how to use md5 in python hashlib?‘)
print md5.hexdigest()

計算結果如下：
d26a53750bc40b38b65a520292f69306

　　如果數據量很大，可以分塊多次調用update()，最後計算的結果是一樣的：

md5 = hashlib.md5()
md5.update(‘how to use md5 in ‘)
md5.update(‘python hashlib?‘)
print md5.hexdigest()

　　MD5是最常見的摘要算法，速度很快，生成結果是固定的128 bit字節，通常用一個32位的16進制字符串表示。另一種常見的摘要算法是SHA1，調用SHA1和調用MD5完全類似：

import hashlib
 
sha1 = hashlib.sha1()
sha1.update(‘how to use sha1 in ‘)
sha1.update(‘python hashlib?‘)
print sha1.hexdigest()

　　SHA1的結果是160 bit字節，通常用一個40位的16進制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不過越安全的算法越慢，而且摘要長度更長。

　　4、摘要算法應用

　　　　4.1網站存儲用戶登錄的用戶名和登錄密碼

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

　　　　4.2，防止網站數據泄露後，黑客“撞庫”，對網站存儲用戶登錄的用戶名和登錄密碼進行“加鹽”，即通過對原始口令加一個復雜字符串來實現

hashlib.md5("abc".encode("utf8"))

　　　　經過Salt處理的MD5口令，只要Salt不被黑客知道，即使用戶輸入簡單口令，也很難通過MD5反推明文口令。

4、os模塊

　　1、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    輸出用於分割文件路徑的字符串 win下為;,Linux下為:
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所指向的文件或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小
‘‘‘

 1 os路徑處理
 2 #方式一：推薦使用
 3 import os
 4 #具體應用
 5 import os,sys
 6 possible_topdir = os.path.normpath(os.path.join(
 7     os.path.abspath(__file__),
 8     os.pardir, #上一級
 9     os.pardir,
10     os.pardir
11 ))
12 sys.path.insert(0,possible_topdir)
13 
14 
15 #方式二：不推薦使用
16 os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

Python基礎（11）_python模塊之time模塊、rando模塊、hashlib、os模塊