day5-python之經常使用模塊

時間 2019-11-13

標籤 day5 day python 經常使用模塊欄目 Python 简体版

原文原文鏈接

1、經常使用模塊一

# 模塊 == .py文件html

# 模塊是寫好了但不直接使用的功能node

# 模塊分爲三種：內置模塊、擴展模塊、自定義模塊python

# 參考資料：# https://pypi.orggit

1. collections模塊

在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。程序員

(1) namedtuple: 生成可使用名字來訪問元素內容的tuple

tuple能夠表示不變集合，例如，一個點的二維座標就能夠表示成：正則表達式

p = (1,2)shell

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

from collections import namedtuple
point = namedtuple('point',['x','y'])
p = point(1,2)
print(p.x)
print(p.y)

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

from collections import namedtuple
# namedtuple('名稱',[屬性list]):
circle = namedtuple('circle',['x','y','r'])
c = circle(1,2,3)
print(c.x)
print(c.y)
print(c.r)

(2) deque: 雙端隊列，能夠快速的從另一側追加和推出對象

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

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

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
# 輸出結果：deque(['y', 'a', 'b', 'c', 'x'])

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

(3) Counter: 計數器，主要用來計數

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

from collections import Counter
c = Counter('abcdeabcdabcaba')
print(c)
# 輸出結果：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

其餘詳細內容：http://www.cnblogs.com/Eva-J/articles/7291842.html

(4) OrderedDict: 有序字典

使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。

若是要保持Key的順序，能夠用OrderedDict：

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)   # dict的Key是無序的
# 輸出結果：{'a': 1, 'c': 3, 'b': 2}
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)  # OrderedDict的Key是有序的
# 輸出結果：OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key會按照插入的順序排列，不是Key自己排序：

from collections import OrderedDict
od = OrderedDict()
od['z'] = 1
od['y'] = 2
od['x'] = 3
print(od.keys())   # 按照插入的Key的順序返回
# 輸出結果：odict_keys(['z', 'y', 'x'])

(5) defaultdict: 帶有默認值的字典

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

即： {'k1': 大於66 , 'k2': 小於66}

from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict)

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

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
print(dd['key1']) # key1存在

print(dd['key2']) # key2不存在，返回默認值

2. time模塊

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

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

表示時間的三種方式

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

(1)時間戳(timestamp) ：一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。

(2)格式化的時間字符串(Format String)： ‘1999-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 當前時區的名稱
%% %號自己

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

# 導入時間模塊
import time

# 時間戳
print(time.time())   # 時間戳時間 英國倫敦時間 1970 1 1 0 0 0
print(time.time())   # 時間戳時間 北京時間 1970 1 1 8 0 0

# 時間字符串  格式化時間  用字符串表示的時間
print(time.strftime('%H:%M:%S'))
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%x'))
print(time.strftime('%c'))

# 時間元組  結構化時間  localtime將一個時間戳轉換爲當前時區的struct_time
t = time.localtime()
print(t)

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

幾種格式之間的轉換：

#時間戳-->結構化時間
#time.gmtime(時間戳)    #UTC時間，與英國倫敦當地時間一致
#time.localtime(時間戳) #當地時間。例如咱們如今在北京執行這個方法：與UTC時間相差8小時，UTC時間+8小時 = 北京時間
import time
print(time.gmtime(1500000000))
# 輸出結果：time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
print(time.localtime(1500000000))
# 輸出結果：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.mktime(結構化時間)
time_tuple = time.localtime(1500000000)
t = time.mktime(time_tuple)
print(t)
# 輸出結果：1500000000.0

#結構化時間-->字符串時間
#time.strftime("格式定義","結構化時間")  結構化時間參數若不傳，則現實當前時間
t = time.strftime("%Y-%m-%d %X")
print(t)
# 輸出結果：'2017-07-24 14:55:36'
t = time.strftime("%Y-%m-%d",time.localtime(1500000000))
print(t)
# 輸出結果：'2017-07-14'

