首页 > 编程语言> > Python ( 高级第一部)

Python ( 高级第一部)

2020-11-01 16:33:32 作者：互联网

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

1. abs 绝对值

lst= [1,2,3]
res =sum (lst)
print(res)
# 输出结果为 6

2. sum 计算一个序列的和

lst = [1,3,2,5,6]
res = max(lst)
print(res)
# 输出结果为6

3. max 获取序列中最大的值

lst = [1,3,2,5,6]
res = min(lst)
print(res)
# 输出结果为1

4. min 获取序列中最小的值

res = pow (2,3)    # 2 为值   3 为次方
print (res)    
# 输出结果 为 8

5. pow 计算某值的次方

# 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)

ascll 和字符转换

""“注意点:在与用户交互的时候,慎用”""

a=90
exec('print(a)')

exec 将字符串当做 Python代码执行(功能强大)

repr 不转义字符输出字符串

input　接收输入字符串(永远接收字符串)

“”“相同的两个数据经过哈希算法运算得出的结果一定相同”""
res1 = hash(“abc”)
res2 = hash(“abc”)
print(res1,res2)\
# 输出结果为  4521462165539241311 2948100441812388161

hash 生成哈希值

# 正常情况下遵循四色五入, 但是在 n.5 结构中, n为偶数则会舍去,n 为奇数则进一

res1 = round(4.51)  # s
res2 = round((4.5)  #4
res3 = round(3.5)   # 4
res4 = round(4.12)  #4

round 四舍五入

数字模块

# ### 数学模块
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)
"""

标签：第一部,Python,res,高级,re,lst,print,strvar,findall
来源： https://www.cnblogs.com/f211/p/13908073.html

Python ( 高级 第一部)

目录

time时间模块

利用time模块实现动态进度条效果

Python的内置方法

数字模块

随机模块

利用random模块实现验证码的生成

序列化模块 pickle

序列化模块 json

os 系统模块

os模块: 新建和删除

os shutil 模块

os.path 路径模块

文件压缩模块 zipfile

文件压缩

文件解压

文件追加

查看压缩包

文件压缩模块 tarfile

1. 创建atr包

2. 对压缩包进行解压

3. 追加文件

4. 查看包中的文件

计算文件大小 代码

正则表达式

单字符匹配

多字符匹配

贪婪匹配与非贪婪匹配

边界符

^ $ 开头/结尾

匹配分组

匹配分组练习

小数和整数

匹配手机号135或者171

findall和search的qubie

命名分组

反向引用

命名分组

正则函数

1. search 通过正则匹配出第一个对象返回,通过group取出对象中的值

match 验证用户输入内容

split 切割

sub 替换

subn 替换

finditer 返回字符串中响应内容,返回迭代器

compile 指定一个统一的匹配规则

正则表达式装饰符

Python ( 高级第一部)

计算文件大小代码