1、re模塊

re模塊用于對python的正則表達式的操作

1.1 什么是正則

正則就是用一些具有特殊含義的符號組合到一起(稱為正則表達式)來描述字符或者字符串的方法。或者說：正則就是用來描述一類事物的規則。(在Python中)它內嵌在Python中，并通過 re 模塊實現。正則表達式模式被編譯成一系列的字節碼，然后由用 C 編寫的匹配引擎執行。

1.2 常用匹配模式(元字符)

'.' 默認匹配除\n之外的任意一個字符，若指定flag DOTALL,則匹配任意字符，包括換行

'^' 匹配字符開頭，若指定flags MULTILINE,這種也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$' 匹配字符結尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以

'*' 匹配*號前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 結果為['abb', 'ab', 'a']

'+' 匹配前一個字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 結果['ab', 'abb']

'?' 匹配前一個字符1次或0次

'{m}' 匹配前一個字符m次

'{n,m}' 匹配前一個字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 結果'abb', 'ab', 'abb']

'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結果'ABC'

'(...)' 分組匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結果 abcabca456c

'[a-z]' 匹配a到z任意一個字符

'[^()]' 匹配除()以外的任意一個字符

r' ' 轉義引號里的字符 針對\字符 詳情查看⑦

'\A' 只從字符開頭匹配，re.search("\Aabc","alexabc") 是匹配不到的

'\Z' 匹配字符結尾，同$

'\d' 匹配數字0-9

'\D' 匹配非數字

'\w' 匹配[A-Za-z0-9]

'\W' 匹配非[A-Za-z0-9]

'\s' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 結果 '\t'

'(?P...)' 分組匹配 re.search("(?P[0-9]{4})(?P[0-9]{2})(?P[0-9]{4})","371481199306143242").groupdict("city")

結果{'province': '3714', 'city': '81', 'birthday': '1993'}

re.IGNORECASE 忽略大小寫 re.search('(\A|\s)red(\s+|$)',i,re.IGNORECASE)

貪婪模式、懶惰模式：

import re

print(re.findall('a.*c','a123c456c'))

輸出結果如下：

C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe C:/Users/Administrator/PycharmProjects/python18/day6/正則re.py

['a123c456c']

1.3 match：

從起始位置開始根據模型去字符串中匹配指定內容：

import re

obj = re.match('\d+', '123uua123sf') #<==從第一個字符開始匹配一個到多個數字

print(obj)

#<_sre.sre_match object span="(0," match="123"> #<==輸出結果

if obj: #<==如果有匹配到字符則執行，為空不執行

print(obj.group()) #<==打印匹配到的內容

#123 #<==輸出結果

匹配ip地址：

import re

ip = '255.255.255.253'

result=re.match(r'^([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.'

r'([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])$',ip)

print(result)

# <_sre.sre_match object span="(0," match="255.255.255.253">

1.4 search：

根據模型去字符串中匹配指定內容(不一定是最開始位置)，匹配最前

#search

import re

obj = re.search('\d+', 'a123uu234asf') #從數字開始匹配一個到多個數字

print(obj)

#<_sre.sre_match object span="(1," match="123">

if obj: #如果有匹配到字符則執行，為空不執行

print(obj.group()) #打印匹配到的內容

#123

import re

obj = re.search('\([^()]+\)', 'sdds(a1fwewe2(3uusfdsf2)34as)f') #匹配最里面()的內容

print(obj)

#<_sre.sre_match object span="(13," match="(3uusfdsf2)">

if obj: #如果有匹配到字符則執行，為空不執行

print(obj.group()) #打印匹配到的內容

#(3uusfdsf2)

1.5 group與groups的區別：

#group與groups的區別

import re

a = "123abc456"

b = re.search("([0-9]*)([a-z]*)([0-9]*)", a)

print(b)

#<_sre.sre_match object span="(0," match="123abc456">

print(b.group())

#123abc456

print(b.group(0))

#123abc456

print(b.group(1))

#123

print(b.group(2))

#abc

print(b.group(3))

#456

print(b.groups())

#('123', 'abc', '456')

1.6 findall：

上述兩中方式均用于匹配單值，即：只能匹配字符串中的一個，如果想要匹配到字符串中所有符合條件的元素，則需要使用?findall；findall沒有group用法

#findall

import re

obj = re.findall('\d+', 'a123uu234asf') #匹配多個

if obj: #如果有匹配到字符則執行，為空不執行

print(obj) #生成的內容為列表

#['123', '234']

1.7 sub：

用于替換匹配的字符串(pattern, repl, string, count=0, flags=0)

#sub

import re

content = "123abc456"

new_content = re.sub('\d+', 'ABC', content)

print(new_content)

#ABCabcABC

1.8 split：

根據指定匹配進行分組(pattern, string, maxsplit=0, flags=0)

#split

import re

content = "1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )"

new_content = re.split('\*', content) #用*進行分割，分割為列表

print(new_content)

