[ python ] 經常使用模塊

時間 2019-11-07

原文原文鏈接

collections 模塊

在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：node

nametuple: 生成能夠使用名字來訪問元素內容的tuple
deque: 雙端隊列，能夠快速的從另一側追加和推出對象
OrderedDict: 計數器，主要用來計數
defaultdict: 有序字典
Counter: 帶有默認值的字典

nametuplepython

咱們知道tuple能夠表示不變集合，例如，一個點的二維座標就能夠表示成：shell

>>> t = (1,2)

可是，看到(1, 2)，很難看出這個tuple是用來表示一個座標的。
這時，namedtuple就派上了用場：bash

In [1]: from collections import namedtuple

In [2]: Point = namedtuple('Point', ['x', 'y'])

In [3]: p = Point(1, 2)

In [4]: p
Out[4]: Point(x=1, y=2)

In [5]: p.x
Out[5]: 1

In [6]: p.y
Out[6]: 2

相似的，若是要用座標和半徑表示一個圓，也能夠用namedtuple定義：app

#namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

使用該屬性還能夠運用在紙牌遊戲中，花色和數字才能肯定的表示一張牌。dom

dequeide

使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了。由於list是線性存儲，數據量大的時候，插入和刪除效率很低。函數

deque是爲了高效實現插入和刪除操做的雙向列表，適合用於隊列和棧：ui

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。spa

OrderedDict

使用dict時，key是無序的。在對dict作迭代時，咱們沒法肯定key的順序
若是要保持key的順序，能夠用OrderDict:

In [29]: from collections import OrderedDict

In [30]: d = dict([('a', 1), ('b', 2), ('c', 3)])

In [31]: d	# d 是無序的字典
Out[31]: {'a': 1, 'b': 2, 'c': 3}

In [32]: od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

In [33]: od	# od 是有序的字典
Out[33]: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderDict 的key會按照插入的順序排序，不是key自己排序：

In [35]: od['z'] = 1

In [36]: od['y'] = 2

In [37]: od['x'] = 3

In [38]: od.keys()	# 按照插入的Key的順序返回
Out[38]: odict_keys(['z', 'y', 'x'])

定義的OrderDict使用方式和普通的字典同樣，只是比普通的字典多了一個有序的功能

defaultdict

有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。
即： {'k1': 大於66 , 'k2': 小於66}

values = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]

my_dict = {}

for value in values:
    if value > 60:
        if 'k1' in my_dict:
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value, ]
    elif value < 60:
        if 'k2' in my_dict:
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value, ]

print(my_dict)

原生字典解決方法

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list) # 設置字典中，每一個元素都是一個list，list的key值由下面隨意定義

for value in values:
    if value > 60:
        my_dict['k1'].append(value)
    elif value < 60:
        my_dict['k2'].append(value)


print(my_dict)
print(my_dict['aaaaaaa']) # 隨意定義的key值都會對應一個list

# 執行結果：
# []
# defaultdict(<class 'list'>, {'k1': [66, 77, 88, 99, 90], 'asdfadfasdf': [], 'k2': [11, 22, 33, 44, 55]})

defaultdict字典解決方法

使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdict：

注意：使用 defaultdict 設置默認值是沒法使用常量的，若是要設置常量爲默認值，須要藉助 lambda來設置，以下：

In [39]: from collections import defaultdict

In [40]: dd = defaultdict(lambda: 'N/A')	# 藉助 lambda 來設置常量 'N/A'

In [41]: dd['key1'] = 'abc'	

In [43]: dd['key1']	# 'key1'存在
Out[43]: 'abc'

In [44]: dd['key2']	# 'key2'不存在則返回默認值
Out[44]: 'N/A'

Counter

Counter類的目的是用來跟蹤值出現的次數。它是一個無序的容器類型，以字典的鍵值對形式存儲，其中元素做爲key，其計數做爲value。計數值能夠是任意的interger（包括0和負數）。

In [45]: from collections import Counter

In [46]: c = Counter('adfasdfawrsadfadfasdfzcv')

In [47]: print(c)	# 統計每一個字符出現的次數並生成一個字典類型
Counter({'a': 6, 'f': 5, 'd': 5, 's': 3, 'w': 1, 'c': 1, 'v': 1, 'r': 1, 'z': 1})

In [48]: print(c['a'])	# 能夠單獨獲取某個字符的次數，使用方法和字典取值同樣
6

時間模塊：time

和時間有關係的咱們就要用時間模塊。在使用模塊以前，應該首先導入這個模塊。

#經常使用方法
1.time.sleep(secs)
(線程)推遲指定的時間運行。單位爲秒。
2.time.time()
獲取當前時間戳

表示時間的三種方式：

在python中，一般有這三種方式來表示時間：時間戳、元組、格式化的時間字符串：
（1）時間戳（timestamp）: 一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。
（2）格式化的時間字符串（Format String）：'1990-12-06'

%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號自己

python中時間日期格式化符號

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

首先，咱們先導入time模塊，來認識一下python中表示時間的幾種格式：

In [1]: from collections import namedtuple
In [49]: import time

