python常用模塊

re模塊

一、正則表達式

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

1、字符組 ： [字符組]

在同一個位置可能出現的各種字符組成了一個字符組，在正則表達式中用[]表示?
字符分為很多類，比如數字、字母、標點等等。?
假如你現在要求一個位置”只能出現一個數字”,那么這個位置上的字符只能是0、1、2…9這10個數之一。

2、字符

元字符：?
.:匹配除換行符以外的任意字符?
\w:匹配字母或數字或下劃線?
\s:匹配任意的空白符?
\d:匹配數字?
\n:匹配一個換行符?
\t:匹配一個制表符?
\b:匹配一個單詞的結尾?
^:匹配字符串的開始?
$:匹配字符串的結尾?
\W:匹配非字母或數字或下劃線?
\D:匹配非數字?
\S:匹配非空白符?
a|b:匹配字符a或字符b?
():匹配括號內的表達式，也表示一個組

3、量詞：

*:匹配零次或更多次?
+:匹配一次或更多次?
?:匹配零次或一次?
{n}:匹配n次?
{n,}:匹配n次或更多次?
{n,m}:匹配n次至m次

4、.*$的用法：

5、*+?{ }的用法：

6、字符集［］［^］用法：

7、分組 ()與 或 ｜［^］用法：

8、轉義符 \用法：

9、貪婪匹配用法：

二、python中re模塊及常用方法

1、介紹

re 模塊使 Python 語言擁有全部的正則表達式功能 re 模塊也提供了與這些方法功能完全一致的函數，這些函數使用一個模式字符串做為它們的第一個參數

2、常用方法

• • 參數說明：?
    pattern —— 匹配的正則表達式?
    string —— 待匹配的字符串?
    flags —— 標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等

  • 匹配對象方法：?
    group(num=0) —— 匹配的整個表達式的字符串，group() 可以一次輸入多個組這里寫代碼片號，在這種情況下它將返回一個包含那些組所對應值的元組?
    groups() —— 返回一個包含所有小組字符串的元組，從1到所含的小組號

  • ①☆findall()返回所有滿足匹配條件的結果至列表中

import re res = re.findall('s','life is short') print(res) >>> ['s','s']

• ②☆search() 返回第一個包含匹配條件的信息對象，可以調用該對象的group()方法將匹配的字符輸出，如果沒有匹配到則調用group()方法會報錯

import re res = re.search('s','life is short') print(res.group()) >>> 's'

• ③☆match() 與search()方法類似，但是僅在字符串開始出匹配，返回第一個包含匹配條件的信息對象，調用該對象的group()方法將匹配的字符輸出，如果沒有匹配到則調用group()方法會報錯

import re res = re.match('l','life is short') print(res.group()) >>> 'l'

• ④split() 逐個按符合條件的字符串對待匹配字符串進行切分，返回結果列表

import re res = re.split('[ab]','abcd') # 首先按'a'進行切分，形成['','bcd']，之后再按'b'進行切分，形成['','','cd'] print(res) >>> ['','','cd']

• ⑤sub() 將待匹配字符串中滿足匹配條件的內容進行替換，最后一個參數指定替換的次數，返回替換后的字符串

import re res = re.sub('\d','_','life8is7short7',2) print(res) >>> 'life_is_short7'

• ⑥subn() 與sub()方法類型，但是無法指定替換的次數，并且輸出的是一個元組，包括替換后的字符串和替換的總次數

import re res = re.subn('\d','_','life8is7short7') print(res) >>> ('life_is_short_', 3)

• ⑦compile() 將正則表達式編譯成為一個正則表達式對象，之后可以用re模塊中的方法對對象進行操作

import re obj = re.compile('\d{3}') res = obj.search('123abc456') 或者res = re.search(obj,'123abc456') print(res.group())

• ⑧finditer() finditer返回一個存放匹配結果的迭代器，用next等方法取出存放結果的對象，再用group()方法取出結果