#['1 - 2 ', ' ((60-30+1', '(9-2', '5/3+7/3', '99/4', '2998+10', '568/14))-(-4', '3)/(16-3', '2) )']

content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"

new_content = re.split('[\+\-\*\/]+', content)

# new_content = re.split('\*', content, 1)

print(new_content)

#["'1 ", ' 2 ', ' ((60', '30', '1', '(9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14))',

# '(', '4', '3)', '(16', '3', "2) )'"]

inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))'

inpp = re.sub('\s*','',inpp) #把空白字符去掉

print(inpp)

new_content = re.split('\(([\+\-\*\/]?\d+[\+\-\*\/]?\d+){1}\)', inpp, 1)

print(new_content)

#['1-2*((60-30+', '-40-5', '*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']

1.9 補充r' ' 轉義：

#文件njx.txt

fdfdsfds\fds

sfdsfds& @$

首先要清楚，程序讀取文件里的\字符時，添加到列表里面的是\\：

import re,sys

ning = []

with open('njx.txt','r',encoding="utf-8") as file:

for line in file:

ning.append(line)

print(ning) # 注意：文件中的單斜杠，讀出來后會變成雙斜杠

# ['fdfdsfds\\fds\n', 'sfdsfds& @$']

print(ning[0]) # print打印的時候還是單斜杠

# fdfdsfds\fds

r字符的意義，對字符\進行轉義，\只做為字符出現：

import re,sys

ning = []

with open('njx.txt','r',encoding="utf-8") as file:

for line in file:

print(re.findall(r's\\f', line)) #第一種方式匹配

# print(re.findall('\\\\', line)) #第二種方式匹配

ning.append(line)

print(ning) # 注意：文件中的單斜杠，讀出來后會變成雙斜杠

# ['s\\f']

# []

# ['fdfdsfds\\fds\n', 'sfdsfds& @$']

補充：看完下面的代碼你可能更懵了

import re

re.findall(r'\\', line) # 正則中只能這樣寫 不能寫成 r'\' 這樣

print(r'\\') # 只能這樣寫 不能寫成r'\' \只能是雙數

# \\ 結果

# 如果想值打印單個\ 寫成如下

print('\\') # 只能是雙數

# \ 結果

總結：文件中的單斜杠\，讀出到程序中時是雙斜杠\\，print打印出來是單斜杠\；正則匹配文件但斜杠\時,用r'\\'雙斜杠去匹配，或者不用r直接用'\\\\'四個斜杠去匹配

1.10 compile函數：

說明：

Python通過re模塊提供對正則表達式的支持。使用re的一般步驟是先使用re.compile()函數，將正則表達式的字符串形式編譯為Pattern實例，然后使用Pattern實例處理文本并獲得匹配結果(一個Match實例)，最后使用Match實例獲得信息，進行其他的操作

舉一個簡單的例子，在尋找一個字符串中所有的英文字符：

import re

pattern = re.compile('[a-zA-Z]')

result = pattern.findall('as3SiOPdj#@23awe')

print(result)

# ['a', 's', 'S', 'i', 'O', 'P', 'd', 'j', 'a', 'w', 'e']

匹配IP地址(255.255.255.255)：

import re

pattern = re.compile(r'^(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])$')

result = pattern.match('255.255.255.255')

print(result)

# <_sre.sre_match object span="(0," match="255.255.255.255">

2 、time模塊

在Python中，通常有這幾種方式來表示時間：

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

格式化的時間字符串(Format String)

結構化的時間(struct_time)：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時)

import time

#--------------------------我們先以當前時間為準,讓大家快速認識三種形式的時間

print(time.time()) # 時間戳:1487130156.419527

print(time.strftime("%Y-%m-%d %X")) #格式化的時間字符串:'2017-02-15 11:40:53'

print(time.localtime()) #本地時區的struct_time

print(time.gmtime()) #UTC時區的struct_time

其中計算機認識的時間只能是'時間戳'格式，而程序員可處理的或者說人類能看懂的時間有: '格式化的時間字符串'，'結構化的時間'?，于是有了下圖的轉換關系

#--------------------------按圖1轉換時間

# localtime([secs])

# 將一個時間戳轉換為當前時區的struct_time。secs參數未提供，則以當前時間為準。

time.localtime()

time.localtime(1473525444.037215)

# gmtime([secs]) 和localtime()方法類似，gmtime()方法是將一個時間戳轉換為UTC時區(0時區)的struct_time。

# mktime(t) : 將一個struct_time轉化為時間戳。

print(time.mktime(time.localtime()))#1473525749.0

# strftime(format[, t]) : 把一個代表時間的元組或者struct_time(如由time.localtime()和

# time.gmtime()返回)轉化為格式化的時間字符串。如果t未指定，將傳入time.localtime()。如果元組中任何一個

# 元素越界，ValueError的錯誤將會被拋出。

print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

# time.strptime(string[, format])

# 把一個格式化時間字符串轉化為struct_time。實際上它和strftime()是逆操作。

