序列化模組，subprocess模組，re模組，常用正則

silence^發表於2024-04-23

Ⅰ序列化模組

【1】json模組

''' json模組是一個序列化模組 ，主要用於跨語言傳輸'''
1.由下圖可知json格式資料是不同程式語言之間資料互動的媒介
2.json格式資料的具體特徵
	結論一中：資料基於網路傳輸肯定是二進位制格式
    在python中bytes型別的資料可以直接看成是二進位制格式
    在python中只有字串可以轉成bytes型別(編碼encode())
# 由上述推論可知 json格式資料 應該屬於字串型別
'''雙引號是json格式資料獨有的標誌'''
json.dumps()     序列化
	將python資料型別轉換成json格式字串
json.loads()     反序列化
	將json格式字串轉換成對應的資料型別

# json模組
# 將python物件序列化成 json字串、
# json字串反序列化成python物件
# json.dump() # 寫檔案
# json.dumps() # 轉換字串
# json.load() # 讀資料
# json.loads() # 將字串轉回物件

# pickle 模組
# 序列化和反序化
# 支隊python物件生效
# # json.dump() # 寫檔案
# # json.dumps() # 轉換字串
# # json.load() # 讀資料
# # json.loads() # 將字串轉回物件

# user_data = {'username': "silence"}

"""
# 將Python物件轉換為二進位制資料
user_data_pickle_str = pickle.dumps(obj=user_data)
user_data_json_str = json.dumps(obj=user_data)

print(user_data_pickle_str)
# b'\x80\x04\x95\x17\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x08username\x94\x8c\x05dream\x94s.'

print(user_data_json_str, type(user_data_json_str))
# {"username": "dream"} <class 'str'>
"""
import json

"""
# 將二進位制的Python資料轉換為Python物件
user_data_pickle = pickle.loads(user_data_pickle_str)
user_data_json = json.loads(s=user_data_json_str)

print(user_data_pickle, type(user_data_pickle))
# {'username': 'dream'} <class 'dict'>

print(user_data_json, type(user_data_json))
# {'username': 'dream'} <class 'dict'>
"""

【2】pickle模組

# pickle是Python獨有的
user_data = {'username': "silence"}

def save_data_json(data):
    with open('data.json', 'w') as fp:
        json.dump(obj=data, fp=fp)

def read_data_json():
    with open('data.json', 'r') as fp:
        data = json.load(fp=fp)
    print(data)

import pickle

def save_data_pickle(data):
    with open('data', 'wb') as fp:
        pickle.dump(obj=data, file=fp)

def read_data_pickle():
    with open('data', 'rb') as fp:
        data = pickle.load(file=fp)
    print(data)

# pickle是Python獨有的
def add(x, y):
    print(x + y)

# save_data_pickle(data=add)
# read_data_pickle()

# json檔案儲存python的物件會報錯
data = {
    'add': add
}
# save_data_json(data=data)
# save_data_pickle(data=data)
# read_data_pickle()

# pickle模組
# 基本不用
	因為它不支援跨語言傳輸，只能識別python程式碼
'''忽略'''

Ⅱ subprocess模組

import subprocess

res = subprocess.Popen('ls',
                       shell=True,
                       stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE,
                       )
print('stdout', res.stdout.read().decode('utf8'))
print('stderr', res.stderr.read().decode('utf8'))

【1】Popen

# 匯入模組
import subprocess


res = subprocess.Popen('diraaa', shell=True,
                       stdout=subprocess.PIPE,  # 管道 負責儲存正確的資訊
                       stderr=subprocess.PIPE  # 管道 負責儲存錯誤資訊
                       )

print(res)  # <subprocess.Popen object at 0x000001ABB1970310>
print(res.stdout.read().decode('gbk'))  # tasklist執行之後的正確結果返回
print(res.stderr.read().decode('gbk'))

【2】run

def runcmd(command):
    ret = subprocess.run(command,  # 子程序要執行的命令
                         shell=True,  # 執行的是shell的命令
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         # encoding="utf-8",
                         timeout=1
                         )
    # print( ret.returncode)
    # returncode屬性是run()函式返回結果的狀態。
    if ret.returncode == 0:
        print("success:", ret.stdout)
    else:
        print("error:", ret)