import re res = re.finditer('\d','a1b2c3d4e5') print(next(res).group()) print(next(res).group()) print(next(res).group()) print([i.group() for i in res]) >>> 1 >>> 2 >>> 3 >>> ['4', '5']

• ★findall的優先級查詢: 將findall()方法中匹配條件中加括號后，只會輸出匹配到的字符串；可以在括號中加入?:取消權限

import re res = re.findall('www.(baidu|google).com','www.baidu.com') print(res) >>> ['baidu']#取消權限 import re res = re.findall('www.(?:baidu|google).com','www.baidu.com') print(res) >>> ['www.baidu.com']

• ★split的優先級查詢:將split()方法中的匹配條件加括號后，會將滿足條件的切分字符也輸出值最終列表中，同樣可以在括號中加入?:取消權限

import re res = re.split('(\d)','life1is2short3') print(res) >>> ['life', '1', 'is', '2', 'short', '3', '']#取消權限 import re res = re.split('(?:\d)','life1is2short3') print(res) >>> ['life', 'is', 'short', '']

collections模塊

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

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

from collections import namedtuple Point = namedtuple('point',['x','y']) p1 = Point(1,2) p2 = Point(99,100)print(p1.x) print(p1.y) print(p2)>>> 1 >>> 2 >>> point(x=99, y=100)

2.deque: 雙端隊列，可以快速的從另外一側追加和推出對象

使用list存儲數據時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性存儲，數據量大的時候，插入和刪除效率很低。?
deque是為了高效實現插入和刪除操作的雙向列表，適合用于隊列和棧：

from collections import deque dq = deque(['A','B','C']) dq.append('X') dq.appendleft('Y') print(dq) >>> deque(['Y', 'A', 'B', 'C', 'X'])print(dq.pop()) >>> Xprint(dq.popleft()) >>> Ydq.insert(1,666) print(dq) >>> deque(['A', 666, 'B', 'C'])

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

from collections import Counter c = Counter('aaabbbbcccddddddeeeeffffff') print(c) >>> Counter({'d': 6, 'f': 6, 'e': 4, 'b': 4, 'c': 3, 'a': 3})

4.OrderedDict: 有序字典

使用dict時，Key是無序的。在對dict做迭代時，我們無法確定Key的順序。?
如果要保持Key的順序，可以用OrderedDict：

from collections import OrderedDict od = OrderedDict([('a',1),('b',2),('c',3)]) print(od) print(od['a']) print(od['b']) print(od['c'])>>> OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> 1 >>> 2 >>> 3

5.defaultdict: 帶有默認值的字典

from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90]dd = defaultdict(list) dd['k1'].append(1) dd['k1'].append(2) dd['k1'].append(3) dd['k1'].append(4) dd['k1'].append(5) print(dd) >>> defaultdict(<class 'list'>, {'k1': [1, 2, 3, 4, 5]})

時間模塊

一、表示時間的三種方式

1、時間戳（timestamp）

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

import time print(time.time()) >>> 1515570662.77503

2、時間字符串（Format String

import time print(time.strftime("%Y-%m-%d %H-%M-%S")) >>> 2018-01-10 15-59-16

3、結構化時間（struct_time

import time print(time.localtime()) >>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=16, tm_min=0, tm_sec=33, tm_wday=2, tm_yday=10, tm_isdst=0)

二、幾種格式之間的轉換

1、時間戳–>結構化時間

語法： time.gmtime(時間戳) #UTC時間，與英國倫敦當地時間一致 time.localtime(時間戳) #當地時間。例如我們現在在北京執行這個方法：與UTC時間相差8小時，UTC時間+8小時 = 北京時間 import time print(time.localtime(1515570662.77503)) >>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=15, tm_min=51, tm_sec=2, tm_wday=2, tm_yday=10, tm_isdst=0) import time print(time.gmtime(1515570662.77503)) >>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=7, tm_min=51, tm_sec=2, tm_wday=2, tm_yday=10, tm_isdst=0)