print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

# tm_wday=3, tm_yday=125, tm_isdst=-1)

#在這個函數中，format默認為："%a %b %d %H:%M:%S %Y"。

#--------------------------按圖2轉換時間

# asctime([t]) : 把一個表示時間的元組或者struct_time表示為這種形式：'Sun Jun 20 23:21:05 1993'。

# 如果沒有參數，將會將time.localtime()作為參數傳入。

print(time.asctime())#Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一個時間戳(按秒計算的浮點數)轉化為time.asctime()的形式。如果參數未給或者為

# None的時候，將會默認time.time()為參數。它的作用相當于time.asctime(time.localtime(secs))。

print(time.ctime()) # Sun Sep 11 00:46:38 2016

print(time.ctime(time.time())) # Sun Sep 11 00:46:38 2016

#--------------------------其他用法

# sleep(secs)

# 線程推遲指定的時間運行，單位為秒。

3、random模塊

import random

# print(random.sample([1,'23',[4,5]],2))

#

# print(random.uniform(1,3))

#

# item=[1,3,5,7,9]

# random.shuffle(item)

# print(item)

def make_code(n):

res=''

for i in range(n):

s1=str(random.randint(0,9))

s2=chr(random.randint(65,90))

res+=random.choice([s1,s2])

return res

print(make_code(10))

4、os模塊

os模塊是與操作系統交互的一個接口

#os模塊

import 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 #輸出用于分割文件路徑的字符串

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所指向的文件或者目錄的最后修改時間

5、sys模塊

用于提供對解釋器相關的操作

#sys模塊

import sys

sys.argv #命令行參數List，第一個元素是程序本身路徑

sys.exit(n) #退出程序，正常退出時exit(0)

sys.version # 獲取Python解釋程序的版本信息

sys.maxint #最大的Int值

sys.path #返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值

sys.platform #返回操作系統平臺名稱

sys.stdout.write('please:')

def progress(percent,width=50): #51

if percent >= 100:

# print('\r[%s] 100%%' %(width*'#'))

percent=100

show_str=('[%%-%ds]' %width) %(int(width*percent/100)*'#')

print('\r%s %d%%' %(show_str,percent),file=sys.stdout,flush=True,end='')

#

total_size=1025121

recv_size=0

while recv_size < total_size:

time.sleep(0.01) #模擬下載的網絡延遲

recv_size+=1024

recv_per=int(100*recv_size/total_size)

progress(recv_per,width=10)

6、json 和?pickle模塊

文件只能存二進制或字符串，不能存其他類型，所以用到了用于序列化的兩個模塊：

json，用于字符串和python數據類型間進行轉換，將數據通過特殊的形式轉換為所有語言都認識的字符串(字典，變量，列表)

pickle，用于python特有的類型和python的數據類型間進行轉換，將數據通過特殊的形式轉換為只有python認識的字符串(函數，類)

json模塊

#json 序列化和反序列化

import json

info ={　　　　　　　　　　　　　　 #字典

"name":"jun",

"age":"18"

}

with open("test","w") as f:

f.write(json.dumps(info)) #用json把info寫入到文件test中

with open("test","r") as f:

info = json.loads(f.read())

print(info["name"])

#jun

pickle模塊

#pickle 序列化和反序列化

import pickle　　　　　　　　#pickle支持python特有的所有類型

def func(): #函數

info ={

"name":"jun",

"age":"18"

}

print(info,type(info))

func()

#{'age': '18', 'name': 'jun'}

with open("test","wb") as f:

f.write(pickle.dumps(func)) #用pickle把func寫入到文件test中 如果用json此時會報錯

with open("test","rb") as f:

func_new = pickle.loads(f.read())

func_new()

#{'age': '18', 'name': 'jun'}

7、shelve模塊

shelve模塊內部對pickle進行了封裝，shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的python數據格式

import shelve

# k，v方式存儲數據

s = shelve.open("shelve_test") # 打開一個文件

tuple = (1, 2, 3, 4)

list = ['a', 'b', 'c', 'd']

info = {"name": "jun", "age": 18}

s["tuple"] = tuple # 持久化元組

s["list"] = list

s["info"] = info

s.close()

# 通過key獲取value值

d = shelve.open("shelve_test") # 打開一個文件

print(d["tuple"]) # 讀取

print(d.get("list"))

print(d.get("info"))

# (1, 2, 3, 4)

# ['a', 'b', 'c', 'd']

# {'name': 'jun', 'age': 18}

d.close()

# 循環打印key值

s = shelve.open("shelve_test") # 打開一個文件

for k in s.keys(): # 循環key值

print(k)

# list

# tuple

# info

s.close()

# 更新key的value值

s = shelve.open("shelve_test") # 打開一個文件

s.update({"list":[22,33]}) #重新賦值或者s["list"] = [22,33]

print(s["list"])

#[22, 33]

s.close()

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的python pp模块_python常用模块的全部內容，希望文章能夠幫你解決所遇到的問題。

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