常用模块
re模块
引用：import re
应用:常应用于正则表达式
正则表达式：正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。****（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行
常用匹配模式：
w：代表一个字符，匹配一个数字、字母或下划线字符
print(re.findall('w','Aah123+-_'))
#输出为['A','a','h','1','2','3','_']
W：代表一个字符，匹配一个非数字、字母和下划线字符
print(re.findall('W','Aah123+-_'))
#输出为['+','-']
s:代表一个字符，匹配一个空字符
S:代表一个字符，匹配一个非空字符
d:代表一个字符，匹配一个数字字符
D:代表一个字符，匹配一个非数字字符
^：仅从头开始匹配
print(re.findall('^alex','alex is alex is nb'))
#输出为['alex']
$:仅从尾部开始匹配
print(re.findall('^alex',' is alex is alex'))
#输出为['alex']
. :代表匹配一个字符，该字符可以是除换行符之外任意字符
print(re.findall('a.c','a a1c aaac a c asfdsaf a
c'))
#输出为['a1c','a c']
print(re.findall('a.c','a a1c aaac a c asfdsaf a
c',re.DOTALL))
#输出为['a1c','a c','a
c]加re.DOTALL换行符也能匹配
[]:代表匹配一个字符，这一个字符是来自于我们自定义的范围
print(re.findall('a[0-9]c','a,c a a1c a9c aaac a c asfdsaf a
c',re.DOTALL))
#匹配a加0到9的数字加c的组合
print(re.findall('a[a-zA-Z]c','a,c aAc a1c a9c aaac a c asfdsaf a
c',re.DOTALL))
#匹配a加字母加c的组合
重复匹配
？：代表左边那个字符出现0次到1次
*：代表左边那一个字符出现0次到无穷次
+：代表左边那一个字符出现1次到无穷次
{n，m}：代表左边那个字符出现n次到m次
.*:匹配任意0个到无穷个字符，贪婪匹配
*？:匹配任意0个到无穷个字符，非贪婪匹配
print(re.findall('ab?','a ab abb abbbb a123b a123bbbb'))
#输出为['a','ab','ab','ab','a','a']
|:代表或者的意思
print(re.findall('companies|company','Too many companies have gone bankrupt,c and the next one is my company'))
#输出为['companies','company']遇到两个其中一个都匹配
():分组
print(re.findall('compan(?:ies|y)','Too many companies have gone bankrupt,c and the next one is my company'））
#输出为['ies','y']只输出匹配的分组部分的
常用模块
re.compile：可以提前定义匹配的字符
attern=re.compile('alex')
print(pattern.findall('alex is alex is alex')) # 以alex匹配
print(pattern.search('alex is alex is alex')) # 只匹配一个alex
print(pattern.match('alex is alex is alex')) # 只匹配以alex开头的字符
hashlib模块
什么是hash
hash是一种算法，该算法接受一系列的数据，经过运算会得到一个hash值
hash具备三大特性：
1、只要传入的内容一样，那么得到的hash值一定是一样
2、只要采用hash算法固定，无论传入的内容多大，hash指的长度都是固定的
3、hash值不可逆，即不能通过hash之逆推出内容(被中国女博士实力打脸)
为何要用hash
特性1+2==》文件完整性校验
特性3====》加密
logging模块
简单的使用
logging.debug("这是一条日志信息!") #没有输出任何内容
因为loggong模块为日志划分了级别 由于你输出的级别没有达到最低级别所以没有输出
为什么要设置最低等级 因为一些级别的日志 对我是无用的
import logging
logging.info("info")
logging.debug("debug")
logging.warning("warning")
logging.error("error")
logging.critical("critical")
默认情况下,级别为warning,输出的位置是控制台,默认的日志格式 为 级别:日志生成器的名称:调试的消息
如何修改默认的行为
import logging
logging.basicConfig(filename="mylog.txt", # 指定的日志文件名
filemode="a", #指定的是文件打开的模式 通常为a
level=logging.DEBUG, # 指定级别
format="%(filename)s %(levelname)s %(asctime)s %(message)s",# 指定显示格式
)
logging.info("info")
logging.debug("debug")
logging.warning("warning")
logging.error("error")
logging.critical("critical")
需求: 有一个登陆注册 功能 需要记录用户操作日志, 程序员需要看到最详细的信息,而boss只需要看到简单的操作信息
自定义四种核心角色 完成日志的输出
参数指定的是生成器的名称 (因为可以同时存在多个生成器)
mylog = logging.getLogger("mylog")
# 设置生成器的级别 低于该级别的不会生成
mylog.setLevel(10)
# 过滤器 这里不讲! 需要使用面向对象的基础知识点! (不常用)
# 处理器
handler = logging.FileHandler("youlog.txt",encoding="utf8",)
#将处理器 绑定给生成器, add函数表明了 一个生成器可以添加多个处理器
mylog.addHandler(handler)
# 格式化处理器
formater = logging.Formatter(fmt="%(filename)s %(levelname)s %(asctime)s %(message)s")
# 将格式化处理器 绑定给 handler
handler.setFormatter(formater)
mylog.info("info")
mylog.debug("debug")
mylog.warning("warning")
mylog.error("error")
mylog.critical("critical")
# 实现 按照不同的格式输出到不同的文件中
mylog = logging.getLogger("mylog")
# 设置生成器的级别 低于该级别的不会生成
mylog.setLevel(10)
# 过滤器 这里不讲! 需要使用面向对象的基础知识点! (不常用)
# 给程序员看的日志处理器
handler1 = logging.FileHandler("youlog.txt",encoding="utf8",)
#将处理器 绑定给生成器, add函数表明了 一个生成器可以添加多个处理器
mylog.addHandler(handler1)
# 给老板看的日志处理器
handler2 = logging.FileHandler("boss.txt",encoding="utf8",)
#将处理器 绑定给生成器, add函数表明了 一个生成器可以添加多个处理器
mylog.addHandler(handler2)
# 程序员的格式化处理器
formater1= logging.Formatter(fmt="%(threadName)s %(funcName)s %(module)s %(filename)s %(levelname)s %(asctime)s %(message)s")
# 将格式化处理器 绑定给 handler
handler1.setFormatter(formater1)
# 老板的格式化处理器
formater2= logging.Formatter(fmt="%(levelname)s %(asctime)s %(message)s")
# 将格式化处理器 绑定给 handler
handler2.setFormatter(formater2)
mylog.info("info")
mylog.debug("debug")
mylog.warning("warning")
mylog.error("error")
mylog.critical("critical")
logging.config 专门用于配置logging 模块
import logging.config
# 导入包含配置字典的模块
import loggin_config
# 通过一个字典来配置 logging模块
logging.config.dictConfig(loggin_config.LOGGING_DIC)
通过名称 来获取一个生成器
aaloger = logging.getLogger("aa")
# 输出日志
aaloger.info("测试信息!")
# 当要获取的名称不存在时 会返回一个默认的生成器
aaloger = logging.getLogger("aasadsadsa")
print(aaloger.name)
# # 输出日志
aaloger.warning("测试信息!")
配置字典
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
logfile_path = "dictconfig.log"
LOGGING_DIC = {
'version': 1,
# 是否禁用已存在的生成器 这个值保持为False
'disable_existing_loggers': False,
# 四个key不能随便写 是固定
'formatters': {
# standard 表示格式化处理器的名字 相当于变量名称 可以随便写
'standard': {
# format是固定的不能随便写
'format': standard_format
},
'simple': {
'format': simple_format
},
},
'filters': {},
'handlers': {
#打印到终端的日志
#console是处理器的名称 可以随便写
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple'
},
#打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard',
'filename': logfile_path, # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5, #日志文件最大个数
'encoding': 'utf-8', # 日志文件的编码
},
"ATM":{
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard',
'filename': "ATMlog.txt", # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5, #日志文件最大个数
'encoding': 'utf-8', # 日志文件的编码
}
},
'loggers': {
#logging.getLogger(__name__)拿到的logger配置
#aa是生成器的名称 可以随便写
# 如果将key(生成器名称)设置为空 则意味着将它作为默认的是你生成器
'': {
'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递 日志的继承
},
"atm":{
'handlers': ['ATM'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递 日志的继承
}
},
}
shelve模块
用于序列化的模块
json,pickle
import shelve
s = shelve.open("test.she")
s["name"] = "爱跟"
s = shelve.open("test.she")
s["dic"] = {"age":20}
s = shelve.open("test.she")
print(s["dic"])
shelve 模块只有一个函数 就时 open 用于打开一个文件,
打开以后 操作方式与字典完全一致,你可以把它当成字典,而且自带buff的字典,可以字典给完成序列化
同样支持 python所有的基础数据类型
该模块序列化得到的数据 只能被该模块使用 其他语言没有这个模块 所有无法使用 即无法跨平台
当你写的程序是一个单机程序时 可以考虑
后期 只要设计到数据交换 就应该使用json
sys模块
sys模块
是system的缩写 表示系统
注意
os operation system 指的是 操作系统
而sys值的是python 解释器
import sys
# 用于接收操作系统调用解释器时传入的参数
# 当你要开发一款基于CMD的程序时 就需要使用这个属性了 因为一些操作系统没有界面 只能通过CMD来使用
print(sys.argv)
# 用于退出解释器 0表示正常退出
# 3.sys.exit(0)
print(sys.version)
print(sys.platform)
需求 开发一个基于CMD的复制文件的工具
第一个参数表示被执行的py文件 第二个作为源文件路径 第三个作为目标文件的路径
source_path = 3.sys.argv[1]
target_path = 3.sys.argv[2]
print(source_path)
print(target_path)
with open(source_path,"rb") as f:
with open(target_path,"wb") as f1:
while True:
data = f.read(1024)
if not data:
break
f1.write(data)
总结 3.sys 处理与python解释器相关的一些操作
常用的两个
添加环境变量 3.sys.path
获取调用解释器参数 3.sys.argv
os模块
os 表示操作系统
该模块主要处理与操作系统相关的操作
最常用的是文件操作
打开 读取 写入 删除 复制 重命名
当前执行文件所在的文件夹路径
print(os.getcwd())
修改当前的工作目录
os.chdir(r"D:脱产5期内容day19")
获取当前目录的 字符串表现方式 .
print(os.curdir)
获取当前目录的 字符串表现方式 ..
print(os.pardir)
创建多级目录 可以自动创建中间的目录 如果不存在
os.makedirs("a/b/c")
只能创建单级目录 会把c1和a1当成已存在的路径
os.mkdir("c1/a1/b1")
删除文件夹 必须保证文件夹是空的 才能删除
os.rmdir("a")
如果要删除一个文件夹 而且文件夹不为空 ,思路是 先遍历这个文件夹中的所有文件 和文件夹
先把里面的内容全部删除 最后再删除文件夹
os.rmdir("b")
要删除的文件路径
path = r"D:脱产5期内容day19"
for f in os.listdir("b"):
f_path = path + "\" + f
os.remove(f_path)
os.rmdir("b")
注意遍历删除文件时 listdir 得到的是文件名称 需要手动拼接完整路径
print(os.stat("os模块.py"))
获取当前的路径分割符 当你的程序要跨平台时 路径分隔符不能直接写死 要从os中获取,
因为每个平台不同
print(os.sep)
获取换行符
print(os.linesep)
执行系统命令
print(os.system("dir"))
print(os.environ)
什么时候使用os 当需要操作文件 及文件夹的时候
重点放在对文件的增删改查
os.path模块
path 翻译为路径
该模块用于处理路径
之所有有这个模块 是因为python时跨平台的 各平台的路径书写方式不同,所以将所有与路径相关都进行了封装
使用了path后 你的程序就是跨平台的 不会因为路径而产生错误
# 返回绝对路径 其实就是把当前执行文件所在的文件夹 与你给的参数做了拼接
print(os.path.abspath('模块os，path.py'))
# 将路径分割为文件夹和文件名
print(os.path.split())
# 获取路径中的文件夹名称
print(os.path.dirname())
# 获取路径中的文件名称
print(os.path.basename())
# 判断一个文件路径是否存在
print(os.path.exists())
# 判断是否是文件的绝对路径 依据是 第一个字符是不是路径分割符
print(os.path.isabs())
# 判断是否是文件
print(os.path.isfile())
# 判断是否是一个文件夹
print(os.path.isdir())
# 以当前平台的路径分割符来拼接路径 如果有多个盘符取的是最后一个
print(os.path.join())
# 获取文件大小
print(os.path.getsize())
# 获取最后存取时间
print(os.path.getatime())
# 获取最后修改时间
print(os.path.getctime())
# 返回规范化路径 大写变小写，反斜杠变成正斜杠
print(os.path.normcase())
# 把反斜杠转成正斜杠，并且 会执行里面..（用于返回上一级目录）
print(os.path.normpath())
import sys,os
# 添加环境变量
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
# 导入配置文件
from conf import settings
# 访问配置文件中用户数据的路径
print(settings.USERDATA_PATH)
总结：主要处理路径 不会关心路径是否存在 只是做拼接 剪切 转换等操作
通常是与os一起使用
优点：用他处理路径跨平台使用
configparser模块
import configparser
# 创建一个配置文件解析器
cfg = configparser.ConfigParser()
# 读取名为test.cfg的配置文件
cfg.read("test.cfg",encoding="UTF-8")
# 获取分区
print(cfg.sections())
# 获取某个分区下的某个选项 第一个参数分区名 第二个选项名称
username = cfg.get("mysql","username")
print(username)
print(type(username))
password = cfg.get("mysql","password")
print(password)
print(type(password))
print(int(password))
lock = cfg.get("mysql","lock")
print(lock)
print(type(lock))
print(bool(lock))
lock = cfg.getboolean("mysql","lock")
print(type(lock))
print(lock)
# 以下三个函数是帮你封装了 类型转换
cfg.getfloat()
cfg.getint()
cfg.getboolean()
# 读取配置信息 两步
# 1.读取某个配置文件
# 2.调用get函数
import configparser
# 修改
cfg = configparser.ConfigParser()
cfg.read("test.cfg",encoding="utf-8")
# 将mysql分区下的lock改为True
cfg.set("mysql","lock","true")
with open("test.cfg","wt",encoding="UTF-8") as f:
cfg.write(f)
# 添加新的选项 port 值为3306
cfg = configparser.ConfigParser()
cfg.read("test.cfg",encoding="utf-8")
# 添加新的分区
cfg.add_section("新分区")
# 添加新的选项 port 值为3306
cfg.set("mysql","port","3306")
with open("test.cfg","wt",encoding="UTF-8") as f:
cfg.write(f)
# 删除
cfg = configparser.ConfigParser()
cfg.read("test.cfg",encoding="utf-8")
# 删除分区
cfg.remove_section("新分区")
# 删除某个分区的选项
cfg.remove_option("mysql","port")
# 判断是否存在某个分区
print(cfg.has_section("mysql"))
# 判断是否存在某个选项
print(cfg.has_option("mysql","username"))
with open("test.cfg","wt",encoding="UTF-8") as f:
cfg.write(f)
作为配置文件 最常用的操作就是读取 很少会做修改
总结: read读取配置文件
add_section 添加分区
set 如果没有这个选项则添加
remove_section 删除分区
remove_option 删除选项
shutil模块
shutil模块 是一个工具包,封装了文件高级操作,让你操作起来更方便
功能与os有些重叠 ,os 只能帮你处理文件是否存在啊 路径是否正确等,
无法直接完成copy等操作
还提供了压缩与解压缩
import shutil
shutil.copyfile(r"D:脱产5期内容day19shutil模块shutil模块.py",r"D:脱产5期内容day19shutil模块shutil模块.py2")
# 压缩文件 支持的格式 zip 和tar
shutil.make_archive("shutil模块",
"zip",
r"D:脱产5期内容day19",
"D:脱产5期内容day19这是压缩后的文件")
# 解压缩
shutil.unpack_archive(r"shutil模块.zip",
r"D:脱产5期内容day19shutil模块解压的文件夹",
r"zip")
subprocess模块
subprocess 翻译为子进程
进程指的是 正在运行的程序
子进程 是由另一个正在运行程序启动的程序 例如 qq聊天 点击了一个连接 打开了浏览器 那么浏览器称之为qq的子进程
为什么使用子进程 ? 当我们有一个任务需要处理 而自己的程序无法处理 所以需要开启另一个程序
例如 在python 想要获取所有的进程(任务列表)信息
import os
os.system(r'"D:Program Files (x86)TencentQQBinQQScLauncher.exe"')
res = os.system("dir")
print(res)
# os.system 在执行系统指令时 也可以命令操作系统启动某个程序
# os.system在执行时 直接把结果输出到了 控制台 如果我们要获取执行的结果 就无能为力了
# subprocess 不仅可以启动子进程 还能与子进程进行数据交互
import subprocess
# dir 表示要执行命令
# shell 表示dir是一个命令
# stdout指定输出管道
# 管道是什么? 相当于生活中的水管 水可以通过管道 从一个地方流到另一个地方
# 在程序中 数据相当于水 管道的作用,就从一个进程中把数据传输到另一个进程
# 本质上是读写同一个文件
p = subprocess.Popen("dir",shell=True,stdout=subprocess.PIPE)
print(p.stdout.read())
# 上面代码是 启动了一个dir子进程 并将结果输出到指定管道
# 启动一个tasklist子进程 指定输出结果到管道中
p1 = subprocess.Popen("tasklist",shell=True,stdout=subprocess.PIPE)
# 启动一个findstr的子进程 将p1进程的结果作为p2进程输入
p2 = subprocess.Popen("findstr cmd", # 要执行的指令
shell=False,# 第一个参数是否是一个指令
stdin=p1.stdout, # 指定输入管道
stdout=subprocess.PIPE,#指定输出管道
stderr=subprocess.PIPE) # 表示错误管道 当进程执行出错时 可以在错误管道中获取结果
# 读取p2进程的结果
print(p2.stdout.read())
print(p2.stderr.read().decode("GBK"))
总结 ：当你需要在python中启动一个子进程 并且它进行数据交互时就使用subprocess如果不需要数据交互 可以使用os.system