2、結構化時間–>時間戳

語法： time.mktime(結構化時間) import time time_tuple = time.localtime(1500000000) print(time.mktime(time_tuple)) >>> 1500000000.0

3、字符串時間–>結構化時間

語法： time.strptime(時間字符串,字符串對應格式) import time print(time.strftime("%Y-%m-%d %X")) >>> 2018-01-10 16:19:46 print(time.strftime("%Y-%m-%d",time.localtime(1515570662.77503))) >>> 2018-01-10

4、結構化時間–>字符串時間

語法: time.strftime(“格式定義”,”結構化時間”) 結構化時間參數若不傳，則現實當前時間 import time print(time.strptime("2017-03-16","%Y-%m-%d")) >>> 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) print(time.strptime("07/24/2017","%m/%d/%Y")) >>> 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)

random模塊

一、常用方法

1、隨機小數

import random print(random.random()) # 隨機輸出在0-1之間的小數 >>> 0.11828833626857149import random print(random.uniform(1,5)) # 隨機輸出在范圍之間的小數 >>> 2.164732131520036

2、隨機整數

import random print(random.randint(5,10)) # randint中的范圍包括首尾 >>> 8import random print(random.randrange(5,10,2)) # randrange中的范圍顧首不顧尾，可以指定步長 >>> 7

3、隨機選擇一個返回

import random print(random.choice([1,'23',[4,5],(6,7)])) >>> (6, 7)

4、隨機選擇多個返回，可以指定返回的個數

import random print(random.sample([1,'23',[4,5],(6,7)],2)) >>> [(6, 7), 1]

5、打亂順序

import random item=[1,2,3,4,5,6,7,8,9] random.shuffle(item) print(item) >>> [2, 6, 8, 3, 5, 4, 7, 1, 9]

二、應用實例

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())

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') 獲取文件/目錄信息 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.popen("bash command) 運行shell命令，獲取執行結果 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的大小

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)

序列化模塊

一、定義

將原本的字典、列表等內容轉換成一個字符串的過程叫做序列化，其反過程叫反序列化。

二、目的

以某種存儲形式使自定義對象持久化

將對象從一個地方傳遞到另一個地方

使程序更具維護性

三、過程

• 字符串——反序列化——>其他數據結構
• 字符串<——序列化——其他數據結構

四、序列化相關模塊

1、json:用于字符串(包括其他支持json的語言)和python數據類型間進行轉換

• • ①dumps、loads 內存操作，dumps用于將結構化數據轉化成字符串，loads用于將字符串轉化為結構化數據?

注意，json轉換完的字符串類型的字典中的字符串是由”“表示的 import json dic = {'k1':'v1','k2':'v2','k3':'v3'} dic_d = json.dumps(dic) print(dic_d) >>> {"k2": "v2", "k3": "v3", "k1": "v1"}dic_s = json.loads(dic_d) print(dic_s) >>> {'k1': 'v1', 'k3': 'v3', 'k2': 'v2'}

• ②dump、load 文件句柄操作，dumps用于將結構化數據轉化成字符串并操作文件句柄存儲于文件中， loads用于將字符串轉化為結構化數據并操作文件句柄將數據從文件中讀至內存

import json dic = {'k1':'v1','k2':'v2','k3':'v3'} with open('json_file',mode='w') as f:dic_fd=json.dump(dic,f) 文件中的內容： >>> {"k3": "v3", "k2": "v2", "k1": "v1"}with open('json_file',mode='r') as f:dic_fs=json.load(f) print(dic_fs) >>> {'k1': 'v1', 'k3': 'v3', 'k2': 'v2'}

• ③ensure_ascii關鍵字參數：ensure_ascii默認True，如果數據中包括非ascii字符，則會以bytes類型數據存儲在文件中，若將ensure_ascii改為False，則會以人類可識別字符存儲

