序列化模块，subprocess模块，re模块，常用正则

最新推荐文章于 2024-09-26 11:55:47 发布

.訨.

最新推荐文章于 2024-09-26 11:55:47 发布

阅读量279

点赞数 3

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_41936563/article/details/141451853

版权

Ⅰ序列化模块

【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]+$`