Python语法进阶篇 --- re库、os库、sys库、time库、logging库、random库
🐹🐹🐹🐹🐹一只正在努力学习计算机技术的小仓鼠🐹🐹🐹🐹🐹
re模块
正则表达式
- 含义：记录文本规则的代码。
优点：通用性强，适用于多种编程语言 缺点：语法复杂，可读性差
正则表达式：字符相关
| 正则表达式 |
描述 |
| . |
匹配任意一个字符，除换行符\n以外 |
| |
匹配中括号内列举的字符 |
| \^abc |
匹配不包含中括号内列举的字符 |
| a-zA-Z |
匹配所有英文字符 |
| 0-9 或 \d |
匹配数字 |
| \D |
匹配非数字 |
| \s |
匹配空格或tab键 |
| \S |
匹配非空格和tab键 |
| \w |
匹配单词字符，即a-z、A-Z、0-9、_、汉字 |
| \W |
匹配非单词字符 |
| \b |
匹配单词边界（非内部位置） |
| \B |
匹配单词内部位置（非边界） |
正则表达式：次数相关
| 正则表达式 |
描述 |
| * |
匹配前一个字符出现0次或者无限次 |
| + |
匹配前一个字符出现1次或者无限次 |
| ? |
匹配前一个字符出现0次或者1次 |
| {m} |
匹配前一个字符出现m次 |
| {m,n} |
匹配前一个字符出现从m次到n次，m必须小于n |
正则表达式：开头结尾
| 正则表达式 |
描述 |
| ^ |
匹配字符串开头 |
| $ |
匹配字符串结尾 |
正则表达式：分组相关
| 正则表达式 |
描述 |
| | |
匹配"|"左右任意一个整体表达式 |
| (ab) |
将括号中字符作为一个分组 |
| \num |
匹配第num分组匹配到的字符串，排序法则：从外到内，从左到右排序 |
match方法
-
描述：从字符串起始位置到结束位置对字符串进行整体匹配，如果匹配成功则返回字符串，失败则返回None
-
结构：re.match(pattern, string, flags)
- pattern --- 匹配的正则表达式
- string --- 目标字符串
- flags --- 标志位
- re.M --- 多行匹配，影响^和$
- re.I --- 使匹配的英文字符大小写不敏感
import re
res = re.match('Tom', 'Tom永远被Jerry揍')
print(res)
# group()用来提取匹配成功的数据
print(res.group())
# span()用来返回字符串匹配的开头和结束位置
print(res.span())
正则表达式 --- 字符案例：
import re
# 1. 匹配任意一个字符，除\n以外
res = re.match(r'.', 'hello')
print(res.group())
# 2. [] 匹配中括号内列举的字符
res = re.match(r'[abcdefgh]', 'hello')
print(res.group())
# 3. [^abc] 匹配不包含中括号内列举的字符
res = re.match(r'[^abcde]', 'hello')
print(res.group())
# 匹配数字
res = re.match(r'[0-9]', '6458')
res = re.match(r'\d', '1234')
print(res.group())
# 匹配非数字
res = re.match(r'\D', 'abc123')
print(res.group())
# 匹配所有英文字母
res = re.match(r'[a-zA-Z]', 'hello')
print(res.group())
# 匹配空格或tab键
res = re.match(r'\s...', ' hello')
print(res.group())
# 匹配非空白
res = re.match(r'\S', 'h ello')
print(res.group())
# 匹配单词字符，即a-z、A-Z、0-9、_、汉字
res = re.match(r'\w\w\w\w', '_仓鼠Hamster_')
print(res.group())
# 匹配非单词字符
res = re.match(r'\W\W', '$￥')
print(res.group())
正则表达式 --- 次数相关案例：
import re
# 1. * 匹配"*"前一个字符出现0次或者无限次，即"*"前一个字符可有可无。
res_1 = re.match(r'T*om', 'TTTom')
res_2 = re.match(r'T*om', 'om')
print(res_1.group())
print(res_2.group())
# 2. + 匹配"+"前一个字符出现1次或者无限次，即"+"前一个字符至少出现1次
res_1 = re.match(r'T+om', 'TTTom')
res_2 = re.match(r'T+om', 'Tom')
# res_3 = re.match(r'T+om', 'om')
print(res_1.group())
print(res_2.group())
# print(res_3.group())
# 3. ? 匹配"?"前一个字符出现1次或者无限次，即"?"前一个字符出现1次或未出现
res_1 = re.match(r'\D+\d?', 'Tom')
res_2 = re.match(r'\D+\d?', 'Tom1')
print(res_1.group())
print(res_2.group())
# 4. {m} 匹配"{m}"前一个字符出现m次
res_1 = re.match(r'\w{2}', 'Tom')
print(res_1.group())
# 5. {m,n} 匹配"{m,n}"前一个字符出现从m次到n次（m<n）
res_1 = re.match(r'\w{1,2}', 'Tom')
print(res_1.group())
正则表达式 --- 开头结尾相关案例：
import re
# 1. ^ 匹配字符串开头
res = re.match(r'^T', 'Tom')
print(res.group())
# 2. $ 匹配字符串结尾
res = re.match('.*m$', 'Tom')
print(res.group())
正则表达式 --- 开头结尾相关案例：
import re
# 1. | 匹配"|"左右任意一个整体表达式
res = re.match('ab|def', 'abc')
print(res.group())
# 2. (ab) 将括号中字符作为一个分组
res = re.match(r'\w+@{1}(163|qq|126){1}(.com){1}', 'Tom@163.com')
print(res.group())
# 3. \num 匹配第num分组匹配到的字符串
res = re.match(r'<(\w+)>\w+</\1>', '<html>Tom</html>')
# 从外到内，从左到右排序
res = re.match(r'<(\w+)><(\w*)>\w+</\2></\1>', '<html><span>Tom</span></html>')
# 拓展：分组命名法（注意：每个命名仅能匹配唯一一个符合规则的字符串，即下次引用该命名就代表该字符串）
res = re.match(r'<(?P<body>\w+)><(?P<contentType>\w+)>\w+</(?P=contentType)></(?P=body)>', '<html><span>Tom</span></html>')
print(res.group())
search方法和findall方法
- search方法：扫描整个字符串并返回第一个成功匹配的对象，如果匹配失败，就返回
None
- findall方法：从头到尾匹配，找到所有匹配成功的数据，返回一个列表
import re
# 1. search()：扫描整个字符串并返回第一个成功匹配的对象，如果匹配失败，就返回None
res = re.search(r'\w', 'python')
print(res.group())
# 2. findall()：从头到尾匹配，找到所有匹配成功的数据，返回一个列表
res = re.findall(r'\w', 'python')
print(res, type(res))
sub方法
sub(pattern, repl, string, count,flags)
- pattern：正则表达式
- repl：被替换后的新内容
- string：字符串
- count：指定替换的次数
import re
res = re.sub(r'\bpython\b', 'Tom', 'Hello, python! I like Python very much!', count=1, flags=re.I)
print(res)
split方法
split(pattern, string, maxsplit)
- pattern：正则表达式
- string：字符串
- maxsplit：指定最大分割次数
import re
res = re.split(r"Tom", "Hello, Tom! I like Tom and Python.", maxsplit=1)
print(res)
贪婪与非贪婪
- 贪婪匹配（默认）：在满足匹配时，匹配尽可能长的字符串。
- 非贪婪匹配：在满足匹配时，匹配尽可能短的字符串，使用
?表示非贪婪匹配。
import re
# 贪婪匹配（默认）：在满足匹配时，匹配尽可能长的字符串
res = re.match('em*', 'emmmm...')
print(res.group())
# 非贪婪匹配：在满足匹配时，匹配尽可能短的字符串，使用？表示非贪婪匹配
res = re.match('em{2,8}?', 'emmmm...')
print(res.group())
os模块
| 方法 |
描述 |
| os.name |
指示正在使用的工作平台（返回操作系统类型） 注：Windows返回nt，Linux返回posix |
| os.getenv(环境变量名称) |
读取环境变量 |
| os.path.split() |
把目录名和文件名分离，以元组的形式接收，第一个元素是目录路径，第二个元素是文件名 |
| os.path.dirname() |
显示文件的目录路径（split分割的第一个元素） |
| os.path.basename() |
显示文件的文件名（split分割的第二个元素） |
| os.path.exists() |
判断路径（文件或者目录）是否存在，存在就返回True，不存在就返回False |
| os.path.isfile() |
判断是否存在文件，存在就返回True，不存在就返回False 注：如果路径是个文件夹则返回False |
| os.path.isdir() |
判断目录是否存在，存在就返回True，不存在就返回False 注：如果路径是个文件则返回False |
| os.path.abspath() |
获取指定文件的绝对路径 |
import os
# 1. os.name：指示正在使用的工作平台（返回操作系统类型）
print(os.name)
# 2. os.getenv(环境变量名称)：读取环境变量
print(os.getenv("path"))
# 3. os.path.split()：把目录名和文件名分离，以元组的形式接收，第一个元素是目录路径，第二个元素是文件名
print(os.path.split(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\main.py"))
# os.path.dirname()：显示文件的目录（split分割的第一个元素）
print(os.path.dirname(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\main.py"))
# os.path.basename()：显示文件的文件名（split分割的第二个元素）
print(os.path.basename(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\main.py"))
# os.path.exists()：判断路径（文件或者目录）是否存在，存在就返回True，不存在就返回False
print(os.path.exists(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\main.py"))
print(os.path.exists(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\test.py"))
# os.path.isfile：判断是否存在文件
print(os.path.isfile(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server"))
print(os.path.isfile(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\test.py"))
# os.path.isdir()：判断目录是否存在
print(os.path.isdir(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server\main.py"))
print(os.path.isdir(r"C:\Users\ZHQ27\Desktop\AIcoding\demo\server"))
# os.path.abspath()：获取指定文件的绝对路径
print(os.path.abspath("main.py"))
sys模块
| 方法 |
描述 |
| sys.getdefaultencoding() |
获取系统默认编码格式 |
| sys.path |
获取环境变量的路径，路径和解释器相关 |
| sys.platform |
获取操作系统平台名称 |
| sys.version |
获取python解释器的版本信息 |
import sys
# 1. sys.getdefaultencoding()：获取系统默认编码格式
print(sys.getdefaultencoding())
# 2. sys.path：获取环境变量的路径，跟解释器相关
print(sys.path)
# 3. sys.platform：获取操作系统平台名称
print(sys.platform)
# 4. sys.version：获取python解释器的版本信息
print(sys.version)
time模块
- 三种时间表示方式
- timestamp：时间戳
- format time：格式化的时间字符串
- struct time：时间元组
| 方法 |
描述 |
| time.sleep() |
睡眠操作，以秒为单位 |
| time.time() |
获取环境变量的路径，路径和解释器相关 |
| time.localtime() |
将一个时间戳转换为当前时区的struct_time |
| time.asctime() |
获取系统当前时间，把struct_time转换成固定的字符串表达式 |
| time.ctime() |
获取系统当前时间，把时间戳转换成固定的字符串表达式 |
| time.strftime(格式化字符串, struct_time) |
将struct_time转换成时间字符串 |
| time.strptime(时间字符串, 格式化字符串) |
将时间字符串转化成struct_time |
import time
# 1. time.sleep()：睡眠操作，以秒为单位
print(123)
time.sleep(2)
print(123)
# 2. time.time()：获取到当前的时间戳，以秒计算，从1970年1月1日00点00分00秒到现在的时间差
print(time.time())
# 3. time.localtime()：将一个时间戳转换为当前时区的struct_time
print(time.localtime())
t = time.localtime()
print('北京时间：', f'{t.tm_year}-{t.tm_mon}-{t.tm_mday} {t.tm_hour}:{t.tm_min}:{t.tm_sec}')
# 4. time.asctime()：获取系统当前时间，把struct_time转换成固定的字符串表达式
t = time.localtime()
print(time.asctime(t))
# 5. time.ctime()：获取系统当前时间，把时间戳转换成固定的字符串表达式
t = time.time()
print(time.ctime(t))
# 6. time.strftime(格式化字符串, struct_time)：将struct_time转换成时间字符串
print(time.strftime("%Y-%m-%d %H-%M-%S", time.localtime()))
# 7. time.strptime(时间字符串, 格式化字符串)：将时间字符串转化成struct_time
print(time.strptime("2026-06-04", "%Y-%m-%d"))
logging模块
-
作用：
- 程序调试
- 了解软件程序运行情况是否正常
- 软件程序运行故障分析与问题定位
-
级别：
-
logging.basicConfig(filename, filemode, level, format, datefmt)
- filename：日志存放文件名
- filemode：日志文件的模式
- level：日志记录等级
- format：日志记录格式
- datefmt：日志记录中的日期格式
-
format常用参考输出格式
| 格式 |
描述 |
| %(levelno)s |
打印日志级别的数值 |
| %(levelname)s |
打印日志级别名称 |
| %(pathname)s |
打印当前执行程序的路径 |
| %(filename)s |
打印当前执行程序名称 |
| %(funcname)s |
打印日志的当前函数 |
| %(asctime)s |
打印日志的时间 |
| %(thread)d |
打印线程id |
| %(process)d |
打印进程id |
| %(message)s |
打印日志信息 |
| %(name)s |
打印logger的名字 |
import logging
logging.basicConfig(
filename='main.log',
filemode='w',
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
logging.debug('我是debug')
logging.info('我是info')
logging.warning('我是warning')
logging.error('我是error')
logging.critical('我是critical')
random模块
- 作用：用于实现各种分布的伪随机数生成器，可以根据不同的实数分布来随机生成值
| 方法 |
描述 |
| random.random() |
生成大于等于0且小于1之间的小数(左闭右开) |
| random.uniform(a, b) |
产生大于等于a且小于b的随机小数(左闭右开) |
| random.randint(a, b) |
产生大于等于a且小于等于b的随机整数(闭区间) |
| random.randrange(a, b, step) |
产生大于等于a且小于b，符合a + n*step的整数(左闭右开) |
import random
# 1. random.random()：生成大于0且小于1之间的小数(左闭右开)
print(random.random())
# 2. random.uniform()：产生指定范围的随机小数(左闭右开)
print(random.uniform(1, 3))
# 3. random.randint(a, b)：产生指定范围内的随机整数(闭区间)
print(random.randint(1,3))
# 4. random.randrange(start, stop, [step])：产生start, stop范围内的整数，包含开头但是不包含结尾(左闭右开)
print(random.randrange(2,8,2))