import json# 默認ensure_ascii是True，說明支持系統用ascii編碼進行數據存儲，所以數據在文件中是以bytes類型(utf-8/utf-16/GBK)等方式進行 # 存儲的，人類不能直接識別文件中的中文數據內容，如果非要識別則需要進行解碼操作； # 如果將ensure_ascii改為False，則在數據存儲時就將數據按照人類可識別的內容進行存儲，可直接閱讀 dic = {'姓名':'張三','性別':'男','年齡':'18'} with open('json_file',mode='w') as f:dic_fd = json.dump(dic,f) >>> {"\u5e74\u9f84": "18", "\u6027\u522b": "\u7537", "\u59d3\u540d": "\u5f20\u4e09"}str1 = b'\u5e74\u9f84' print (str1.decode('unicode_escape')) >>> 年齡dic = {'姓名':'張三','性別':'男','年齡':'18'} with open('json_file',mode='w') as f:dic_fd = json.dump(dic,f,ensure_ascii=False) >>> 亂碼，因為在windows系統下默認用GBK存儲，但是道理沒變，如果是內存操作，則可以通過pycharm是utf-8的字符編碼直接讀出

④其他參數說明

• Skipkeys：默認值是False，如果dict的keys內的數據不是python的基本類型(str,unicode,int,long,float,bool,None)，設置為False時，就會報TypeError的錯誤。此時設置成True，則會跳過這類key

• ensure_ascii:，當它為True的時候，所有非ASCII碼字符顯示為\uXXXX序列，只需在dump時將ensure_ascii設置為False即可，此時存入json的中文即可正常顯示。)

• indent：應該是一個非負的整型，如果是0就是頂格分行顯示，如果為空就是一行最緊湊顯示，否則會換行且按照indent的數值顯示前面的空白分行顯示，這樣打印出來的json數據也叫pretty-printed json

• separators：分隔符，實際上是(item_separator, dict_separator)的一個元組，默認的就是(‘,’,’:’)；這表示dictionary內keys之間用“,”隔開，而KEY和value之間用“：”隔開。

• sort_keys：將數據根據keys的值進行排序。

import json data = {'username':['張三','李四'],'sex':'male','age':16} json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False) print(json_dic2)\>\>\> {"age":16,"sex":"male","username":["張三","李四"]}

2、pickle:用于python特有的類型和python的數據類型間進行轉換

注意：

• ①與json相似，pickle提供的方法與json相同，不同的是pickle可以轉換python特有的數據類型，而非只有dic、list(tuple)
• ②pickle在文件存儲時，使用bytes類型進行存儲，所以在讀寫文件的時候要求mode為wb/rb模式

3、shelve:只提供一個open方法，用key來訪問，使用起來與字典類似

• ①序列化到文件、從文件反序列化

import shelve with shelve.open('shelve_file') as f:f['key'] = {1,2,3,4,5,6,7,8,9}import shelve with shelve.open('shelve_file') as f:data = f['key'] print(data) >>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

• ②該模塊不支持多個應用同一時間往同一個DB進行寫操作。所以當我們知道我們的應用如果只進行讀操作，我們可以讓shelve通過只讀方式打開DB。

import shelve with shelve.open('shelve_file',flag='r') as f:data = f['key'] print(data) >>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

• ③??? 該模塊在默認情況下不會記錄待持久化對象的任何修改，所以需要在shelve.open()時修改默認參數，否則對象的修改不會保存。

import shelve with shelve.open('shelve_file', writeback=True) as f2:print('修改前：'+ str(f2['key']))f2['key'] = 'this was not here before' >>> 修改前：{1, 2, 3, 4, 5, 6, 7, 8, 9}with shelve.open('shelve_file', writeback=True) as f3:print('修改后：'+str(f3['key'])) >>> 修改后：this was not here before

?

轉載于:https://www.cnblogs.com/lidaxu/p/8277245.html

總結

以上是生活随笔為你收集整理的python_fullstack基础(十一)-常用模块的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。