#字符串時間-->結構化時間
#time.strptime(時間字符串,字符串對應格式)
t1 = time.strptime("2017-03-16","%Y-%m-%d")
print(t1)
# 輸出結果：time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
t2 = time.strptime("07/24/2017","%m/%d/%Y")
print(t2)
# 輸出結果：time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

#結構化時間 --> %a %b %d %H:%M:%S %Y串
#time.asctime(結構化時間) 若是不傳參數，直接返回當前時間的格式化串
import time
t = time.asctime(time.localtime(1500000000))
print(t)
# 輸出結果：'Fri Jul 14 10:40:00 2017'
t = time.asctime()
print(t)
# 輸出結果：'Mon Jul 24 15:18:33 2017'

#時間戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(時間戳)  若是不傳參數，直接返回當前時間的格式化串
t = time.ctime()
print(t)
# 輸出結果：'Mon Jul 24 15:19:07 2017'
t = time.ctime(1500000000)
print(t)
# 輸出結果：'Fri Jul 14 10:40:00 2017'

計算時間差

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('過去了%d年%d月%d天%d小時%d分鐘%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

3. random模塊

import random

#隨機小數
print(random.random())      # 大於0且小於1之間的小數
# 0.7664338663654585
print(random.uniform(1,3))  #大於1小於3的小數
# 1.6270147180533838
#恆富：發紅包

#隨機整數
print(random.randint(1,5))       # 大於等於1且小於等於5之間的整數
print(random.randrange(1,10,2))  # 大於等於1且小於10之間的奇數

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

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

練習：生成隨機驗證碼

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="".join([code,str(add)])
    return code

print(v_code())

4. sys模塊

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

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

異常處理和status

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)

