一.正则函数
import re
search 通过正则匹配出第一个对象返回 通过groups取出对象中的值
strvar = "1+2 3*4"
obj = re.search("\d+(.*?)\d+", strvar)
print(obj) # <_sre.SRE_Match object; span=(0, 3), match='1+2'>
# 返回匹配到的内容(匹配到一个就返回)
res = obj.group()
print(res) # 1+21+2
# 返回分组里面的内容,类型是元组
tup = obj.groups()
print(tup[0]) # +
match 验证用户输入内容(了解)
“”“当search函数里面的正则表达式前面加上^ 等价于 match的用法”""
strvar = "a13566668888"
# strvar = "13566668888"
obj = re.search("^\d+", strvar)
print(obj)
# print(obj.group())
split 切割
strvar = "alex|xboyww&wusir%ritian"
res = re.split("[|&%]", strvar)
print(res) # ['alex', 'xboyww', 'wusir', 'ritian']
strvar = "alex234234xboyww6786wusir78967896ritian"
# [0-9] <=> \d
res = re.split("\d+", strvar)
print(res) # ['alex', 'xboyww', 'wusir', 'ritian']
sub 替换
“”“sub(正则,要替换的字符,原字符串[,次数])”""
strvar = "alex|xboyww&wusir%ritian"
res = re.sub("[|&%]", "-", strvar)
print(res) # alex-xboyww-wusir-ritian
strvar = "alex|xboyww&wusir%ritian"
res = re.sub("[|&%]", "-", strvar, 2)
print(res) # alex-xboyww-wusir%ritian
# 传统replace替换的写法
strvar = "alex|xboyww&wusir%ritian"
strvar = strvar.replace("|", "-").replace("&", "-").replace("&", "-")
print(strvar) # alex-xboyww-wusir%ritian
subn 替换(用法和sub一样,区别在于返回的是元组(结果,次数))
strvar = "alex|xboyww&wusir%ritian"
res = re.subn("[|&%]", "-", strvar) # ('alex-xboyww-wusir-ritian', 3)
res = re.subn("[|&%]", "-", strvar, 1) # ('alex-xboyww&wusir%ritian', 1)
print(res)
finditer 匹配字符串中相应内容,返回迭代器[迭代器中包含的是对象]
from collections import Iterator, Iterable
strvar = "jkasdfjkadfjk1234asfj2342kfa"
it = re.finditer("\d+", strvar)
print(isinstance(it, Iterator)) # True
# 获取迭代器里面的内容
for i in it:
print(i.group()) # 1234 2342
compile 指定一个统一的匹配规则
正常情况下,正则表达式编译一次,执行一次
如果想要编译一次,多次使用的话,使用compile
compile 可以编译一次,终生受益,节省系统的资源
strvar = "jksdjdfsj72343789asdfaj234"
pattern = re.compile("\d+")
print(pattern) # re.compile('\\d+')
lst = pattern.findall(strvar)
print(lst) # ['72343789', '234']
obj = pattern.search(strvar)
print(obj.group()) # 72343789
二.正则表达式修饰符
re,I 使匹配对大小写不敏感
strvar = "<h1>72347923489</H1>"
pattern = re.compile(r"<h1>(.*?)</h1>", flags=re.I)
obj = pattern.search(strvar)
print(obj) # <_sre.SRE_Match object; span=(0, 20), match='<h1>72347923489</H1>'>
print(obj.group()) # <h1>72347923489</H1>
re.M 使每一行都能单独匹配(多行). 影响 ^ 和 $
strvar = """<h1>72347923489</H1>
<p>72347923489</p>
<li>72347923489</li>
"""
pattern = re.compile("^<.*?>(?:.*?)<.*?>$", flags=re.M)
lst = pattern.findall(strvar)
print(lst) # ['<h1>72347923489</H1>', '<p>72347923489</p>', '<li>72347923489</li>']
re.S 使 . 匹配包括换行在内的所有字符
strvar = """give
1234234234mefive
"""
pattern = re.compile("(.*?)mefive", flags=re.S)
obj = pattern.search(strvar)
print(obj) # <_sre.SRE_Match object; span=(0, 21), match='give\n1234234234mefive'>
print(obj.group()) # give 1234234234mefive
可以加多个修饰符 通过 | 拼接
"""
pattern = re.compile("(.*?)mefive", flags=re.S|re.I|re.M)
"""
三.import_bao
main.py
# ### 模块和包(模块部分)
# ### 1.import 引入
"""
导入一次,终生受益,不会重复导入
"""
import mymodule
# import mymodule
# 模块.变量
print(mymodule.dog)
# 模块.函数
mymodule.xboyww()
# 模块.类
print(mymodule.MyClass().name)
# ### 2.导入任意路径下的模块
"""自定义模块时,不能使用中文,也不能使用已存在的模块名,会被覆盖"""
import sys
print(sys.path)
"""
把路径添加到系统环境变量path当中
执行命令时, 系统会自动按照路径找到模块,从而引入
如果找不到当前模块所在的路径,直接报错
"""
# ### 3.from ... import ... 从...导入...
# 导入单个
# from mymodule import dog
# print(dog)
# 导入多个
# from mymodule import cat, xboyww
# print(cat)
# xboyww()
# 导入所有
""" * 代表所有"""
# from mymodule import *
# print(cat)
# xgirl()
# 导入的时候,起别名
# from mymodule import xboyww as ww
# ww()
# 可以设置 * 号的导入范围
from mymodule import *
print(cat)
# xboyww() error
# ### __name__ 魔术属性的使用
"""
返回模块名字的魔术属性__name__
如果当前文件是直接运行的,返回__main__
如果当前是间接导入的,返回当前文件名(模块名)
文件直接被执行的时候返回__main__
当成模块被导入的时候,返回模块名本身
"""
print(__name__)
main2.py
# ### 模块和包(包的部分)
"""
1.文件就是模块,文件夹就是包
2.__init__.py 对包(文件夹)进行初始化的脚本文件
导入包的时候,系统自动调用__init__.py 文件,把init文件里面成员进行导入
3.可以通过__init__间接导入其他模块
"""
# ### (一) import 导入包的使用
# 1.获取包初始化文件中的成员
"""
import package1
print(package1.ceshi301)
"""
# 2.导入包下的某些模块
# 方法一
"""
import package1.mypath
package1.mypath.join()
"""
# 方法二(模拟os.path.join写法)
# import package1
# package1.mypath.join()
# package1.mypath.getsize()
# ### (二)from ... import 从包导入相应成员
"""
# 从包中导入成员属性(__init__)
# from package1 import ceshi301
# print(ceshi301)
# 从包当中导入模块
# from package1 import mypath
# mypath.join()
# 引入包下的模块下的具体成员
# from package1.mypath import getsize
# getsize()
# 在引入的同时,起别名
# from package1.mypath import getsize as gs, join as j
# gs()
# j()
"""
# 导入所有,可以指定 * 号引入的范围
from package1 import *
# print(ceshi301)
# print(ceshi302) error
# ### (三)单入口模式(相对导入)
import package2.pkg1.pgone_1 as ppp1
print(ppp1.ceshi1000) # 2001 2000 3000 3001 4000 4001 1000
mymodule.py
# 指定 * 号的导入范围
__all__ = ["dog", "cat"]
dog = "旺旺"
cat = "喵喵"
def xboyww():
print("是一个神秘的人")
def xgirl():
print("没有名字的神秘女人")
class MyClass():
name = "python31"
print("模块被调用了")
res = __name__
print(res, type(res), "=======")
# 只能在测试的时候使用,不能作为模块进行导入,通过__name__实现
if __name__ == "__main__":
print("====start====")
print(dog)
xboyww()
print("====end====")
package1 ->__ init__.py
__all__ = ["ceshi301"]
ceshi301 = 301
ceshi302 = 302
# 通过初始化__init__文件间接导入
from package1 import mypath
package1 ->mypath.py
def join():
print("我是join函数")
def getsize():
print("我是getsize函数")
package2 --pkg2_module1.py
ceshi3000 = 3000
ceshi3001 = 3001
package2->pkg1->pgone_1.py
ceshi1000 = 1000
ceshi1001 = 1001
"""
分模块不能单独进行调用,统一由主文件main进行调用
模块之间的互相嵌套导入,使用相对路径实现
单入口文件必须和包在同一层级,包里面可以含有各种包和模块
相对路径导入的落脚点在 模块或者其中的具体成员身上
"""
# . 代表当前
from . import pgone_2
print(pgone_2.ceshi2001)
# ceshi2000
from . pgone_2 import ceshi2000
print(ceshi2000)
# .. 上一级
from .. import pkg2_module1
print(pkg2_module1.ceshi3000)
from .. pkg2_module1 import ceshi3001
print(ceshi3001)
from .. pkg2 import pgtwo_2
print(pgtwo_2.ceshi4000)
from .. pkg2.pgtwo_2 import ceshi4001
print(pgtwo_2.ceshi4001)
"""
. 当前路径
.. 上一级路径
... 上一级的上一级
.... 上一级的上一级的上一级
..... (这里的点是无限的)
from .................... import 模块
"""
package2->pkg1->pgone_2.py
ceshi2000 = 2000
ceshi2001 = 2001
package2->pkg2->pgtwo_2.py
ceshi4000 = 4000
ceshi4001 = 4001