Python基礎學習（16）主要模組

一、今日內容大綱

• time 模組
• datetime 模組
• os 模組
• sys 模組
• json 模組
• pickle 模組
• hashlib 模組
• collection 模組

二、變數類別

可在Pycharm自動補全功能中經常看到：

• C：Class 類
• m：Method 方法
• F：Function 函式
• f：Field 域
• V：Variable 變數
• p：property 屬性
• p：parameter 引數

三、time 模組

封裝了獲取時間戳和字串形式地時間的一些方法。

1. 三大物件

   • 時間戳 timestamp
   • 格式化時間物件 format time object
   • 時間字串 time string

2. 獲取時間戳

   時間戳：從時間元年（1970-01-01 00:00:00）到現在經過的秒數（某些語言是毫秒數）。

   print(time.time())  # 1594723794.3379405
   

3. 獲取格式化事件物件

   格式化時間物件是一個名為 struct_time 的元組，元組中共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時標記）。

   print(time.gmtime())  # GMT（格林威治） 時間
   print(time.localtime())  # 當地時間
   # time.struct_time(tm_year=2020, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=57, tm_sec=26, tm_wday=1, tm_yday=196, tm_isdst=0)
   print(time.localtime(1))  # 是時間元年過一秒，對應的時間物件
    
   

4. 時間字串

   時間字串需要通過格式化時間物件轉化，轉化為字串易於閱讀，而格式化事件物件易於傳輸。

   # 將格式化時間物件轉換成字串 string-format-time
   s = time.strftime('%Y.%m.%d %H:%M:%S', time.gmtime())  # 將格林威治時間物件轉換為字串
   s = time.strftime('%Y.%m.%d %H:%M:%S')  # 預設轉換當地的事件物件
   
   
   # 將時間物件轉換為時間字串 string-parse-time
   time_obj = time.strptime('2010.10.10', '%Y.%m.%d')  # 將字串轉換為時間物件
    
   

5. 格式化事件物件轉化為時間戳（瞭解）

   print(time.mktime(time.gmtime()))  # 1594697675.0
   

6. 睡眠功能

   可以通過time.sleep()實現當前執行程式的睡眠，主要用於開發過程。

四、datetime 模組

日期時間模組，封裝了一些和日期時期相關的類，主要用於對時間進行數學運算，裡面主要包含 date 類、time 類、datetime 類、timedelta 類等。

1. date 類

   主要包含year,month,day三個屬性（property）。

   d = datetime.date(2010, 10, 10)
   print(d)  # 2010-10-10
   # 獲取date類的各個屬性(property)
   print(d.year)
   print(d.month)
   print(d.day)
   

2. time 類

   主要包含hour,minute,second三個屬性。

   t = datetime.time(10, 48, 59)
   print(t)  # 10:48:59
   # 獲取time類的各個屬性(property)
   print(t.hour)
   print(t.minute)
   print(t.second)
   

3. datetime 類

   相當於綜合了 time 類和 date 類的功能，主要包含year,month,day,hour,minute,second六個屬性。

   dt = datetime.datetime(2010, 11, 11, 11, 11, 11)
   print(dt)  # 2010-11-11 11:11:11
   

4. timedelta 類

   是一種儲存時間變化量的類，具有days,seconds,microseconds,milliseconds,minutes,hours,weeks屬性等。

   # timedeleta類
   td = datetime.timedelta(days=300)
   print(td)  # 1 day, 0:00:00
   
   # 建立時間運算:date,datetime,timedelta(和time類不能計算)
   # 時間變化量的運算會跨位運算
   d = datetime.date(2010, 10, 10)
   res = d + td
   print(res)  # 2011-08-06
   

   # 練習:計算2100某一年的二月份有多少天
   # 普通演算法:根據年份計算是否是閏年
   # 用datetime模組
   import datetime
   d = datetime.date(2100, 3, 1)
   res = d - datetime.timedelta(days=1)
   print(res.day)  # 28
   

五、os 模組

和底層作業系統相關的操作被封裝在這個模組中。

1. 和檔案操作相關

   • 刪除檔案：

     ​ os.remove(path)：刪除路徑下的檔案

   • 重新命名檔案

     ​ os.rename(path_1, path_2)：將路徑一的檔案修改為路徑二的檔案

   • 刪除目錄（必須是空目錄）

     ​ os.removedirs(path)：刪除路徑所指的目錄

   • 擴充套件：利用 shutil（shell utility）模組刪除帶檔案的目錄

     ​ shutil.rmtree(path)：徹底刪除，慎用