5. os模塊

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')  獲取文件/目錄信息
# Linux和windows的差別
os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
# 在python中執行操做系統的命令
os.system("bash command")  運行shell命令，直接顯示
os.popen("bash command).read()  運行shell命令，獲取執行結果
# 查看python中環境變量
os.environ  獲取系統環境變量

# 路徑相關
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') 獲取文件/目錄信息的結構說明

stat 結構:
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）是建立時間（詳細信息參見平臺的文檔）。

6. re模塊

假如用python寫一段代碼，相似：

phone_number = input('please input your phone number ： ')

怎麼判斷ohone_number是否合法？

根據手機號碼一共11位而且是隻以1三、1四、1五、18開頭的數字這些特色，咱們用python寫了以下代碼：

while True:
     phone_number = input('please input your phone number ： ')
     if len(phone_number) == 11 \
             and phone_number.isdigit()\
             and (phone_number.startswith('13') \
             or phone_number.startswith('14') \
             or phone_number.startswith('15') \
             or phone_number.startswith('18')):
         print('是合法的手機號碼')
     else:
         print('不是合法的手機號碼')

正則表達式寫法

import re
 phone_number = input('please input your phone number ： ')
 if re.match('^(13|14|15|18)[0-9]{9}$',phone_number):
         print('是合法的手機號碼')
 else:
         print('不是合法的手機號碼')

python裏的re模塊和正則表達式，正則表達式不只在python領域，在整個編程屆都佔有舉足輕重的地位。

無論之後你是否是去作python開發，只要你是一個程序員就應該瞭解正則表達式的基本使用。若是將來你要在爬蟲領域發展，你就更應該好好學習這方面的知識。

可是你要知道，re模塊本質上和正則表達式沒有一毛錢的關係。re模塊和正則表達式的關係 相似於 time模塊和時間的關係

你沒有學習python以前，也不知道有一個time模塊，可是你已經認識時間了 12:30就表示中午十二點半（這個時間可好，通常這會兒就該下課了）。

時間有本身的格式，年月日時分秒，12個月，365天......已經成爲了一種規則。你也早就牢記於心了。time模塊只不過是python提供給咱們的能夠方便咱們操做時間的一個工具而已

正則表達式自己也和python沒有什麼關係，就是匹配字符串內容的一種規則。

官方定義：正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個「規則字符串」，這個「規則字符串」用來表達對字符串的一種過濾邏輯。

1）正則表達式

在線測試工具：http://tool.chinaz.com/regex/

首先你要知道的是，談到正則，就只和字符串相關了。在我給你提供的工具中，你輸入的每個字都是一個字符串。

其次，若是在一個位置的一個值，不會出現什麼變化，那麼是不須要規則的。
　　
好比你要用"1"去匹配"1"，或者用"2"去匹配"2"，直接就能夠匹配上。這連python的字符串操做均可以輕鬆作到。

那麼在以後咱們更多要考慮的是在同一個位置上能夠出現的字符的範圍。

字符組 ： [字符組]
在同一個位置可能出現的各類字符組成了一個字符組，在正則表達式中用[]表示
字符分爲不少類，好比數字、字母、標點等等。
假如你如今要求一個位置"只能出現一個數字",那麼這個位置上的字符只能是0、一、2...9這10個數之一。

字符組：

字符：

量詞：

. ^ $

* + ? { }

注意：前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

字符集 [] [^]

分組 ()與或｜［^］

身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有由數字組成，首位不能爲0；若是是18位，則前17位所有是數字，末位多是數字或x，下面咱們嘗試用正則來表示：

轉義符

在正則表達式中，有不少有特殊意義的是元字符，好比\d和\s等，若是要在正則中匹配正常的"\d"而不是"數字"就須要對""進行轉義，變成'\'。

在python中，不管是正則表達式，仍是待匹配的內容，都是以字符串的形式出現的，在字符串中\也有特殊的含義，自己還須要轉義。因此若是匹配一次"\d",字符串中要寫成'\d'，那麼正則裏就要寫成"\\d",這樣就太麻煩了。這個時候咱們就用到了r'\d'這個概念，此時的正則是r'\d'就能夠了。

貪婪匹配

貪婪匹配：在知足匹配時，匹配儘量長的字符串，默認狀況下，採用貪婪匹配

幾個經常使用的非貪婪匹配Pattern

*? 重複任意次，但儘量少重複
+? 重複1次或更屢次，但儘量少重複
?? 重複0次或1次，但儘量少重複
{n,m}? 重複n到m次，但儘量少重複
{n,}? 重複n次以上，但儘量少重複

.*?的用法

. 是任意字符
* 是取 0 至 無限長度
? 是非貪婪模式。
何在一塊兒就是 取儘可能少的任意字符，通常不會這麼單獨寫，他大多用在：
.*?x

就是取前面任意長度的字符，直到一個x出現

2）re模塊下的經常使用方法

import re

ret = re.findall('a', 'eva egon yuan')  # 返回全部知足匹配條件的結果,放在列表裏
print(ret) #結果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #結果 : 'a'
# 函數會在字符串內查找模式匹配,只到找到第一個匹配而後返回一個包含匹配信息的對象,該對象能夠
# 經過調用group()方法獲得匹配的字符串,若是字符串沒有匹配，則返回None。

ret = re.match('a', 'abc').group()  # 同search,不過盡在字符串開始處進行匹配
print(ret)
#結果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割獲得''和'bcd',在對''和'bcd'分別按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#將數字替換成'H'，參數1表示只替換1個
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#將數字替換成'H'，返回元組(替換的結果,替換了多少次)
print(ret)

obj = re.compile('\d{3}')  #將正則表達式編譯成爲一個 正則表達式對象，規則要匹配的是3個數字
ret = obj.search('abc123eeee') #正則表達式對象調用search，參數爲待匹配的字符串
print(ret.group())  #結果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一個存放匹配結果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一個結果
print(next(ret).group())  #查看第二個結果
print([i.group() for i in ret])  #查看剩餘的左右結果

注意：

1 findall的優先級查詢：

import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     這是由於findall會優先把匹配結果組裏內容返回,若是想要匹配結果,取消權限便可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

2 split的優先級查詢

ret=re.split("\d+","eva3egon4yuan")
print(ret) #結果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #結果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）以後所切出的結果是不一樣的，
#沒有（）的沒有保留所匹配的項，可是有（）的卻可以保留了匹配的項，
#這個在某些須要保留匹配部分的使用過程是很是重要的。