目录
time时间模块
time : 时间戳
mktime : 时间元祖转时间戳
ctime: 时间戳转时间字符串
strftime: 时间元祖转时间字符串
strptime: 时间字符串转时间元组
# ### time 时间模块 import time # localtime -> mktime -> ctime # 时间元组 -> 时间戳 -> 时间字符串 # time() 获取本地时间戳 (*) res = time.time() print(res) # localtime() 获取本地时间元组(参数是时间戳,默认当前) (*) res = time.localtime() print(res) """ time.struct_time( tm_year=2020, tm_mon=7, tm_mday=28, tm_hour=10, tm_min=45, tm_sec=9, tm_wday=1, tm_yday=210, tm_isdst=0 ) """ # 指定时间戳,返回时间元组 ttp = 1595904161 res = time.localtime(ttp) print(res) # mktime() 通过时间元组获取时间戳(参数是时间元组) (*) ttp = (2020,7,28,10,48,30,0,0,0) res = time.mktime(ttp) print(res) # 1595904510 # ctime() 获取本地时间字符串(参数是时间戳,默认当前) (*) res = time.ctime() # 默认以当前时间戳获取时间字符串 print(res) # 指定时间戳 res = time.ctime(1595904161) print(res) # asctime() 通过时间元组获取时间字符串(参数是时间元组)(了解) ttp = (2020,7,28,10,54,30,6,0,0) # 不能自动识别周几. res = time.asctime(ttp) print(res) # 改造办法 ttp = (2020,7,28,10,54,30,0,0,0) res = time.mktime(ttp) str_time = time.ctime(res) print(str_time) # sleep() 程序睡眠等待 (*) """ time.sleep(2) print("我睡醒了") """ """ strftime => 把时间元组 -> 时间字符串 strptime => 把时间字符串 -> 时间元组 """ # strftime() 格式化时间字符串(格式化字符串,时间元祖) (*) # 1.默认按照当前时间做格式化 res = time.strftime("%Y-%m-%d %H:%M:%S") print(res) # 2.指定时间元组,对时间字符串格式化 """strftime如果在windows当中出现中文,直接报错,不能解析,linux 可以支持""" ttp = (2000,10,1,12,12,12,0,0,0) res = time.strftime("%Y-%m-%d %H:%M:%S" , ttp) print(res) # strptime() 将时间字符串通过指定格式提取到时间元组中(时间字符串,格式化字符串) (*) """要求字符串不能乱加符号,必须严丝合缝.""" strvar = "2020年7月28号11时12分13秒是著名歌星庾澄庆的生日" ttp = time.strptime(strvar,"%Y年%m月%d号%H时%M分%S秒是著名歌星庾澄庆的生日") print(ttp) # perf_counter() 用于计算程序运行的时间 (了解) # 记录开始时间 # startime = time.perf_counter() startime = time.time() for i in range(100000000): pass # 记录结束时间 # endtime = time.perf_counter() endtime = time.time() print(endtime - startime)
利用time模块实现动态进度条效果
进度条准备工作
import time # (1) 定义进度条的样式 '''%-50s让#号居左显示且占50个空位''' print("[%-50s]" % ("#")) print("[%-50s]" % ("###############")) print("[%-50s]" % ("#########################")) # (2) 让进度条动起来 strvar = "" for i in range(50): strvar += "#" time.sleep(0.1) print("\r[%-50s]" % (strvar) , end="" ) # \r的作用：将后面的字符直接拉到当前行行首
实现进度条的进度效果
# (3) 根据文件的大小,调整进度条的位置 # 假设文件的大小是 1024000 def progress(percent): # 如果百分比超过了1,说明数据已经接受完毕; if percent > 1: percent = 1 # 打印对应的#号效果 strvar = "#" * int(percent * 50) # %% => % print("\r[%-50s] %d%%" % (strvar,int(percent * 100)) , end="" ) # 初始化接受的字节数 recv_size = 0 # 文件接受总大小 total_size = 1024000 while recv_size < total_size: recv_size += 1024 # 模拟延迟 time.sleep(0.01) # 计算百分比 percent = recv_size/total_size #0.001 # 调用进度条函数 progress(percent)
Python的内置方法
res = abs(-100) pritn(res) # 输出结果 为 100
lst= [1,2,3] res =sum (lst) print(res) # 输出结果为 6
lst = [1,3,2,5,6] res = max(lst) print(res) # 输出结果为6
lst = [1,3,2,5,6] res = min(lst) print(res) # 输出结果为1
res = pow (2,3) # 2 为值 3 为次方 print (res) # 输出结果 为 8
# bin 将10 进制 转为 2 进制 # oct 将 10 进制 转为 8 进制 # hex 将 10 进制 转为 16 进制 res1 = bin(9) res2 = oct(9) res3 = hex(9) print(res1,res2,res3) # 输出结果为 0b1001 0o11 0x9
#chr ascll 转 字符 #ord 字符转 ascll res= ord('a') res1 =chr(33) print( res,res1)
""“注意点:在与用户交互的时候,慎用”"" a=90 exec('print(a)')
repr 不转义字符输出字符串
input 接收输入字符串(永远接收字符串)
“”“相同的两个数据经过哈希算法运算得出的结果一定相同”"" res1 = hash(“abc”) res2 = hash(“abc”) print(res1,res2)\ # 输出结果为 4521462165539241311 2948100441812388161
# 正常情况下遵循四色五入, 但是在 n.5 结构中, n为偶数则会舍去,n 为奇数则进一 res1 = round(4.51) # s res2 = round((4.5) #4 res3 = round(3.5) # 4 res4 = round(4.12) #4
数字模块
# ### 数学模块 import math #ceil() 向上取整操作 (对比内置round)* res = math.ceil(4.9) # 5 res = math.ceil(-3.5) # -3 print(res) # floor() 向下取整操作 (对比内置round)* res = math.floor(3.9) # 3 res = math.floor(-3.8) # -4 print(res) # pow() 计算一个数值的N次方(结果为浮点数) (对比内置pow) res = math.pow(2,3) # 8 # res = math.pow(2,3,3) error # 只有2个参数 print(res) # 结果一定是小数:8.0 # sqrt() 开平方运算(结果浮点数)* res = math.sqrt(9) print(res) # 结果一定是小数:3.0 # fabs() 计算一个数值的绝对值 (结果浮点数) (对比内置abs) res = math.fabs(-99) print(res) # 99.0 # modf() 将一个数值拆分为整数和小数两部分组成元组* res = math.modf(13.45) print(res) # (0.4499999999999993, 13.0) # copysign() 将参数第二个数值的正负号拷贝给第一个 (返回一个小数)* res = math.copysign(-13,-1) print(res) # 返回一个小数 # fsum() 将一个容器数据中的数据进行求和运算 (结果浮点数)(对比内置sum) lst = [1,2,3,4,6] res = math.fsum(lst) print(res) # 返回一个小数 #圆周率常数 pi* res = math.pi print(res)
随机模块
# ### random 随机模块 import random # random() 获取随机0-1之间的小数(左闭右开) 0<= x <1 res = random.random() print(res) # randrange() 随机获取指定范围内的整数(包含开始值,不包含结束值,间隔值) ** # 一个参数 res = random.randrange(5) # 0~4 # 二个参数 res = random.randrange(2,8) # 2~7 # 三个参数 res = random.randrange(1,10,3) # 1,4,7 print(res) # randint() 随机产生指定范围内的随机整数 (了解) res = random.randint(3,4) # 3,4 # res = random.randint(3) error # res = random.randint(3,7,2) error # 3 5 7 print(res) # uniform() 获取指定范围内的随机小数(左闭右开) res = random.uniform(1,3) # 1<=x<3 小数 # return a + (b-a) * self.random() """ a=3,b=1 3 + (1-3) * x = 0 => 3 3 + (1-3) * x = 1 => 1 1<x<=3 """ res = random.uniform(3,1) print(res) #choice() 随机获取序列中的值(多选一) lst = ["刘鑫","刘子豪","孙致和","高旭峰","戈隆"] res = random.choice(lst) print(res) def mychoice(lst): num = random.randrange(len(lst)) # 0 1 2 3 4 return lst[num] res = mychoice(lst) print(res) # lambda 表达式 func = lambda lst : lst[random.randrange(len(lst))] print(func(lst)) #sample() 随机获取序列中的值(多选多) [返回列表] lst = ["刘鑫","刘子豪","孙致和","高旭峰","戈隆"] res = random.sample(lst,1) res = random.sample(lst,2) print(res) #shuffle() 随机打乱序列中的值(直接打乱原序列) lst = ["刘鑫","刘子豪","孙致和","高旭峰","戈隆"] random.shuffle(lst) print(lst)
利用random模块实现验证码的生成
def yanzhengma(): # 验证码当中含有小写字母,大写字母,数字 # 小写字母:97~122 strvar = "" # 随机抽4次 for i in range(4): s_char = chr(random.randrange(97,123)) # 大写字母:65~90 b_char = chr(random.randrange(65,91)) # # 0~9 num = str(random.randrange(10)) lst = [s_char,b_char,num] strvar += random.choice(lst) return strvar res = yanzhengma() print(res)
序列化模块 pickle
1. 序列化: 把不能直接存储的数据变得可以存储,这个过程叫做序列化
2. 反序列化: 把文件中的数据取出来,恢复到原来的数据类型,这个过程叫做反序列化
3. 在文件中存储的数据只能是字符串或者字节流,不可以是其他类型,如果想要存储其他类型的数据必须序列化.
4. pickle模块可以序列化一切数据类型
5. 只有字符串可以encode和decode转化为字节流
dumps 序列化
loads 反序列化
6. 序列化输入文件
lst = {'马生平","曹成光","吴洪昌"]
with open("文件",modo="wb") as tf
pickle.dump(lst,tf)
7. 反序列化输出文件
with open("文件",mode"rb") as tf: res=pickle.load(tf) print(res)
dumps 和 loads 文件操作的区别
lst =['马生平","曹成光",'吴洪昌"] res =pick.dumps(lst) with open("文件",mode='wb') as tf: tf.write(res) with open("文件",mode='rb') as tf: res=fp,read() print(res) lst =pickle.loads(res) print(lst.tpe(lst))
序列化模块 json
1. 所有的编程语言都识别的序列化格式json ,是字符串
2. jsom可以序列化的类型有( int float str list tuple dict None)
3 用法一:
dic ={'name':'高学峰','age':18}
res= json.dumps(dic,ensure_ascii=False,sort_keys=
True)
print(res,type(dic))
dic={'name':'高学峰','age':18)
print(dic,type(dic))
4. 用法二:
dic ={'name':'高学峰','age':18}
with open("文件",mode="w",encodig="utf-8') as fp:
json.dump(dic,fp,ensue_ascii=False)
with open("文件",mode='r',encoding="utf-8") as fp:
dic=json.load(fp)
print(dic,type(dic))
5. json 与 pickle 之间的区别
6. json 可以连续dump,但是不能连续load dic1={'a':1,'b':2} dic2={'c':3,'d':4} with open('文件',mode='w',encoding='uf-8') as fp: json.dump(dic1,fp) fp.write('\n') json.dump(dic2,fp) fp.write('\n') 7. load 在获取数据时,一次性拿出所有内容 解决方法 with open('文件',mode='r',encoding='utf-8') as fp: for i in fp: dic =json.loads() print(dic,type(dic)) pickle 可以连续dump也可以连续load,因为pickle在存储的时候会在末尾加上一个结束符 import pickle dic1={'a':1,'b';2} dic2={'c':3,'d':4} with open ('文件',mode='wb') as fp: pickle.dump(dic1,fp) pickle.dump(dic2,fp) with open ('文件',mode= 'rb') as fp: dic1=pickle.load(fp) print(dic1,type(diuc1)) dic2=pickle.load(fp) print(dic2,type(dic2)) try: 可能报错的代码 except: 如果报错执行except这个代码块: try: with open ('文件',mode+'rb') as fp: while True: res=pickle.load(fp) print(res) except: pass
json 序列化之后的数据类型是str,所有编程语言都识别,但是仅限于( int float bool list tuple dict None)
json 不可以连续load ,只能一次性拿出所有数据
pickle 序列化之后的数据类型是bytes,所有数据类型都可以转换,但是仅限于python 之间的数据存储和传输
pickle 可以连续load ,多套数据放在同一个文件中
json 的使用广泛性比pickle 广
json 用在不同的编程语言的数据交流中
pickle 用于数据的存储
os 系统模块
方法: system popen listdir getcwd chdir environ / name sep linesep
import os #### os模块方法 #### # 1.system 在python中执行系统命令 os.system("ifconfig") os.system("touch 1.txt") # 2.popen 执行系统命令返回对象 # 可以通过read方法读出字符串，防止字符串乱码，使用popen进行操作 obj = os.popen("ifconfig") res = obj.read() print(res) # 3.listdir 获取指定文件夹中的所有内容的名称列表 lst = os.listdir(".") # . 当前目录 lst = os.listdir("..") # . 上一级目录 lst = os.listdir("/home/libolun") print(lst) # 4.getcwd 获取当前文件所在的默认路径(单纯的路径) res = os.getcwd() print(res) # /mnt/hgfs/python31_gx/day19 # 路径+文件 print(__file__) # /mnt/hgfs/python31_gx/day19/1.py # 5.chdir 修改当前文件工作的默认路径 os.chdir("/home/libolun/mywork") os.system("mkdir ceshi100") # 6.environ 获取或修改环境变量 print(os.environ) # 获取所有环境变量 print(os.environ["path"]) os.environ["path"] += ":/home/libolun/mywork" # 修改环境变量 os.system("libolun") #### os模块属性 #### # 1.name 获取系统标识 # linux,mac->posix windows->nt print(os.name) # 2.sep 获取路径分割符号 # linux,mac-> / windows-> \ print(os.sep) # 3.linesep 获取系统的换行符号 # linux,max-> \n windows->\r\n或\n print(repr(os.linesep))
os模块: 新建和删除
mknod remove mkdir rmdir rename makedirs removedirs
#### os 负责新建和删除 #### # 1 os.mknod 创建文件 os.mknod("1.txt") # 2.os.remove 删除文件 os.remove("1.txt") # 3.os.mkdir 创建文件夹 os.mkdir("ceshi100") # 4.os.rmdir 删除文件夹 os.rmdir("ceshi100") # 5.os.rename 对文件/文件夹重命名 os.rename("111.txt","123.py") # 6.os.makedirs 递归创建文件夹 os.makedirs("a/b/c/d/e") # 7.os.removedirs 递归删除文件夹（空文件夹） os.removedirs("a/b/c/d/e")
os shutil 模块
copyfilleobj copyfile copymode copystat copy copy2 copytree rmtree remove
# 1.copyfileobj(fsrc,fdst,[,length=16*1024]) 单纯复制文件的内容 # 需要手动创建文件对象 fp1 = open("123.py",mode='r',encoding="utf-8") fp2 = open("lianxi111.php",mode="w",encoding="utf-8") shutil.copyfileobj(fp1,fp2) # 2.copyfile(src,dst) 单纯的仅复制文件内容 # 在底层调用了copyfileobj shutil.copyfile("1.php","2.js") # 3.copymode(src,dst) 单纯的复制权限,不包括文件内容 shutil.copymode("1.php","2.js") # 4.copystat(src,dst) 复制文件所有状态信息，不包括内容 # 状态信息：包括权限、组、用户、修改时间 shutil.copystat("1.py","2.php") # 5.copy(src,dst) 复制文件的权限和内容 shutil.copy("1.py","2.html") # 6.copy2(src,dst) 复制文件权限和内容，还有组，时间，用户等 shutil.copy2("1.py","2.html") # 7.copytree(src,dst) 复制文件夹里的所有内容(递归拷贝) shutil.copytree("lianxi001","lianxi002") # 8.rmtree(path) 删除当前文件夹以及文件夹中的所有内容(递归删除) shutil.rmtree("lianxi001") # 9.move(path1,path2) 移动文件或者文件夹 shutil.move("1.php","..") shutil.move("lianxi001","../lianxi007") # 移动并改名
os.path 路径模块
basename dirname split join splitext getsize isdir isfile islink getctime getatime getmtime exists isabs abspath
# 1.basename 返回文件名部分 strvar = "/home/libolun/mywork/1.py" res = os.path.basename(strvar) print(res) # 1.py # 2.dirname 返回路径部分 res = os.path.dirname(strvar) print(res) # /home/libolun/mywork # 3.split 将路径拆分为单独的文件部分和路径部分，并组合成一个元组 tup = os.path.split(strvar) print(tup) # 4.join 将多个路径和文件组成新的路径 # 可以自动通过不同的系统加不同的斜杠 path1 = "ceshi1" path2 = "libolun" path3 = "2.py" # pathvar = path1 + os.sep + path2 + os.sep + path3 pathvar = os.path.join(path1,path2,path3) print(pathvar) # 5.splitext 将路径分割为后缀和其他部分 res = os.path.splitext(strvar) print(res) # ('/home/libolun/mywork/1','.py') # 6.getsize 获取文件的大小 res = os.path.getsize("1.py") # 文件夹不能计算 res = os.path.getsize("os") print(res) # 7.isdir 检测路径是否是一个文件夹 strvar = "/home/libolun/mywork/libolun" res = os.path.isdir(strvar) print(res) # 8.isfile 检测路径是否是一个文件 strvar = "/home/libolun/mywork/libolun" res = os.path.isfile(strvar) print(res) # 9.islink 检测路径是否是一个链接 strvar = "/home/libolun/mywork/libolun" res = os.path.islink(strvar) print(res) # 10.getctime [windows]文件的创建时间 [linux]权限的改动时间 # 返回的是时间戳 res = os.path.getctime("1.py") # 11.getmtime 获取文件最后一次修改时间 res = os.path.getmtime("1.py") # 12.getatime 获取文件最后一次访问时间 res = os.path.getatime("1.py") # 13.exists 检测指定的路径是否存在 strvar = "/home/libolun/mywork/libolun" res = os.path.exists(strvar) print(res) # 14.isabs 检测一个路径是否是绝对路径 pathvar = "." res = os.path.isabs(pathvar) print(res) # 15.abspath 将相对路径转化为绝对路径 pathnew = os.path.abspath(pathvar) print(pathnew) # 检测是否是绝对路径，如果不是，将其转化为绝对路径 if not os.path.abspath(pathvar): pathnew = os.path.abspath(pathvar) print(pathnew)
文件压缩模块 zipfile
文件压缩
#(1)创建压缩包 zf = zipfile.ZipFile('wenjian","w',zipfile.ZIP_DELATED) #(2)把文件写入到压缩包中 #write(路径,别名) zf.write('/bin/home','home') #可以临时创建一个文件夹天麻片在压缩包中 zf.write("/bin/df","/tmp/df") # (3) 关闭压缩包 zf.close()
文件解压
# (1)打开压缩包 zf = zipfile.ZipFile("1424.zip","r") # (2)解压文件 # 解压单个文件 zf.extract("cp","ceshi1424_2") # 解压所有文件 # zf.extractall("ceshi1424") # (3) 关闭压缩包 zf.close()
文件追加
with zipfile.ZipFile("1424.zip","a",zipfile.ZIP_DEFLATED) as zf: zf.write("/bin/dir","dir")
查看压缩包
with zipfile.ZipFile("1424.zip","r",zipfile.ZIP_DEFLATED) as zf: lst = zf.namelist() print(lst)
文件压缩模块 tarfile
mode1. tar
mode2. .tar.gz
mode3 .tar.bz2 压缩到最小
1. 创建atr包
# 单纯的tar包 tf = tarfile.open("ceshi0729_1.tar","w",encoding="utf-8") tf.add("/bin/echo","echo") tf.add("/bin/ed","ed") tf.add("/bin/fuser","/tmp/fuser") tf.close() # .tar.gz tf = tarfile.open("ceshi0729_2.tar.gz","w:gz",encoding="utf-8") tf.add("/bin/echo","echo") tf.add("/bin/ed","ed") tf.add("/bin/fuser","/tmp/fuser") tf.close() # .tar.bz2 tf = tarfile.open("ceshi0729_3.tar.bz2","w:bz2",encoding="utf-8") tf.add("/bin/echo","echo") tf.add("/bin/ed","ed") tf.add("/bin/fuser","/tmp/fuser") tf.close()
2. 对压缩包进行解压
tf = tarfile.open("ceshi0729_3.tar.bz2","r",encoding="utf-8") # 解压单个 tf.extract("echo","ceshi0729_4") # 解压所有 # tf.extractall("ceshi0729_3") tf.close()
3. 追加文件
#(支持with语法) [只能为没有压缩过的tar包进行追加.] with tarfile.open("cceshi0729_1.tar","a",encoding="utf-8") as tf: tf.add("/bin/cp","cp")
4. 查看包中的文件
with tarfile.open("ceshi0729_2.tar.gz","r",encoding="utf-8") as tf: lst = tf.getnames() print(lst)
计算文件大小 代码
import os pathvar = "/mnt/hgfs/python31_gx/day19/ceshi100" # 基本写法 lst = os.listdir(pathvar) print(lst) # ['1.py', '2.py', '3.py', 'ceshi200'] size = 0 for i in lst: # 拼接路径 pathnew = os.path.join(pathvar,i) # 判断是否是文件 if os.path.isfile(pathnew): print(i,"[文件]") size += os.path.getsize(pathnew) # 判断是否是文件夹 elif os.path.isdir(pathnew): print(i,"[文件夹]") print(size) """不确定有多少层级的情况下,使用递归""" # 递归计算文件夹的大小 def getallsize(pathvar): size = 0 # 获取当前文件夹中所有内容 lst = os.listdir(pathvar) # 循环列表 for i in lst: # 拼接完整路径 pathnew = os.path.join(pathvar,i) # 判断是否是文件或者文件夹 if os.path.isfile(pathnew): size += os.path.getsize(pathnew) elif os.path.isdir(pathnew): # 如果是文件夹,继续调用函数. size += getallsize(pathnew) # 返回最后的结果 return size res = getallsize(pathvar) print(res)
正则表达式
单字符匹配
1. 预定义字符
\d 匹配数字 \D 匹配非数字
\w 匹配数字字母下划线 \W 匹配非数字字母下划线
\s 匹配任意空白符( \n \t \r 空格) \S匹配任意空白符
\n 匹配一个换行符
\t 匹配一个制表符
# ### 预定义字符集 # \d 匹配数字 strvar = "sdfsdf*(&*(&(2ui3" lst = re.findall("\d",strvar) print(lst) # \D 匹配非数字 strvar = "sdfsdf*(&*(&(2ui3" lst = re.findall("\D",strvar) print(lst) # \w 匹配字母数字下划线 strvar = "sadf*)(*_)456你你好" lst = re.findall("\w",strvar) print(lst) # \W 匹配非字母或数字或下划线 strvar = "sadf*)(*_)456你你好" lst = re.findall("\W",strvar) print(lst) # \s 匹配任意的空白符 (\n \t \r ' ') strvar = " " lst = re.findall("\s",strvar) print(lst) # \S 匹配任意非空白符 strvar = " abdd " lst = re.findall("\S",strvar) print(lst) # \n 匹配一个换行符 strvar = """ """ lst = re.findall(r"\n",strvar) print(lst) # \t 匹配一个制表符 strvar = """ """ lst = re.findall(r"\t",strvar) print(lst)
2,. 字符组[] 必须从字符组列出来的字符当中抽取, 默认一个,如果没有返回空
strvar = "abpoiuc" lst = re.findall("[abc]",strvar) print(lst) # ['a', 'b', 'c'] print(re.findall('a[abc]b','aab abb acb adb')) # aab abb acb print(re.findall('a[0123456789]b','a1b a2b a3b acb ayb')) # a1b a2b a3b # - 代表到,代表的是范围 # 0-9 0到9这么多的数字 print(re.findall('a[0-9]b','a1b a2b a3b acb ayb')) # a1b a2b a3b # a-g => abcdefg print(re.findall('a[abcdefg]b','a1b a2b a3b acb ayb adb')) # acb adb print(re.findall('a[a-g]b','a1b a2b a3b acb ayb adb')) # acb adb # a-z => 26个小写字母 print(re.findall('a[a-z]b','a1b a2b a3b acb ayb adb')) # acb ayb adb # A-G => ABCDEFG print(re.findall('a[ABCDEFG]b','a1b a2b a3b aAb aDb aYb')) #aAb aDb print(re.findall('a[A-G]b','a1b a2b a3b aAb aDb aYb')) #aAb aDb # A-Z=> 26个大写字母 print(re.findall('a[A-Z]b','a1b a2b a3b aAb aDb aYb')) #aAb aDb aYb print(re.findall('a[0-9a-zA-Z]b','a-b aab aAb aWb aqba1b')) # aab aAb aWb aqb a1b # 0-z 不会单纯的匹配小写大写字母和数字,还会匹配到特殊的符号,比如_和@ print(re.findall('a[0-z]b','a_ba@b aab aAb aWb aqba1b')) # aab aAb aWb aqb a1b print(re.findall('a[0-9][*#/]b','a1/b a2b a29b a56b a456b')) #a1/b # ^ 除了 , 在字符组当中,开头的位置使用 print(re.findall('a[^-+*/]b',"a%b ccaa*bda&bd")) #a%b a&b
3.匹配^ -
#如果想要匹配^ - 需要在前面加上\进行转义
lst = re.findall(“a[^-]b”,“a+b a-b a^b”) print(lst) # [‘a-b’, ‘a^b’]
4. 匹配 /
#\b本身也是转义字符: 退格( 把光标向左移动一位)
lst = re.findall(r"a\b",r"a\b") print(lst[0])
多字符匹配
量词
? 0-1
+ 1-n
* 0-n
{m,n} m-n
# 量词 '''1) ? 匹配0个或者1个a ''' print(re.findall('a?b','abbzab abb aab')) # ab b ab ab b ab '''2) + 匹配1个或者多个a ''' print(re.findall('a+b','b ab aaaaaab abb')) # ab aaaaaab ab '''3) * 匹配0个或者多个a ''' print(re.findall('a*b','b ab aaaaaab abbbbbbb')) # b ab aaaaaab ab b b b b b b '''4) {m,n} 匹配m个至n个a ''' # 1 <= x <= 3 print(re.findall('a{1,3}b','aaab ab aab abbb aaz aabb')) # aaab ab aab ab aab # {2,} 至少2次 print(re.findall('a{2,}b','aaab ab aab abbb aaz aabb')) # aaab aab aab # {2,} 必须2次 print(re.findall('a{2}b','aaab ab aab abbb aaz aabb')) # aab aab aab
贪婪匹配与非贪婪匹配
1. 贪婪匹配: 默认向更多次匹配(回溯算法) 非贪婪匹配: 默认向更少次匹配
2. 非贪婪匹配: 在量词后面接? .?? .+? .*? {4,}?
3. 回溯算法: 从左向右进行匹配,直到匹配到最后,再也找不到了,回头,找最后一个(递归)
4. . 匹配任意字符,(除了换行符\n)
# 练习题 strvar = "刘能和刘老根和刘铁柱子111子222" lst = re.findall("刘.",strvar) # ['刘能', '刘老', '刘铁'] print(lst) lst = re.findall("刘.?",strvar) # ['刘能', '刘老', '刘铁'] print(lst) lst = re.findall("刘.+",strvar) # ['刘能和刘老根和刘铁柱子111子222'] print(lst) lst = re.findall("刘.*",strvar) # ['刘能和刘老根和刘铁柱子111子222'] print(lst) lst = re.findall("刘.{4,}子",strvar) # ['刘能和刘老根和刘铁柱子111子'] print(lst) # 非贪婪匹配 lst = re.findall("刘.??",strvar) # ['刘', '刘', '刘'] print(lst) lst = re.findall("刘.+?",strvar) # ['刘能', '刘老', '刘铁'] print(lst) lst = re.findall("刘.*?",strvar) # ['刘', '刘', '刘'] print(lst) lst = re.findall("刘.{4,}?子",strvar) # ['刘能和刘老根和刘铁柱子'] print(lst)
边界符
\b 本身也是转义字符: 退格( 把光标向左移动一位)
word
右边界: d\b
左边界: \bw
# 右边界 strvar = "word pwd scf" lst = re.findall(r"d\b",strvar) print(lst) # ['d', 'd'] lst = re.findall(r".*d\b",strvar) print(lst) # ['word pwd'] lst = re.findall(r".*?d\b",strvar) print(lst) # ['word', ' pwd'] # 左边界 lst = re.findall(r"\bw",strvar) print(lst) # ['w'] lst = re.findall(r"\bw.*",strvar) print(lst) # ['word pwd scf'] lst = re.findall(r"\bw.*?",strvar) print(lst) # ['w'] lst = re.findall(r"\bw.* ",strvar) print(lst) # ['word pwd '] lst = re.findall(r"\bw.*? ",strvar) print(lst) # ['word '] # \S 匹配的是非空白符 lst = re.findall(r"\bw\S*",strvar) print(lst) # ['word']
^ $ 开头/结尾
^匹配字符串的开头(必须以..开头)
$匹配字符串的结尾(必须以.结尾)
当使用^ 和$ 符号匹配的时候 要把字符串看成整体
strvar = "大哥大嫂大爷" print(re.findall('大.',strvar)) # ['大哥', '大嫂', '大爷'] print(re.findall('^大.',strvar)) # ['大哥'] print(re.findall('大.$',strvar)) # ['大爷'] print(re.findall('^大.$',strvar)) # [] print(re.findall('^大.*?$',strvar)) # ['大哥大嫂大爷'] print(re.findall('^大.*?大$',strvar)) # [] print(re.findall('^大.*?爷$',strvar)) # ['大哥大嫂大爷'] print(re.findall('^g.*? ' , 'giveme 1gfive gay')) # ['giveme '] print(re.findall('five$' , 'aassfive')) # ['five'] print(re.findall('^giveme$' , 'giveme')) # ['giveme'] print(re.findall('^giveme$' , 'giveme giveme')) # [] print(re.findall('giveme' , 'giveme giveme')) # ['giveme', 'giveme'] print(re.findall("^g.*e",'giveme 1gfive gay')) # ['giveme 1gfive']
匹配分组
# 分组练习（用圆括号） print(re.findall('.*?_good','wusir_good alex_good secret男_good')) # ['wusir_good', ' alex_good', ' secret男_good'] # () 优先显示括号里面的内容 print(re.findall('(.*?)_good','wusir_good alex_good secret男_good')) # ['wusir', ' alex', ' secret男'] # ?: 取消显示括号里面的内容 print(re.findall('(?:.*?)_good','wusir_good alex_good secret男_good')) # ['wusir_good', ' alex_good', ' secret男_good'] # | 代表或 , a|b 匹配字符a 或者 匹配字符b . 把字符串长的写在前面,字符串短的写在后面 strvar = "abcdefg" lst = re.findall("a|b",strvar) print(lst) # ['a', 'b'] """在使用|的时候,把不容易匹配到的字符串放到前面,把容易匹配到的放到后面""" strvar = "abciuiuabcdwerewr" lst1 = re.findall("abc|abcd",strvar) # ['abc', 'abc'] lst2 = re.findall("abcd|abc",strvar) # 把不容易匹配的放到前面 ['abc', 'abcd'] print(lst1) print(lst2)
匹配分组练习
. 除了\n 匹配所有字符
\. 代表的, 这个字符本身,不转义
小数和整数
strvar = ".34 .... 78. 78.12 56.3 .3 .4 .5 " # 匹配小数 lst = re.findall(r"\d+\.\d+",strvar) print(lst) # 匹配小数和整数 lst = re.findall(r"\d+\.\d+|\d+",strvar) print(lst) # 分组来表达小数和整数 lst = re.findall(r"\d+(\.\d+)?",strvar) print(lst) lst = re.findall(r"\d+(?:\.\d+)?",strvar) print(lst) # ['34', '78', '78.12', '56.3', '3', '4', '5']
匹配手机号135或者171
# 匹配135或171的手机号 strvar = "13566668888 17166668888" lst = re.findall(r"(?:135|171)\d{8}",strvar) print(lst) # ['13566668888', '17166668888'] # 用^$卡死长度,只能是一个手机号,不能是多个 strvar = "13566668888" lst = re.findall(r"^(?:135|171)\d{8}$",strvar) print(lst) # ['13566668888']
匹配www.baidu.com 或者 www.oldboy.com
strvar = "www.baidu.com www.lagou.com www.oldboy.com" lst = re.findall(r"(?:www).(?:baidu|oldboy).(?:com)",strvar) print(lst) # search 的用法 strvar = "www.baidu.com www.lagou.com www.oldboy.com" obj = re.search(r"www\.(baidu|oldboy)\.(com)",strvar) # 返回的是匹配到的结果 res = obj.group() print(res) # 通过group和下标可以获取到括号的内容(了解) print(obj.group(1)) print(obj.group(2)) # 返回的是括号分组里面的内容 res = obj.groups() print(res)
findall和search的qubie
1. findall 是把 所有符合条件的内容都匹配出来放到列表里, 不能够把匹配到的结果和分组当中的内容显示在同一个界面当中
2. search 按照正则表达式,把第一次匹配到的内容返回出来,返回的是对象,能够把匹配到的结果和分组当中的内容显示在同一个界面当中
对象 group 返回的是匹配到的结果
对象groups 返回的是括号分组里面的内容
如果匹配不到内容,返回的是None 无法调用group 或者 groups方法
匹配 5*6-7/3 计算出最后的结果
strvar = "5*6-7/3" # 匹配5*6 obj = re.search(r"\d+[*/]\d+",strvar) print(obj) strvar1 = obj.group() print(strvar1,type(strvar1),"<===>") # 5*6 <class 'str'> <===> # 计算5*6 num1,num2 = strvar1.split("*") print(num1,num2) strvar2 = str(int(num1) * int(num2)) print(strvar2 ,type(strvar2)) # "30" # 替换5*6 为字符串30 strvar3 = strvar.replace(strvar1,strvar2) print(strvar3 , type(strvar3)) # 30-7/3 <class 'str'> # 匹配7/3 obj = re.search(r"\d+[*/]\d+",strvar3) print(obj) strvar4 = obj.group() print(strvar4) # 7/3 # 计算7/3 num1,num2 = strvar4.split("/") strvar5 = str(int(num1) / int(num2)) print(strvar5 , type(strvar5)) # 替换7/3 为字符串2.333333333333 strvar6 = strvar3.replace(strvar4,strvar5) print(strvar6 , type(strvar6)) # 计算 30-2.3333333333333335 得出最后的结果 num1,num2 = strvar6.split("-") res = float(num1) - float(num2) print(res)
命名分组
反向引用
strvar = "<div> 今天天气不错~ </div>" lst = re.findall("<(.*?)>(.*?)<(.*?)>",strvar) print(lst) # [('div', ' 今天天气不错~ ', '/div')] # 反向引用 : 在匹配到的值,在引用一次 '''\1 把第一个小括号里面的内容,拿出来在匹配一下''' lst = re.findall(r"<(.*?)>(.*?)<(/\1)>",strvar) print(lst) # [('div', ' 今天天气不错~ ', '/div')] # \1 代表反向引用第一个括号 \2代表反向引用第二个括号 strvar = "a1b2cab" # strvar = "f1z2pfz" obj = re.search(r"(.*?)\d(.*?)\d(.*?)\1\2",strvar) print(obj) # <_sre.SRE_Match object; span=(0, 7), match='a1b2cab'> # 获取匹配到的内容 res1 = obj.group() print(res1) # a1b2cab # 获取分组里面的内容 res2 = obj.groups() print(res2) # ('a', 'b', 'c')
命名分组
""" (?P<组名>正则表达式) 给这个组起一个名字 (?P=组名) 引用之前组的名字,把该组名匹配到的内容放到当前位置 """ # 方法一 strvar = "a1b2cab" obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)\1\2",strvar) # 获取匹配到的内容 res1 = obj.group() print(res1) # 获取分组里面的内容 res2 = obj.groups() print(res2) # 方法二 strvar = "a1b2cab" obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)(?P=tag1)(?P=tag2)",strvar) # 获取匹配到的内容 res1 = obj.group() print(res1) # 获取分组里面的内容 res2 = obj.groups() print(res2)
正则函数
1. search 通过正则匹配出第一个对象返回,通过group取出对象中的值
# search 通过正则匹配出第一个对象返回，通过group取出对象中的值 strvar = "1+2 3*4" obj = re.search("\d+(.*?)\d+",strvar) print(obj) # 返回匹配到的内容(匹配到一个就返回) res = obj.group() print(res) # <_sre.SRE_Match object; span=(0, 3), match='1+2'> # 返回分组里面的内容,类型是元组 tup = obj.groups() print(tup[0]) # 1+2
match 验证用户输入内容
# match 验证用户输入内容(了解) """当search函数里面的正则表达式前面加上^ 等价于 matth的用法""" strvar = "a13566668888" obj = re.search("^\d+",strvar) print(obj) # print(obj.group()) obj = re.match("\d+",strvar) print(obj) # print(obj.group())
split 切割
# split 切割 strvar = "alex|xboyww&wusir%ritian" res = re.split("[|&%]",strvar) print(res) # ['alex', 'xboyww', 'wusir', 'ritian'] strvar = "alex234234xboyww6786wusir78967896ritian" res = re.split("\d+",strvar) # ['alex', 'xboyww', 'wusir', 'ritian'] print(res)
sub 替换
# 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
subn 替换
# subn 替换 (用法和sub一样,区别在于返回的是元组 (结果,次数) ) strvar = "alex|xboyww&wusir%ritian" res = re.subn("[|&%]","-",strvar) res = re.subn("[|&%]","-",strvar,1) print(res)
finditer 返回字符串中响应内容,返回迭代器
# finditer 匹配字符串中相应内容,返回迭代器[迭代器中包含的是对象] from collections import Iterator , Iterable strvar = "jkasdfjkadfjk1234asfj2342kfa" it = re.finditer("\d+",strvar) print(isinstance(it,Iterator)) # 获取迭代器里面的内容 for i in it: print(i.group())
compile 指定一个统一的匹配规则
# finditer 匹配字符串中相应内容,返回迭代器[迭代器中包含的是对象] from collections import Iterator , Iterable strvar = "jkasdfjkadfjk1234asfj2342kfa" it = re.finditer("\d+",strvar) print(isinstance(it,Iterator)) # 获取迭代器里面的内容 for i in it: print(i.group())
正则表达式装饰符
# ### 正则表达式修饰符 # re.I 使匹配对大小写不敏感 strvar = "<h1>72347923489</H1>" pattern = re.compile(r"<h1>(.*?)</h1>",flags=re.I) obj = pattern.search(strvar) print(obj) print(obj.group()) # re.M 使每一行都能够单独匹配(多行)，影响 ^ 和 $ strvar = """<h1>72347923489</H1> <p>72347923489</p> <li>72347923489</li> """ pattern = re.compile("^<.*?>(?:.*?)<.*?>$",flags=re.M) lst = pattern.findall(strvar) print(lst) # re.S 使 . 匹配包括换行在内的所有字符 strar = """give 1234234234mefive """ pattern = re.compile("(.*?)mefive",flags=re.S) obj = pattern.search(strar) print(obj) print(obj.group()) # 可以加多个修饰符 通过| 拼接 """ pattern = re.compile("(.*?)mefive",flags=re.S|re.I|re.M) """