runcmd(["dir",'/b'])  # 序列引數
# success: CompletedProcess(args=['dir', '/b'], returncode=0, stderr='')
# runcmd("exit 1")  # 字串引數
# error: CompletedProcess(args='exit 1', returncode=1, stdout='', stderr='')

【3】call

subprocess.call(['python', '--version'])

Ⅲ re模組

# 正則：按照指定的匹配規則從字串中匹配或者擷取相應的內容

【1】引入

# 必須是 11 位，並且是數字 ，必須符合國家規範

def check_phone_number(phone):
    # 必須是 11 位
    if len(phone) != 11:
        print(f"當前手機號位數不是11位!")
    else:
        # 是數字
        if not phone.isdigit():
            print(f"當前手機號格式錯誤,必須全是數字!")
        else:
            # 符合國家規範
            # 4.校驗開頭是否合法(隨便寫幾個意思一下)
            if phone.startswith('13') or phone.startswith('15') or phone.startswith(
                    '17') or phone.startswith('18'):
                print(f"當前手機號是正常的手機號")
            else:
                print(f"非法境外手機號!")


phone = input("phone :>>>> ").strip()
check_phone_number(phone)


# 藉助正規表示式進行匹配
import re


def check_phone_re(phone_number):
    if re.match('^(13|14|15|18)[0-9]{9}$', phone_number):
        print('是合法的手機號碼')
    else:
        print('不是合法的手機號碼')


phone = input("phone :>>>> ").strip()
check_phone_re(phone_number=phone)

【2】字元組

正則 待匹配字元 匹配結果 說明
[0123456789] 8 True 在一個字元組裡列舉合法的所有字元，字元組裡的任意一個字元和"待匹配字元"相同都視為可以匹配
[0123456789] a False 由於字元組中沒有"a"字元，所以不能匹配
[0-9] 7 True 也可以用-表示範圍,[0-9]就和[0123456789]是一個意思
[a-z] s True 同樣的如果要匹配所有的小寫字母，直接用[a-z]就可以表示
[A-Z] B True [A-Z]就表示所有的大寫字母
[0-9a-fA-F] e True 可以匹配數字，大小寫形式的a～f，用來驗證十六進位制字元 
# 字元組就是在同一個位置可能出現的字元
# 字元組用  []
# 字元組的 [備選項] 字母/數字/特殊標點 ...

# （1）匹配 0 - 9 數字
pattern = "[0123456789]"
res = re.findall(pattern, 'a b c d e f g h i j k 1 2 3 4 5')
print(res)  # ['1', '2', '3', '4', '5']
pattern = "[0-9]"
res = re.findall(pattern, 'a b c d e f g h i j k 1 2 3 4 5')
print(res)  # ['1', '2', '3', '4', '5']
# （2）匹配小寫字母
pattern = "[abcd]"
res = re.findall(pattern, 'a b c d e f g h i j k 1 2 3 4 5')
print(res)  # ['a', 'b', 'c', 'd']
pattern = "[a-z]"
res = re.findall(pattern, 'a b c d e f g h i j k A B C D E 1 2 3 4 5')
print(res)  # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
# （3）匹配大寫字母字元組
pattern = "[ABC]"
res = re.findall(pattern, 'a b c d e f g h i j k A B C D E 1 2 3 4 5')
print(res)  # ['A', 'B', 'C']
pattern = "[A-Z]"
res = re.findall(pattern, 'a b c d e f g h i j k A B C D E 1 2 3 4 5')
print(res)  # ['A', 'B', 'C', 'D', 'E']
# （4）大小寫字母+數字混合
pattern = "[0123abcdABC]"
res = re.findall(pattern, 'a b c d e f g h i j k A B C D E 1 2 3 4 5')
print(res)  # ['a', 'b', 'c', 'd', 'A', 'B', 'C', '1', '2', '3']
pattern = "[0-9a-zA-Z]"
res = re.findall(pattern, 'a b c d e f g h i j k A B C D E 1 2 3 4 5')
print(res)  # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'A', 'B', 'C', 'D', 'E', '1', '2', '3', '4', '5']

【3】元字元

