python必学的模块_Python常用的模块
模塊和包
1.1模塊介紹模塊定義:一系列功能的集合體
模塊使用: import導入模塊 或者 from ... import... 導入模塊
模塊分類:內置模塊 自定義模塊 第三方模塊
模塊加載順序: 內存>內置>sys.path(環境變量中的路徑時逐一加載的)
模塊起別名: import 模塊名 as 別名
模塊兩種被執行方式:
1.一個py文件作為自執行文件，__name__變量的值為 '__main__'
if __name__ == '__main__':
# 自執行的邏輯 => 因為在文件作為模塊使用時 __name__為文件名，不滿足條件
pass
2.一個py文件作為模塊被導入執行，__name__變量的值為 '文件(模塊)名'
此時被其他使用
1.2 包的介紹包的定義:
一系列模塊的集合體,用文件件來管理一系列有聯系的功能的模塊,該文件夾稱之為包,文件夾名就是包名包與普通文件夾的區別:
包的文件夾中一定存在一個__init__.py文件文件__init__.py文件的作用
1 產生一個全局名稱空間提供給包使用 此名稱空間就是包的名稱空間
2 管理包 包可以直接點出來模塊使用導包完成的三件事
# 導包完成的三件事
# 1）編譯形成包中__init__.py文件的pyc文件
# 2）執行__init__.py文件，形成一個全局名稱空間，將__init__.py文件中所有名字存放其中，該名稱空間就代表包的名稱空間
# 3）在導包的文件中，產生一個與包名相同的名字，指向包的名稱空間(__init__.py文件的全局名稱空間)包的管理
# 在包中采用相對導入管理模塊或模塊中的名字
# 在包的__init__.py文件或是包中任意一個模塊中
# . 代表當前文件所在目錄
# .. 代表當前文件所在目錄的上一級目錄
# 注：.語法不能出包，因為包外的文件都能自執行，但擁有.開頭導入的文件不能自執行
1.3 項目開發周期
'''1.調研2.需求分析3.架構師完成項目demo，完成項目架構4.分工5.寫代碼6.白盒黑盒測試7.項目審核發布 => 項目 -> 產品'''
'''bin: 可執行文件，入口，入口也可以放在項目根目錄下core: 核心代碼db：數據庫相關文件interface：接口lib：包、模塊、第三方文件夾log：日志setting：配置static：靜態文件'''
1.4 time 模塊 (重點)
可以用來計算時間
"""時間戳(timestamp)：time.time() 用于數據的唯一標識 從1970年開始算的延遲線程的運行：time.sleep() # 幾秒之后才去執行(指定時間戳下的)當前時區時間：time.localtime()(指定時間戳下的)格林威治時間：time.gmtime()(指定時間元組下的)格式化時間：time.strftime(fmt[,tupletime])"""
案例
import time
# 格林威治時間
time_obj2 = time.gmtime()
print(time.time()) # 時間戳，用于數據的唯一標識
# 格式化時間
# Y-m-d H:M:S 代表 年 月 日 時 分 秒
# (2019, 5, 6, 6, 16, 9, 0, 126, 0)
res = time.strftime("%Y-%m-%d%H:%M:%S")
print(res)
res = time.strftime("%Y-%m-%d%H:%M:%S", (2008, 8, 8, 8, 8, 8, 0, 0, 0))
print(res)
# 計算時間
starttime = time.time()
def fn():
time.sleep(3)
return time.time()
res = fn() - starttime
print(res)
1.5 datetime模塊
和time模塊功能重復 掌握time模塊就好
"""當前時間：datetime.datetime.now()昨天：datetime.datetime.now() + datetime.timedelta(days=-1)修改時間：datetime_obj.replace([...])格式化時間戳：datetime.date.fromtimestamp(timestamp)"""
1.6 calendar模塊
"""
判斷閏年：calendar.isleap(year)
查看某年某月日歷：calendar.month(year, mouth)
查看某年某月起始星期與當月天數：calendar.monthrange(year, mouth)
查看某年某月某日是星期幾：calendar.weekday(year, month, day)
"""
import calendar
print(calendar.isleap(2200))
print(calendar.month(2019, 5))
print(calendar.monthrange(2019, 5))
print(calendar.weekday(2019, 5, 7))
1.7 os模塊 (重點)
重點掌握
生成單級目錄：os.mkdir('dirname')
生成多層目錄：os.makedirs('dirname1/.../dirnamen2')
列舉目錄下所有資源：os.listdir('dirname')
刪除文件：os.romeve('file_path')
刪除單層空目錄：os.rmdir('dirname')
移除多層空目錄：os.removedirs('dirname1/.../dirnamen')
# os.mkdir('abc') # 在當前文件所在路徑下創建abc文件夾
# os.mkdir('D:\\abc') # 就是在指定的絕對路徑下創建abc文件夾
# os.mkdir('a/b/c') # a,b必須提前存在，c不能存在
# os.makedirs(r'a\b\c') # a,b存在與否都可以，c不能存在
不常用
'''工作目錄：os.getcwd()刪除文件：os.romeve('file_path')刪除單層空目錄：os.rmdir('dirname')移除多層空目錄：os.removedirs('dirname1/.../dirnamen')路徑分隔符：os.sep行終止符：os.linesep文件分隔符：os.pathsep操作系統名：os.name操作系統環境變量：os.environ執行shell腳本：os.system()'''
1.8 os.path 系統路徑操作 (重點)
重點掌握
'''目標大小：os.path.getsize(path)上一級目錄：os.path.dirname(path)上上級目錄os.path.dirname(os.path.dirname(__file__))路徑拼接：os.path.join(path1[, path2[, ...]])指定路徑是否存在：os.path.exists(path)'''
不常用
'''是否是文件：os.path.isfile(path)是否是路徑：os.path.isdir(path)返回path規范化的絕對路徑：os.path.abspath(path)最后一級名稱：os.path.basename(path)是否是絕對路徑：os.path.isabs(path)最后存取時間：os.path.getatime(path)最后修改時間：os.path.getmtime(path)將path分割成目錄和文件名二元組返回：os.path.split(path)'''
part1_path = os.path.join(BASE_DIR, 'part1') # => BASE_DIR + os.sep + 'part1'
sys.path.append(part1_path)
part3_path = os.path.join(BASE_DIR, 'part3')
sys.path.append(part3_path)
print(sys.path)
1.9 sys 系統
'''命令行參數List，第一個元素是程序本身路徑：sys.argv退出程序，正常退出時exit(0)：sys.exit(n)獲取Python解釋程序的版本信息：sys.version最大int值：sys.maxsize | sys.maxint環境變量：sys.path操作系統平臺名稱：sys.platform'''
1.10 跨文件夾移動文件 (os,os.path模塊操作案例)
part5
----mm.py
part6
----abc
----os.py(就是下面的代碼)
# 將part5下的mm.py移動到part6下abc文件夾中
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)
def move_file(file, folder):
if not (os.path.exists(file) and os.path.isfile(file)):
print('文件不存在或非法')
return False
if not os.path.exists(folder):
os.makedirs(folder)
file_name = os.path.split(file)[1]
# file_name = os.path.basename(file)
new_file = os.path.join(folder, file_name)
with open(file, 'rb') as rf, open(new_file, 'wb') as wf:
for line in rf:
wf.write(line)
os.remove(file)
# 將目標文件夾下的目標文件移動到指定文件夾下
file = os.path.join(BASE_DIR, 'part5', 'mm.py')
folder = os.path.join(BASE_DIR, 'part6', 'abc')
move_file(file, folder)
1.11 random 隨機數 (重點)
'''(0, 1)：random.random() # 0 到1之間的隨機小數[1, 10]：random.randint(1, 10) # 0 到10之間的隨機整數數 含1和10[1, 10)：random.randrange(1, 10) # 左包又不不包(1, 10)：random.uniform(1, 10) # 兩邊不包含 是小數單例集合隨機選擇1個：random.choice(item)單例集合隨機選擇n個：random.sample(item, n)洗牌單列集合：random.shuffle(item)'''
1.12 json : 序列化 (重點)
json語言,是一種有語法規范的字符串,是用來存放數據的,主要用來各語言之間的數據交互,最常見與前后端交互
1.就是{}和[]的組合,{}存放雙列信息(類比字典) ,[]存放單列信息(類比列表)
2.{}的key必須是字符串,并且用""包裹(雙引號)
3.{},[]中的值支持的類型 :dict |list| int |float| bool| str| null序列化 將對象轉化為字符串
反序列化 將字符串轉化為對象
# 序列化：將對象轉換為字符串
#json.dumps()： 將 Python 對象編碼成 JSON 字符串
# json.dump()： 將Python內置類型序列化為json對象后寫入文件
obj = {'name': 'Owen', "age": 18, 'height': 180, "gender": "男"}
r1 = json.dumps(obj, ensure_ascii=False) # 取消默認ascii編碼，同該文件的編碼 utf-8 py3默認，py2規定文件頭
print(r1)
# {"name": "Owen", "age": 18, "height": 180, "gender": "男"}
with open('1.txt','w',encoding='utf-8') as wf: # 若沒有1.txt會創建
json.dump(obj,wf,ensure_ascii=False)
# 將轉化后的json字符串{"name": "Owen", "age": 18, "height": 180, "gender": "男"}寫入1.txt中
# 反序列化：將字符串轉換為對象
# json.load() 讀取文件中json形式的字符串元素轉化為Python類型
# json.loads() 將已編碼的 JSON 字符串解碼為 Python 對象
json_str = '{"name": "Owen", "age": 18, "height": 180, "gender": "男"}'
r2 = json.loads(json_str, encoding='utf-8') # 默認跟當前文件被解釋器執行的編碼走
print(r2, type(r2))
with open('1.txt', 'r', encoding='utf-8') as rf:
r3 = json.load(rf)
print(r3, type(r3))
1.13 pickle 序列化與反序列化
# 為什么有很多序列化和反序列化模塊
# 因為程序中會出現各種各樣的對象，如果要將這些對象持久化存儲，必須先序列化
# 只有序列化存儲后，必須有對應的反序列化，才能保證存儲的數據能被重新讀取使用
# 什么是序列化：對象 => 字符串
# 為什么序列化：存 或 傳
# 為什么要反序列化：再次使用
# 為什么有很多序列化模塊：存與取的算法可以多種多樣，且要配套
import pickle
obj = {"name": 'Owen', "age": 18, "height": 180, "gender": "男"}
# 序列化
r1 = pickle.dumps(obj)
print(r1)
with open('2.txt', 'wb') as wf:
pickle.dump(obj, wf)
# 反序列化
with open('2.txt', 'rb') as rf:
data = rf.read()
o1 = pickle.loads(data)
print(o1, type(o1))
rf.seek(0, 0) # 游標移到開頭出現讀
o2 = pickle.load(rf)
print(o2, type(o2))
1.14 shelve 序列化 反序列化 (不常用)
# 將序列化文件操作dump與load進行封裝
shv_dic = shelve.open("target_file") # 注：writeback允許序列化的可變類型，可以直接修改值
# 序列化：存
shv_dic['key1'] = 'value1'
shv_dic['key2'] = 'value2'
# 文件這樣的釋放
shv_dic.close()
shv_dic = shelve.open("target_file", writeback=True)
# 存 可變類型值
shv_dic['info'] = ['原數據']
# 取 可變類型值，并操作可變類型
# 將內容從文件中取出，在內存中添加, 如果操作文件有writeback=True，會將內存操作記錄實時同步到文件
shv_dic['info'].append('新數據')
# 反序列化：取
print(shv_dic['info']) # ['原數據', '新數據']
shv_dic.close()
1.15 hashlib 加密 (重點)
# 不可逆加密：沒有解密的加密方式 md5
# 解密方式：碰撞解密
# 加密的對象：用于傳輸的數據（字符串類型數據）
# 一次加密：
# 1.獲取加密對象 hashlib.md5() => lock_obj
# 2.添加加密數據 lock_obj.update(b'...') ... lock_obj.update(b'...')
# 3.獲取加密結果 lock.hexdigest() => result
lock = hashlib.md5()
res = lock.hexdigest()
print(res)
# 加鹽加密
# 1.保證原數據過于簡單，通過復雜的鹽也可以提高解密難度
# 2.即使被碰撞解密成功，也不能直接識別鹽與有效數據
lock_obj = hashlib.md5()
lock_obj.update(b'goodgoodstudy')
lock_obj.update(b'123')
lock_obj.update(b'daydayup')
res = lock_obj.hexdigest()
print(res)
# 了了解：其他算法加密
lock_obj = hashlib.sha3_256(b'1')
print(lock_obj.hexdigest())
lock_obj = hashlib.sha3_512(b'1')
print(lock_obj.hexdigest())
1.16 shutil 文件操作
# 基于路徑的文件復制：
shutil.copyfile('source_file', 'target_file')
# 基于流的文件復制：
with open('source_file', 'rb') as r, open('target_file', 'wb') as w:
shutil.copyfileobj(r, w)
# 遞歸刪除目標目錄
shutil.rmtree('target_folder')
# 文件移動
shutil.move('old_file', 'new_file')
# 文件夾壓縮
# file_name：被壓縮后形成的文件名 format：壓縮的格式 archive_path：要被壓縮的文件夾路徑
shutil.make_archive('file_name', 'format', 'archive_path')
# 文件夾解壓
# unpack_file：被解壓文件 unpack_name：解壓后的名字 format解壓格式
shutil.unpack_archive('unpack_file', 'unpack_name', 'format')
1.17 logging日志模塊 (重點)logging模塊是python提供的用于記錄日志的模塊
日志級別
隨著時間的推移,日志記錄會非常多,成千上萬行,如何快速找到需要的日志記錄這就成了問題
解決的方案就是 給日志劃分級別
logging模塊將日志分為了五個級別,從高到低分別是:
1.debug 調試信息
2.info 常規信息
3.warning 警告信息
4.error 錯誤信息
5.cretical 嚴重錯誤
本質上他們使用數字來表示級別的,從高到低分別是10,20,30,40,50使用
import logging
import sys
# logging配置：格式化輸出 1）輸出的方式 2）輸出的格式 3）輸出的位置
h1 = logging.StreamHandler()
h2 = logging.FileHandler('d.log')
logging.basicConfig(
# filename='my.log',
# filemode='w',
# stream=sys.stderr, # 往控制臺打印采用具體的輸出流
format='%(asctime)s[%(levelname)s]-%(name)s:%(message)s',
datefmt='%Y-%m-%d%H:%M:%S',
level=logging.DEBUG, # 10, 代表DEBUG及DEBUG級別以上都能輸出
handlers=[h1, h2]
)
logging.debug("debug")
logging.info("info")
logging.warning("warning")
logging.error("error")
logging.critical("critical")
# 對比sys.stdout | sys.stderr有什么優勢
#
logging的最低顯示級別為warning,對應的數值為30
日志被打印到了控制臺
日志輸出格式為:級別 日志生成器名稱 日志消息
1.17-1 自定義日志配置
import logging
logging.basicConfig()
"""可用參數filename：用指定的文件名創建FiledHandler（后邊會具體講解handler的概念），這樣日志會被存儲在指定的文件中。filemode：文件打開方式，在指定了filename時使用這個參數，默認值為“a”還可指定為“w”。format：指定handler使用的日志顯示格式。datefmt：指定日期時間格式。level：設置rootlogger（后邊會講解具體概念）的日志級別"""
#案例:
logging.basicConfig(
filename="aaa.log",
filemode="at",
datefmt="%Y-%m-%d%H:%M:%S %p",
format="%(asctime)s-%(name)s-%(levelname)s-%(module)s:%(message)s",
level=10
)
1.71-2 logging模塊的四個核心角色
1.Logger 日志生成器 產生日志
2.Filter 日志過濾器 過濾日志
3.Handler 日志處理器 對日志進行格式化,并輸出到指定位置(控制臺或文件)
4.Formater 處理日志的格式
# 1.新建打印者
logger = logging.getLogger("Owen")
# 2.創建句柄：輸出的位置
stream_handler = logging.StreamHandler()
a_file_handler = logging.FileHandler('a.log')
b_file_handler = logging.FileHandler('b.log')
# 3.打印者綁定句柄
logger.addHandler(stream_handler)
logger.addHandler(a_file_handler)
logger.addHandler(b_file_handler)
# 4.設置格式
fmt1 = logging.Formatter('%(asctime)s-%(msg)s')
fmt2 = logging.Formatter('%(asctime)s[%(name)s] -%(msg)s')
# 5.為句柄綁定輸出格式
stream_handler.setFormatter(fmt1)
a_file_handler.setFormatter(fmt1)
b_file_handler.setFormatter(fmt2)
logger.critical('msg')
1.71-3 多輸出者
import logging
# 1.創建logger
log1 = logging.getLogger('Owen')
log2 = logging.getLogger('Zero')
r_log = logging
# 2.logger設置級別
log1.setLevel(logging.DEBUG)
# 3.設置句柄
h1 = logging.StreamHandler()
# 4.設置句柄級別：
# 1）系統句柄默認級別warning，
# 2）自定義的句柄級別默認同logger，也可以在logger基礎上在加以限制
h1.setLevel(logging.DEBUG)
# 5.logger添加句柄
log1.addHandler(h1)
# log1可以打印DEBUG以上的信息，但往不同位置打印，采用不同句柄的二次級別限制
h2 = logging.FileHandler('c.log')
h2.setLevel(logging.WARNING)
log1.addHandler(h2)
log1.debug('debug')
log1.info('info')
log1.warning('warning')
log1.error('error')
log1.critical('critical')
log2.critical('00000')
r_log.critical('00000')
1.71-4 配置文件的使用
# 1.配置
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'o_fmt1': {
'format': '%(name)s:%(asctime)s-%(message)s'
},
'o_fmt2': {
'format': '%(name)s:%(asctime)s[%(levelname)s] -%(message)s'
}
},
'filters': {},
'handlers': {
'o_cmd': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'o_fmt1'
},
'o_file': {
'level': 'WARNING',
'class': 'logging.handlers.RotatingFileHandler',
'formatter': 'o_fmt2',
'filename': r'F:\python8期\課堂內容\day20\代碼\part4\logging.log', # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5, #日志文件最大個數
'encoding': 'utf-8', # 日志文件的編碼
}
},
'loggers': {
'o_owen': {
'level': 'DEBUG',
'handlers': ['o_cmd', 'o_file']
},
'o_zero': {
'level': 'DEBUG',
'handlers': ['o_file']
}
}
}
# 2.加載配置
import logging.config
logging.config.dictConfig(LOGGING_DIC)
# 3.使用
log = logging.getLogger('o_owen')
log.warning('123')
1.18 re 模塊 (重點)
'''正則 : 有語法的字符串 ,用來匹配目標字符串1:常用于爬蟲2:判斷字符串內容是否滿足某種規則 多用于規范用戶輸入 比如輸入手機號 郵箱等'''
| 元字符 | 描述 |
| ----------- | :----------------------------------------------------------- |
| \ | 將下一個字符標記符、或一個向后引用、或一個八進制轉義符。例如，“\n”匹配\n。“\n”匹配換行符。序列“\”匹配“\”而“(”則匹配“(”。即相當于多種編程語言中都有的“轉義字符”的概念。 |
| ^ | ^代表以什么開頭。如果設置了RegExp對象的Multiline屬性，^也匹配“\n”或“\r”之后的位置。 |
| $ | $代表以什么結尾。如果設置了RegExp對象的Multiline屬性，$也匹配“\n”或“\r”之前的位置。 |
| * | 匹配0到無數個。 |
| + | 匹配1到無數個。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等價于{1,}。 |
| {*n*} | *n*是一個非負整數。匹配確定的*n*次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的兩個o。 |
| {*n*,} | *n*是一個非負整數。匹配n到無數個。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等價于“o+”。“o{0,}”則等價于“o*”。 |
| {*n*,*m*} | 匹配n到m個。例如，“o{1,3}”將匹配“fooooood”中的前三個o為一組，后三個o為一組。“o{0,1}”等價于“o?”。請注意在逗號和兩個數之間不能有空格。 |
| ? | 匹配0到1個。例如，“do(es)?”可以匹配“do”或“does”。?等價于{0,1}。 |
| ? | 當該字符緊跟在任何一個其他限制符（*,+,?，{*n*}，{*n*,}，{*n*,*m*}）后面時，匹配模式是非貪婪的。非貪婪模式盡可能少地匹配所搜索的字符串，而默認的貪婪模式則盡可能多地匹配所搜索的字符串。例如，對于字符串“oooo”，“o+”將盡可能多地匹配“o”，得到結果[“oooo”]，而“o+?”將盡可能少地匹配“o”，得到結果 ['o', 'o', 'o', 'o'] |
| .點 | 匹配除“\n”和"\r"之外的任何單個字符。要匹配包括“\n”和"\r"在內的任何字符，請使用像“[\s\S]”的模式。 |
| | |
| x\|y | 匹配x或y。例如，“z\|food”能匹配“z”或“food”(此處請謹慎)。“[zf]ood”則匹配“zood”或“food”。 |
| [xyz] | 字符集合。匹配所包含的任意一個字符。例如，“[abc]”可以匹配“plain”中的“a”。 |
| [^xyz] | 負值字符集合。匹配未包含的任意字符。例如，“abc”可以匹配“plain”中的“plin”任一字符。 |
| [a-z] | 字符范圍。匹配指定范圍內的任意字符。例如，“[a-z]”可以匹配“a”到“z”范圍內的任意小寫字母字符。注意:只有連字符在字符組內部時,并且出現在兩個字符之間時,才能表示字符的范圍; 如果出字符組的開頭,則只能表示連字符本身. |
| [^a-z] | 負值字符范圍。匹配任何不在指定范圍內的任意字符。例如，“a-z”可以匹配任何不在“a”到“z”范圍內的任意字符。 |
| \b | 匹配一個單詞的邊界，也就是指單詞和空格間的位置（即正則表達式的“匹配”有兩種概念，一種是匹配字符，一種是匹配位置，這里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”；“\b1*”可以匹配“1_23”中的“1*”，但不能匹配“21_3”中的“1_”。 |
| \B | 匹配非單詞邊界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er” |
| \s | 匹配任何不可見字符，包括空格、制表符、換頁符等等。等價于[ \f\n\r\t\v]。 |
| \S | 匹配任何可見字符。等價于 \f\n\r\t\v。 |
| \w | \w == [A_Za-z0-9] 匹配所有大小寫和數字的單個字符串 此時漢字當做一個字符來看待 |
| \W | \W 就是\w的對立面 匹配所有非大小寫數字的單個字符串 |
| \d | 匹配單獨數字字符。等價于[0-9]。 |
| \D | \D就是\d的對立面 匹配所有非數字的單個字符 |
| \n | 匹配一個換行符。等價于\x0a和\cJ。 |
| \r | 匹配一個回車符。等價于\x0d和\cM。 |
| \t | 匹配一個制表符。等價于\x09和\cI。 |
| ( ) | 將( 和 ) 之間的表達式定義為“組”（group），并且將匹配這個表達式的字符保存到一個臨時區域（一個正則表達式中最多可以保存9個），它們可以用 \1 到\9 的符號來引用。 |
| (?:pattern) | 非獲取匹配，匹配pattern但不獲取匹配結果，不進行存儲供以后使用。這在使用或字符“(\|)”來組合一個模式的各個部分時很有用。例如“industr(?:y\|ies)”就是一個比“industry\|industries”更簡略的表達式。 |
| \| | 將兩個匹配條件進行邏輯“或”（Or）運算。例如正則表達式(him\|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：這個元字符不是所有的軟件都支持的。 |
1.81-1 匹配單個字符
import re
# 單個字符匹配
'''re.findall(pattern, string, flags=0)在字符串中找到正則表達式所匹配的所有子串，并返回一個列表，如果沒有找到匹配的，則返回空列表。'pattern':匹配規則 string:需要匹配的字符串flags:標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。'''
# re.I不區分大小寫
res = re.findall(r'a','abc123嘿嘿abcABC',flags=re.I)
print(res) # ['a', 'a', 'A']
# a|b a或b單個字符
res = re.findall(r'a|b','abc123嘿嘿abcAB',flags=re.I)
print(res) # ['a', 'b', 'a', 'b', 'A', 'B']
# [a,b] 或a 或, 或b單個字符 匹配
res = re.findall(r'[a,b]','abc,123嘿嘿abcABC',flags=re.I)
print(res) # ['a', 'b', ',', 'a', 'b', 'A', 'B']
# [^ab] 非a非b得所有單個字符
res = re.findall(r'[^ab]','abc,123嘿嘿abcABC')
print(res) # ['c', ',', '1', '2', '3', '嘿', '嘿', 'c', 'A', 'B', 'C']
# [a-z]匹配所有小寫字符 [A-Z]匹配所有大寫字母 [0-9]匹配所有數字
res = re.findall(r'[a-z]','abc,123嘿嘿abcABC')
print(res) # ['a', 'b', 'c', 'a', 'b', 'c']
res = re.findall(r'[0-9]','abc,123嘿嘿abcABC')
print(res) # [1,2,3]
# 匹配所有大小寫和數字
print(re.findall(r'[a-z]|[A-Z]|[0-9]', 'abc,123嘿嘿abcABC'))
# ['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C']
# 匹配所有大小寫和數字
res = re.findall(r'[a-zA-Z0-9]','abc,123嘿嘿abcABC')
print(res)
# ['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C']
# \d 匹配單獨數字 == [0-9]
res = re.findall(r'\d','abc,1234嘿嘿abcABC')
print(res) # ['1', '2', '3', '4']
# \D就是\d的對立面 匹配所有非數字的單個字符
res = re.findall(r'\D','abc,1234嘿嘿abcABC')
print(res)
# ['a', 'b', 'c', ',', '嘿', '嘿', 'a', 'b', 'c', 'A', 'B', 'C']
# \w == [A_Za-z0-9] 匹配所有大小寫和數字的單個字符串 此時漢字當做一個字符來看待
print(re.findall(r'\w', 'abc,123嘿[_'))
# ['a', 'b', 'c', '1', '2', '3', '嘿', '_']
# \W 就是\w的對立面 匹配所有非大小寫數字的單個字符串
print(re.findall(r'\W', 'abc,123嘿[_'))
# [',', '[']
# .會匹配所有非\n的單個字符
res = re.findall(r'.','*\_+=\n\r\t')
print(res) # ['*', '\\', '_', '+', '=', ' ', '\r', '\t']
# python中 匹配時如有只是單個\ 匹配出來則是\\
# re.S會讓.匹配所有單個字符
res = re.findall(r'.','*\_+=\n\r\t',flags=re.S)
print(res)
# ['*', '\\', '_', '+', '=', '\n', ' ', '\r', '\t']
# 單個漢字 [\u4e00-\u9fa5]
print(re.findall(r'[\u4e00-\u9fa5]', 'abc,123嘿[_')) # ['嘿']
# \s == [\f\n\r\t\v ] 單個空：空格、制表符、換頁符等
print(re.findall(r'\s', '\f\n\r\t\v')) # ['\x0c', '\n', '\r', '\t', '\x0b', ' ']
1.81-2 正則匹配步驟
import re
# 1.將r'\\'的正則語法字符串轉換成 正則對象 '\', 用來匹配 '\' 字符的
# 2.拿著轉換后的正則對象，來匹配目標字符串
print(re.findall(r'\\', r'a\d\p\\')) # ['\\', '\\', '\\', '\\']
'''re.compile(pattern, flags=0)“編譯正則表達式模式，返回模式對象。”'''
re_obj = re.compile(r'\n') # 轉換成匹配 換行符 的正則對象
res = re_obj.findall('\n')
print(res) # ['\n']
re_obj = re.compile(r'\\d') # 轉換成匹配 \d 的正則對象
res = re_obj.findall('\d')
print(res) # ['\\d']
re_obj = re.compile(r'\d') # 轉換成匹配 數字 的正則對象
res = re_obj.findall('\d') # \d不是數字
print(res) # []
re_obj = re.compile(r'\\n') # 轉換成匹配 \n 的正則對象
res = re_obj.findall('\n') # 代表換行，不能被匹配
print(res) # []
res = re_obj.findall(r'\n') # 就代表\n，能被匹配
print(res) # ['\\n']
1.81-3 匹配多個匹配
# 多個字符
import re
# 明確個數的數量 {n}
print(re.findall(r'a','aaabbb')) # ['a', 'a', 'a']
print(re.findall(r'a{2}','aaabbb')) # ['aa']
print(re.findall(r'ab','aaabbb')) # ['ab']
print(re.findall(r'a{2}b{2}','aabbababab')) # ['aabb']
print(re.findall(r'ab{2}','aabbabababa')) # ['abb']
# {n,} 匹配n到無數個，題中最少匹配abb, 貪婪匹配 abbb 能被匹配為 abb 和 abbb，優先匹配多的
print(re.findall(r'ab{2,}', 'ababbbabbabbbbc'))
# ['abb', 'abbb', 'abbbb']
# {,n} 匹配0到n個 ab{,2} 優先匹配abb 如沒有ab也行 還沒有a也行
print(re.findall(r'ab{,2}', 'aababbabbbabbbb'))
# ['a','ab','abb','abb','abb']
# {n,m}匹配n到m個, ab{1,3} 則優先匹配abbb 然后abb 最后ab
print(re.findall(r'ab{1,3}', 'aababbabbbabbbb'))
# ['ab','abb','abbb','abbb']
# 特殊符號的重復
# * 匹配0到無數個
print(re.findall(r'ab*','aababbabbbabbbb'))
# ['a', 'ab', 'abb', 'abbb', 'abbbb']
# + 匹配1到無數個
print(re.findall(r'ab+','aababbabbbabbbb'))
# ['ab', 'abb', 'abbb', 'abbbb']
# ? 匹配0到1個
print(re.findall(r'ab?','aababbabbbabbbb'))
# ['a', 'ab', 'ab', 'ab', 'ab']
# 需求：匹配所有單詞
print(re.findall(r'[a-z]+', 'abc def hello print'))
# ['abc','def','hello','print']
print(re.findall(r'[a-z]+\b', 'abc def hello print'))
# ['abc', 'def', 'hello', 'print']
# \b代表單詞邊界，用空格(字符串的結尾也包括)作為匹配規則
print(re.findall(r'[a-z]*c', 'abc def hello print acb zc'))
# ['abc', 'ac', 'zc']
1.81-4 多行匹配
# 多行匹配
import re
s = """http://www.baidu.comhttps://sina.com.cnhttps://youku.comhaamabchttp://www.oldboy.com"""
# 需求：拿到url的域名的 baidu , youku
# ^代表以什么開頭，$代表以什么結尾，必須結合flags=re.M來完成多行匹配
res = re.findall(r'^http.+com$',s,flags=re.M)
print(res)
1.81-5 分組
# 分組匹配
import re
url = 'https://www.baidu.com, http://www.youku.com'
# 需求：拿到url的域名的 baidu , youku
res = re.findall(r'www.([a-z]+).com',url)
print(res)
# ()代表分組
# findall匹配，如果匹配規則用有分組語法，只存放分組結果
print(re.findall(r'(www).([a-z]+).com', url))
# [('www', 'baidu'), ('www', 'youku')]
# findall是全文匹配，可以從任意位置開始，匹配多次
# match非全文匹配，必須從頭開始匹配，只能匹配一次
# 專門處理分組的方法：分組，分組編號，有名分組，取消分組
# 取消分組: 必須寫()，但是()為分組語法，我們只是想通過()將一些數據作為整體，所以()必須，再取消分組即可
# (?:) 取消分組只是作為整體 (?P<名字>) 有名分組
url = 'www.baidu.com,www.youku.com'
res = re.match(r'((?:www).(?P[a-z]+).com)', url)
print(res)
#
print(res.group(1)) # www.baidu.com
print(res.group(2)) # baidu
print(res.group('name')) # baidu
1.81-6 拆分和替換
import re
s = 'a b ac def'
print(s.split(' ')) # ['a', 'b', 'ac', 'def']
# 正則拆分
s = 'a b,ac@def'
print(re.split(r'[ ,@]', s)) # ['a', 'b', 'ac', 'def']
s = 'python abc python'
print(re.sub('python', 'Python', s)) # Python abc Python
print(re.sub('python', 'Python', s, count=1)) # Python abc python
# 結合分組可以完成信息的重組與替換
s = 'day a good!!!' # 'a good good day'
print(re.sub('(day) (a) (good)', r'today is \2 \3 \3 \1', s))
《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀總結
以上是生活随笔為你收集整理的python必学的模块_Python常用的模块的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python爬虫爬图片教程_Python
- 下一篇： python3 open函数_pytho