2. 和路徑相關的操作

   和路徑相關的操作，都被封裝在了 os 模組的子模組 os.path 中。

   • 目錄路徑:

     ​ os.path.dirname(path):它不判斷路徑是否真是存在，直接返回目錄路徑。

     res = os.path.dirname(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # d:\dsa\dsad
     

   • 檔名:

     ​ os.path.basename(path):它不判斷路徑是否真實存在，返回檔名。

     res = os.path.basename(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # asdas.aaa
     

   • 分割目錄路徑與檔名:

     ​ os.path.split(path):它不判斷路徑是否真實存在，將目錄路徑和檔名分開作為元組返回。

     res = os.path.split(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # ('d:\\dsa\\dsad', 'asdas.aaa')
     

   • 拼接路徑:

     ​ os.path.join(path, paths):它不判斷路徑是否真實存在，拼接路徑，返回拼接後的路徑。

     path = os.path.join('d:\\', 'aaa', 'bbb.as')
     print(path)  # d:\aaa\bbb.as
     

   • 絕對路徑:

     ​ os.path.abspath(path):它不判斷路徑是否真實存在，如果是\開頭的路徑，返回的絕對路徑是在當前碟符下，如果不是\開頭，返回的絕對路徑是當前專案路徑。

     path = os.path.abspath(r'\a\b\c')
     print(path)  # D:\a\b\c
     path = os.path.abspath(r'a\b\c')
     print(path)  # D:\Python\Python Project\day16\a\b\c
     

   • 判斷絕對路徑:

     ​ os.path.isabs(path):它不判斷路徑是否真實存在，返回布林值判斷傳入路徑是否是絕對路徑。

     print(os.path.isabs('a.txt'))  # False
     print(os.path.isabs(r'c:\a.txt'))  # True
     

   • 判斷目錄:

     ​ os.path.isdir(path):會判斷目錄是否真實存在，如果不是目錄或者不存在會返回False。

     print(os.path.isdir(r'c:\Python'))  # True
     

   • 判斷存在:

     ​ os.path.exists(path):會判斷目錄或者檔案是否真實存在，返回布林值。

     print(os.path.exists(r'c:\Python'))  # True
     

   • 判斷檔案:

     ​ os.path.isfile(path):會判斷檔案是否真實存在，如果不是檔案或檔案不存在返回False。

     print(os.path.isfile(r'c:\Python'))  # False
     

   • 判斷快捷方式:

     ​ os.path.islink(path):會判斷快捷方式是否真實存在，如果不存在或者不是快捷方式返回False。

六、sys 模組

封裝和 Python 直譯器相關的操作。

1. 命令列引數 sys,agrv

   全稱為 argument variable 獲取命令列引數，以列表形式返回，列表第一個元素為檔案路徑。

   print(sys.argv)
   # ['D:/Python/Python Project/day16/04 sys模組.py']
   

2. 模組查詢路徑sys.path

   以列表形式返回模組查詢路徑，可以在程式中動態地臨時修改。

3. 已載入模組sys.modules

   返回系統已經載入的模組，以字典形式返回，不可以動態地修改（可能會引起程式錯誤）。

七、json 模組

是 JavaScript Object Notation 的簡稱，是一種簡單的資料交換格式，用於結構化資料和線性資料的轉化，而 json 只能將資料和字串之間進行轉化，用於儲存或者網路傳輸（不太徹底，沒有徹底轉換為二進位制位元組形式）。

1. 序列化過程和反序列化過程

   • 序列化過程 serialization ：將結構化資料轉化為線性資料，將記憶體中的資料轉換成位元組形式用以儲存在檔案或網路傳輸。
   • 反序列化過程 deserialization ：將線性資料轉化為結構化資料，將網路中獲取的資料，轉換成記憶體中原來的資料型別。

2. json.dump()和json.dumps()

   # json.dump()
   s = json.dumps([1,2,3])  # 把指定的物件轉換成json格式的字串
   print(s)  # '[1, 2, 3]'
   s = json.dumps((1, 2, 3))  # 元組序列化後,會變成列表
   print(s)  # '[1, 2, 3]'
   res = json.dumps(10)
   print(res)  # '10'
   res = json.dumps({'name':'andy', 'age': 10})
   print(res)  # '{"name": "andy", "age": 10}'
   # res = json.dumps(set('abs'))  # TypeError: Object of type 'set' is not JSON serializable
   
   
   # 將json結果寫入到檔案中,通過json.dump()
   with open(r'json.txt',encoding='utf-8',mode='a') as file_handler:
       json.dump([1, 2, '12'], file_handler)
   

3. json.load()和json.loads()

   # 反序列化
   res = json.dumps([1, 2, 3])
   lst = json.loads(res)
   print(type(lst))  # <class 'list'>
   print(lst)  # [1, 2, 3]
   # 元組反序列化變為列表
   res = json.dumps((1,2,3))
   lst = json.loads(res)
   print(type(lst))  # <class 'list'>
   print(lst)  # [1, 2, 3]
   
   
   
   # 從檔案中反序列化
   with open(r'json.txt', encoding='utf-8') as file_handler:
       res = json.load(file_handler)  # json檔案通常是一次性寫一次性讀,所以json.load()只能一次性讀檔案
       print(type(res))  # <class 'list'>
       print(res)  # [1, 2, '12']
   

   # 另一種方式,可以實現多次寫多次讀:把需要序列化的物件,通過多次序列化的方式,
   # 用檔案的write方法,把多次序列化後的json字串寫到檔案中
   with open('json.txt', mode='a', encoding='utf-8') as file_handler:
       file_handler.write(json.dumps([1, 2, 3]) + '\n')
       file_handler.write(json.dumps([4, 5, 6]) + '\n')
   # 反序列化同理
   

八、pickle 模組

用以序列化過程和反序列化過程，將 Python 中所有的資料轉換成位元組形式；基本使用方法與 json 模組相同。

import pickle
bys = pickle.dumps((1,2,3))
print(type(bys))  # <class 'bytes'>
print(bys)  # b'\x80\x03K\x01K\x02K\x03\x87q\x00.'

res = pickle.loads(bys)
print(res)  # (1, 2, 3)
print(type(res))  # <class 'tuple'>
# 可以序列化\反序列化任何資料型別
bys = pickle.dumps(set('abc'))
res = pickle.loads(bys)
print(res)  # {'b', 'c', 'a'}
print(type(res))  # <class 'set'>


# pickle.dump和load序列化和反序列化可以多次讀取,與json不同
# 把pickle序列化內容寫入檔案(二進位制不涉及到encoding所以不設定encoding參實)
with open('pickle.txt', mode='wb') as file_handler:
    pickle.dump([1, 2, 3], file_handler)
    pickle.dump([3, 4, 5], file_handler)

# 反序列化
with open('pickle.txt', mode='rb') as file_handler:
    ret1 = pickle.load(file_handler)
    ret2 = pickle.load(file_handler)
    print(ret1, type(ret1))  # [1, 2, 3] <class 'list'>
    print(ret2, type(ret2))  # [3, 4, 5] <class 'list'>
# 在使用過程中要一次寫一次讀,多次會亂

json 模組和 pickle 模組的對比：

九、hashlib 模組

用以封裝一些加密的類。

1. 加密

   • 加密的目的：用於判斷和驗證，而並非解密
   • 加密的特點：
     • 把一個大的資料，切分成不同塊進行加密，再彙總的結果，和直接對整體資料加密的結果是一致的。
     • 單向加密不可逆。
     • 原始資料一丁點小的變化，會導致結果有非常大的差異，即"雪崩"效應。

2. md5 加密演算法

   # 獲取一個加密物件
   m = hashlib.md5()
   # 使用加密物件的update,進行加密
   m.update(b'abc')
   res1 = m.hexdigest()
   m.update('中文'.encode('utf-8'))  # 只能接受二進位制型別，中文轉化成二進位制
   res2 = m.hexdigest()
   print(res1, res2)  # 900150983cd24fb0d6963f7d28e17f72 1af98e0571f7a24468a85f91b908d335
   

3. 資料加密的三大步驟

   • 獲取一個加密物件
   • 使用加密物件的 update 演算法（可以呼叫多次疊加加密）
   • 通過 hexdigest() 方法或者 digest() 獲取加密結果

4. 不同加密方法的區別

   # 不同的加密演算法：實際上就是加密結果的長度不同
   s = hashlib.sha224()
   s.update(b'abc')
   print(s.hexdigest())  # 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7
   
   print(hashlib.md5().hexdigest())  # d41d8cd98f00b204e9800998ecf8427e
   print(hashlib.sha1().hexdigest())  # da39a3ee5e6b4b0d3255bfef95601890afd80709
   print(hashlib.sha256().hexdigest())  # e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
   

5. 加密物件的 salt

   在建立加密物件時，可以指定引數，稱為 salt 。

   hashlib.md5(b'abc')  # 相當於update了,與update結果是相同的
   

十、collection 模組

定義了一些容器類，包括collection.namedtuple()、collection.defaultdict()、collection.Counter()等。

1. namedtuple()命名元組

   # namedtuple():命名元組
   from collections import namedtuple
   # 定義一個Rectangle類(自己定義的類名習慣上首字母大寫)
   Rectangle = namedtuple('this_s_a_rectangle_class', ['length', 'width'])
   # Rectangle類的使用
   r = Rectangle(10, 5)
   # 通過屬性訪問元組的元素
   print(r.length)  # 10
   print(r.width)  # 5
   # 通過索引的方式訪問元素
   print(r[0])  # 10
   print(r[1])  # 5
   

2. defaultdict()預設值字典

   from collections import defaultdict
   dic = defaultdict(lambda :10,name='andy',age=10)
   print(dic['name'])  # andy
   # 索引沒有定義的值時，會按照工廠函式預設新增一個鍵值對，工廠函式不能有引數傳入
   print(dic['ad'])  # 10
   print(dic)  # defaultdict(<function <lambda> at 0x000001DFCFEDBD90>, {'name': 'andy', 'age': 10, 'ad': 10})
   

3. Counter()計數器

   from collections import Counter
   c = Counter('saddasadsad312544444sas')
   print(c)  # Counter({'s': 5, 'a': 5, '4': 5, 'd': 4, '3': 1, '1': 1, '2': 1, '5': 1})
   print(c.most_common(2))  # [('s', 5), ('a', 5)]