元字元 匹配內容
. 匹配除換行符以外的任意字元
\w 匹配字母或數字或下劃線
\s 匹配任意的空白符
\d 匹配數字
\n 匹配一個換行符
\t 匹配一個製表符
\b 匹配一個單詞的結尾
^ 匹配字串的開始
$ 匹配字串的結尾
\W 匹配非字母或數字或下劃線
\D 匹配非數字
\S 匹配非空白符
a|b 匹配字元a或字元b
() 匹配括號內的表示式，也表示一個組
[...] 匹配字元組中的字元
[^...] 匹配除了字元組中字元的所有字元 
# 匹配特殊字元的時候
# （1） . 代表除換行符以外的任意字元
letter = 'a b c d e f g h i j k A B C D E 1 2 3 4 5 , '
pattern = "."
res = re.findall(pattern, letter)
print(res)
# （2）\w 代表數字或者字母或下劃線
letter = 'a b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; % '
pattern = "\w"
res = re.findall(pattern, letter)
print(res)
# （3）\s 代表任意的空白符 ---> 空格
letter = 'a b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; % '
pattern = "\s"
res = re.findall(pattern, letter)
print(res)
# （4）\d 只能匹配數字
letter = 'a b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; % '
pattern = "\d"
res = re.findall(pattern, letter)
print(res)
# （5）\W 除了字母 或數字 或下滑線以外的任意字元
letter = 'a b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; % '
pattern = "\W"
res = re.findall(pattern, letter)
print(res)
# （6）\n 只能匹配換行符
letter = '''
' a 
b c 
d e f g h i j k A B C D E 
1 2 3 4 5 , _ . ; % 
'''
pattern = "\n"
res = re.findall(pattern, letter)
print(res)
# （7）\t 製表符
letter = '''a    b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; % '''
pattern = "\t"
res = re.findall(pattern, letter)
print(res)

# （8）\b 匹配一個單詞的結尾
# （9）^字元 以某個字元開頭
letter = '''a    b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; %'''
pattern = "^a"
res = re.findall(pattern, letter)
print(res)
# （10） 字元$ 以某個字元結尾
letter = '''a    b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; %'''
pattern = "%$"
res = re.findall(pattern, letter)
print(res)
# （11）\D 匹配除數字以外的任意字元
letter = '''a    b c d e f g h i j k A B C D E 1 2 3 4 5 , _ . ; %'''
pattern = "\D"
res = re.findall(pattern, letter)
print(res)
# （12）\S 匹配出了空格以外的所有字元
letter = '''a    b c d e f g h 
i j k A B C D E 1 2 3 4 5 , _ . ; %'''
pattern = "\S"
res = re.findall(pattern, letter)
print(res)
# （13） 字元|字元 匹配任意一個字元
letter = '''a    b c d e f g h 
i j k A B C D E 1 2 3 4 5 , _ . ; %'''
pattern = "a|b|1|%"
res = re.findall(pattern, letter)
print(res)
# （14） () 宣告優先順序
letter = '''a    b c d e f g hi j k A B C D E 12 aa 34 5a , _ . ; %'''
pattern = "\d(\w)"
res = re.findall(pattern, letter)
print(res)
# （15）字元組
letter = '''a    b c d e f g hi j k A B C D E 12 aa 34 5a , _ . ; %'''
pattern = "[a-z0-9A-Z][0-9]" # ['12', '34']
# pattern = "[a-z0-9A-Z][a-z]"
res = re.findall(pattern, letter)
print(res)

letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a , _ . ; %'''
# 匹配除了字元組中字元的所有字元
# $f _g hi 12 aa 34 5a
pattern = "[^a-z0-9A-Z][0-9]" # [' 1', ' 3', ' 5']
res = re.findall(pattern, letter)
print(res)

【4】量詞

量詞 用法說明
* 重複零次或更多次
+ 重複一次或更多次
? 重複零次或一次
{n} 重複n次
{n,} 重複n次或更多次
{n,m} 重複n到m次 
# 代表當前字元的重複次數
# （1） * 代表當前字元重讀零次或更多次
pattern = "[0-9][a-z]*"  #
letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a 111 6cs 9nb 6aaaa , _ . ; %'''
res = re.findall(pattern, letter)
print(res)
# （2） + 代表當前字元重讀一次或更多次
pattern = "[0-9][a-z]+"  #
letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a 111 6cs 9nb  6aaaa , _ . ; %'''
res = re.findall(pattern, letter)
print(res)

# (3)? 重複零次或一次
pattern = "[0-9][a-z]?"  #
letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a 111 6cs 9nb  6aaaa , _ . ; %'''
res = re.findall(pattern, letter)
print(res)