In [50]: time.time()
Out[50]: 1539398412.6536071	# 時間戳

In [51]: time.strftime('%Y%m%d %X')
Out[51]: '20181013 10:40:40'	# 格式化時間

In [52]: time.localtime()
Out[52]: time.struct_time(tm_year=2018, tm_mon=10, tm_mday=13, tm_hour=10, tm_min=40, tm_sec=47, tm_wday=5, tm_yday=286, tm_isdst=0)	# 結構化時間

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

三種格式之間的轉換

In [6]: time.localtime(1500000000)
Out[6]: time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

時間戳 --> 結構化時間：time.localtime

In [7]: time.mktime(time.localtime(1500000000))
Out[7]: 1500000000.0

結構化時間 --> 時間戳: time.mktime

In [12]: time.strftime('%Y%m%d %H:%M:%S', time.localtime(1500000000))
Out[12]: '20170714 10:40:00'

結構化時間 --> 格式化時間: time.strftime

In [14]: time.strptime('20170714 10:40:00', '%Y%m%d %H:%M:%S')
Out[14]: time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=-1)

格式化時間 --> 結構化時間：time.strptime

In [16]: time.asctime(time.localtime(1500000000))
Out[16]: 'Fri Jul 14 10:40:00 2017'

結構化時間 --> %a %b %d %H:%M:%S %Y串：time.asctime

In [17]: time.ctime(1500000000)
Out[17]: 'Fri Jul 14 10:40:00 2017'

時間戳 --> %a %b %d %H:%M:%S %Y串: time.ctime

做業：

　　計算2008-1-1 00:00:00 到如今過去了幾年幾月幾日幾時幾分幾秒

import time

true_time = time.strptime('2008-1-1 00:00:00', '%Y-%m-%d %H:%M:%S')
now_time = time.localtime(time.time())
print('2008-如今過去了%d年%d月%d日%d時%d分%d秒' % (now_time.tm_year - true_time.tm_year,
                                        now_time.tm_mon - true_time.tm_mon,
                                        now_time.tm_mday - true_time.tm_mday,
                                        now_time.tm_hour - true_time.tm_hour,
                                        now_time.tm_min - true_time.tm_min,
                                        now_time.tm_sec - true_time.tm_sec))

time模塊做業

隨機模塊：random模塊

# 隨機小數
In [2]: random.random()	
Out[2]: 0.2835506853671552	# 大於0且小於1之間的小數

In [3]: random.uniform(1,3) # 大於1小於3的小數
Out[3]: 2.6577326276294753

# 隨機整數
In [4]: random.randint(1,5)	# 大於等於1且小於等於5之間的整數
Out[4]: 2

In [5]: random.randrange(1, 10, 2)	# 大於等於1且小於10之間的奇數
Out[5]: 9

# 隨機選擇一個返回
In [6]: random.choice([1, '23', [4,5]])	# 1或者23或者[4,5]
Out[6]: [4, 5]

# 隨機選擇多個返回，返回的個數爲函數的第二個參數
In [7]: random.sample([1, '23', [4,5]],2)	# 列表元素任意2個組合
Out[7]: [[4, 5], 1]

# 打亂列表順序
In [9]: item = [1, 3, 5, 7, 9]

In [10]: random.shuffle(item)	# 打亂次序

In [11]: item
Out[11]: [3, 9, 1, 5, 7]

In [12]: random.shuffle(item)

In [13]: item
Out[13]: [9, 5, 1, 3, 7]

做業：

　　隨機生成驗證碼。

import random

def v_code():
    code = ''
    for i in range(5):
        num = random.randint(0,9)
        alf = chr(random.randint(65, 90))
        add = random.choice([num, alf])
        code += str(add)
        # code = ''.join([code, str(add)])
    return code

print(v_code())

隨機驗證碼做業

操做系統相關模塊：os模塊

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.system("bash command")  運行shell命令，直接顯示
os.popen("bash command).read()  運行shell命令，獲取執行結果
os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd


os.path
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的大小

注意：os.stat('path/filename') 獲取文件/目錄信息的結構說明

st_mode: inode 保護模式
st_ino: inode 節點號。
st_dev: inode 駐留的設備。
st_nlink: inode 的連接數。
st_uid: 全部者的用戶ID。
st_gid: 全部者的組ID。
st_size: 普通文件以字節爲單位的大小；包含等待某些特殊文件的數據。
st_atime: 上次訪問的時間。
st_mtime: 最後一次修改的時間。
st_ctime: 由操做系統報告的"ctime"。在某些系統上（如Unix）是最新的元數據更改的時間，在其它系統上（如Windows）是建立時間（詳細信息參見平臺的文檔）。

stat 結構

os模塊的屬性

os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep    輸出當前平臺使用的行終止符，win下爲"\r\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'

python解釋器環境相關：sys模塊

sys模塊是與python解釋器交互的一個接口

sys.argv           命令行參數List，第一個元素是程序自己路徑
sys.exit(n)        退出程序，正常退出時exit(0),錯誤退出sys.exit(1)
sys.version        獲取Python解釋程序的版本信息
sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform       返回操做系統平臺名稱