标签:letter pattern subprocess re 模块 res print 序列化 findall
Ⅰ序列化模块
【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]+$ |
标签:letter,
pattern,
subprocess,
re,
模块,
res,
print,
序列化,
findall
From: https://www.cnblogs.com/zyb123/p/18153779