# （4）{n} 重複n次
pattern = "[0-9][a-z]{2}"  #
letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a 111 6cs 9nb  6aaaa , _ . ; %'''
res = re.findall(pattern, letter)
print(res)

# （4）{n,m} 重複至少n次 至多m次
pattern = "[0-9][a-z]{2,3}"  #
letter = '''a    b c d e $f _g hi j k A B C D E 12 aa 34 5a 111 6cs 9nb  6aaaa , _ . ; %'''
res = re.findall(pattern, letter)
print(res)

【5】位置元字元

import re

#  . 代表任意字元
pattern = "海."
letter = '''海燕海嬌海東海冬梅'''
res = re.findall(pattern, letter)
# ['海燕', '海嬌', '海東', '海冬']
print(res)

#  . 代表任意字元
# ^ 以 ... 開頭
pattern = "^海."
letter = '''海燕海嬌海東海冬梅'''
res = re.findall(pattern, letter)
# ['海燕']
print(res)

# #  . 代表任意字元
# # $ 以 ... 結尾
pattern = "海.$"
letter = '''海燕海嬌海東海冬梅'''
res = re.findall(pattern, letter)
# ['海冬']
print(res)

# . 代表任意字元
# ? 重複零次或一次
pattern = "李.?"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑', '李蓮', '李二']
print(res)

# . 代表任意字元
# * 重複零次或更多次
pattern = "李.*"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑李蓮英和李二棍子']
print(res)

# . 代表任意字元
# + 重複一次或更多次
pattern = "李.+"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑李蓮英和李二棍子']
print(res)

# . 代表任意字元
# {m,n} 重複一次或更多次
pattern = "李.{2,3}"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑李蓮', '李二棍子']
print(res)

# . 代表任意字元
# [] 字元組中的任意一個
pattern = "李[傑蓮英二棍子]"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑', '李蓮', '李二']
print(res)

# . 代表任意字元
# [] 字元組中的任意一個
# ^和 除了和
# * 任意
pattern = "李[^和]*"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
# ['李傑李蓮英', '李二棍子']
print(res)

【6】分組匹配

# | 或條件
# () 優先匹配
# [^] 除了當前字元組以外的其他字元

【7】貪婪匹配


# 貪婪匹配：在滿足匹配時，匹配儘可能長的字串，預設情況下，採用貪婪匹配
# 非貪婪匹配：在滿足匹配時，匹配儘可能短的字串
# 幾個常用的非貪婪匹配，Pattern
# *? 重複任意次，但儘可能少重複
# +? 重複1次或更多次，但儘可能少重複
# ?? 重複0次或1次，但儘可能少重複
# {n,m}? 重複n到m次，但儘可能少重複
# {n,}? 重複n次以上，但儘可能少重複
import re
pattern = "李.*?"
pattern = "李.+?"
pattern = "李.??"
pattern = "李.{2,3}?"
letter = '李傑李蓮英和李二棍子'
res = re.findall(pattern, letter)
print(res)
# ['李傑李', '李二棍']

【8】方法

（1）findall

  • 返回所有滿足匹配條件的結果,放在列表裡
import re
name_str = "silence yuan Justin"
pattern = 's'
result = re.findall(pattern, name_str)  # findall(正規表示式，待匹配的文字)
print(result)
# 結果 : ['s', 's'] 結果是所有符合條件的資料，並且組織成了列表

（2）search

  • 只匹配到符合條件的一個字元
# 函式會在字串內查詢模式匹配,只到找到第一個匹配然後返回一個包含匹配資訊的物件,該物件可以
# 透過呼叫group()方法得到匹配的字串,如果字串沒有匹配，則返回None。
import re
name_str = "silence yuan Justin"
pattern = 's'
result = re.search(pattern, name_str) # search(正規表示式，待匹配的文字)
print(result)  # <re.Match object; span=(0, 1), match='s'>
result = re.search(pattern, name_str).group()
print(result)  # s 查詢到一個符合條件的資料就結束  沒有則返回None

（3）match

  • 同search,不過是在字串開始處進行匹配，如果沒有則返回None,類似於給正則自動加了^
  • 如果符合也只取一個結束
import re
name_str = 'abcaaaaaa'
# 同search,不過盡在字串開始處進行匹配
pattern = 'a'
result = re.match(pattern, 'abc')
print(result)  # <re.Match object; span=(0, 1), match='a'>
result = re.match(pattern, 'abc').group()
print(result)
# 結果 : 'a'

（4）split

  • 先按'a'分割得到''和'bcd',在對''和'bcd'分別按'b'分割
name_str = 'abcd'
# 先按'a'分割得到''和'bcd',在對''和'bcd'分別按'b'分割
pattern = '[ab]'
result = re.split(pattern, name_str)
print(result)  # ['', '', 'cd']

（5）sub

  • 預設替換所有匹配到的字元 可以用 count 控制替換次數
name_str = 'eva3egon4yuan4'
# 將數字替換成'H'，引數1表示只替換1個
# 預設替換所有匹配到的字元
pattern = '\d'
result = re.sub(pattern, 'H', name_str)
result = re.sub(pattern, 'H', name_str, count=2)
print(result)  # evaHegon4yuan4

（6）subn

  • 替換匹配到的所有字元並返回 替換成功的字元和替換次數
name_str = 'eva3egon4yuan4'

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

（7）compile

  • 預編譯正規表示式
# 將正規表示式編譯成為一個 正規表示式物件，規則要匹配的是3個數字
import re
obj = re.compile('\d{3}')
print(obj) # re.compile('\\d{3}')
# 正規表示式物件呼叫search，引數為待匹配的字串
ret = obj.search('abc1234eeee')
print(ret.group())  # 結果 ： 123
print(re.findall(obj, 'abc1234eeee'))  # ['123']

（8）finditer

import re
res = re.finditer('s','silence yuans Justin')
print(res) # <callable_iterator object at 0x000002A81EB8E7A0>
# 結果是一個迭代器物件 為了節省空間
# print(list(res))
# [<re.Match object; span=(0, 1), match='s'>, <re.Match object; span=(12, 13), match='s'>, <re.Match object; span=(16, 17), match='s'>]

print([obj.group() for obj in res]) # ['s', 's', 's']

【9】正則方法之優先順序

（1）findall的優先順序查詢

'''
findall預設是分組優先展示
	正規表示式中如果有括號分組，那麼在展示匹配結果的時候
	預設只演示括號內正規表示式匹配到的內容
也可以取消分組有限展示的機制
	(?:) 括號前面加問號冒號
'''
pattern = 'www.(baidu|oldboy).com'
pattern = re.compile(pattern)
data = 'www.oldboy.com'
ret = re.findall(pattern, data)
# 這是因為findall會優先把匹配結果組裡內容返回,如果想要匹配結果,取消許可權即可
print(ret)  # ['oldboy']

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


data= "<dd>弱者聲嘶力竭，亦無人在乎，強者輕聲細語，卻能深入人心。一棵熊熊燃燒的天賦樹，每一片葉子都承載著不同的靈紋，宗門被滅，淪為礦奴的陸葉憑此成為修士，攪動九州風雲......</dd>"
pattern = '<dd>(.*)</dd>'
pattern = re.compile(pattern)
print(re.findall(pattern,data))

（2）split的優先順序查詢

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

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #結果 ： ['eva', '3', 'egon', '4', 'yuan']
  • 在匹配部分加上（）之後所切出的結果是不同的，
  • 沒有（）的沒有保留所匹配的項，但是有（）的卻能夠保留了匹配的項，
  • 這個在某些需要保留匹配部分的使用過程是非常重要的。

【10】常用正規表示式

場景 正規表示式
使用者名稱 ^[a-z0-9_-]{3,16}$
密碼 ^[a-z0-9_-]{6,18}$
手機號碼 ^(?:\+86)?1[3-9]\d{9}$
顏色的十六進位制值 ^#?([a-f0-9]
電子郵箱 ^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+\.[a-z]+$
URL ^(?:https://
IP 地址 ((2[0-4]\d
HTML 標籤 ^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>
utf-8編碼下的漢字範圍 ^[\u2E80-\u9FFF]+$

相關文章