Python之旅7 - Python常用模块合集

1、模块是什么？

简单来说一个.py文件就称为一个模块，通常情况下，我们把能够实现某一特定功能的代码放到一个文件中，作为一个模块，能方便其他程序和脚本导入并使用。

使用模块也可以避免函数名和变量名的重名产生的冲突。

1.1、自定义模块

实现自定义模块分为：创建模块和使用模块两个部分

创建模块：其实就是创建一个.py文件

注意事项：

①创建模块时，设置的模块名称尽量不要与python的标准库模块名称相同

②模块文件的扩展名必须是.py

1.2、 使用模块：使用import语句来导入

常用的import语法格式有：

import module_name [as name]  (import 模块名 [as 别名])如果模块名称过长，可以利用as关键字为模块设置别名

from package_name.module_name import struct_name [as name] (from 包.模块名称 import 结构名称 [as 别名])

如果不想每次都受到模块名称或者模块别名的繁琐，可以使用from - import结构来导入指定模块的指定结构

1.3、包 package

包是一个分层次的目录结构，它将一组功能结构相近的模块组织在一个目录下，可以避免模块重名引起冲突，也可以规范化代码

创建包和使用包：

创建包实际上就是创建一个文件夹，并且在该文件夹中创建一个名称为__init__.py的python文件。

在__init__.py文件中可以不写任何代码，也可以编写一些python代码。在__init__.py文件中编写的代码会在导入包时自动执行。

使用包：

import package_name.module_name

from package_name import module_name

from package_name import * (从包内导入所有模块)

from package_name.module_name import struct_name

 

1.4、python中的模块可以分为2类：

远程服务器仓库：保存官方发布的python模块，供所有开发者使用，需要单独下载

本地模块仓库：用户自定义模块，系统模块，已经从远程服务器仓库下载的模块都保存在本地仓库中，这样我们才能使用import语句来进行导入

 

1.5、pip模块管理工具

 python除了系统自身提供的模块之外，还有很多的第三方处理模块，当我们要是用第三方模块是，就需要使用到python提供的pip管理工具

一般情况下，在我们安装好了python的开发环境后，其实就已经自动安装了pip工具

在命令行方式下直接输入pip命令就可以直接执行pip工具了

常用的一些pip命令

pip --help  查看pip命令帮助手册

pip search module_name   查看module_name模块是否存在

pip install module_name  为本地python环境安装module_name模块

pip download module_name  下载模块到本地

pip list 查看本地所有已安装的模块

pip list --outdated  列出所有已被更新的模块

pip install --upgrade setuptools  更新指定模块

pip uninstall module_name -y 卸载本地module_name模块

 

1.6 python虚拟环境

虚拟环境是python项目开发中常用的一种模式，利用虚拟环境的配置可以避免因模块版本不同影响程序的正常运行，使得项目的开发更加具有良好的隔离性。

安装virtualenv工具 ==>  pip install virtualenv

示例：

① 在d:\pythonproject 目录下创建一个python的虚拟运行环境

virtualenv --no-site-packages venv   

此时就创建了一个“纯净”的python运行环境，python中的所有第三方模块都不会被复制过来

默认情况下，虚拟环境是不会启动的，需要手动激活

激活路径：项目路径\虚拟环境名称\Scripts\activate.bat

② 激活venv虚拟环境

d:\pythonproject\venv\Scripts\activate.bat

③ 在venv虚拟环境中安装第三方模块

pip install module_name

④ 退出虚拟环境

d:\pythonproject\venv\Scripts\deactivate.bat

 

1.7 模块打包

python为了方便进行模块打包，专门提供了一个setuptools模块，利用模块中的setup()函数可以将模块打包为一个后缀名为*.whl模块文件。（也就是常说的wheel轮子文件）

setup()函数常用打包参数：

name：打包后生成文件名称

version：打开后生成的版本编号

author：开发程序的作者名称

author_email：开发程序作者的邮箱

maintainer：维护程序人员的姓名

maintainer_email：程序维护人员的邮箱

url：程序开发网站地址

license：程序授权信息

description：程序的简单说明

long_description：程序的详细说明

platforms：程序使用的软件平台列表

classifiers：程序所属分类

keywords：程序关键字列表

packages： 打包目录，可以使用find_packages()配置

data_files： 打包所需要的数据文件

scripts： 程序安装时要执行的脚本列表

package_dir： 定义模块源代码映射目录

packag_data： 定义包含的数据文件配置

exclude：  定义排除文件

 

 

2、sys模块

sys模块是一个和系统环境有关的模块，通过使用sys模块可以实现与当前程序所在系统环境进行交互。

 

sys模块的变量和函数

sys.argv    属性变量，程序接收初始化参数的列表

sys.path    属性变量，程序进行模块加载的变量列表

sys.modules    属性变量，包含系统全部导入的模块列表

sys.platform    属性变量，获取当前操作系统的平台信息

sys.stdin    属性变量，标准输入设备（键盘）

sys.stdout    属性变量，标准输出设备（显示器）

sys.stderr    属性变量，标准错误输出

sys.exit([arg])    退出程序，设置为0表示政策退出，如果设置为其他数据则抛出异常

sys.getdefaultencoding()    获取当前系统编码

sys.setdefaultencoding()    设置系统编码

sys.getfilesystemencoding()    获取文件系统编码

 

3、随机数random模块

常用random模块的函数

 

random.random()   生成0~1之间的浮点数

random.uniform(a,b)   生成指定区间范围内的浮点数

random.randint(a,b)   生成a-b之间的随机整数

random.choice()   从sequence（序列，列表、元组和字符串）中随机获取一个元素

random.choices(sequence,k=n)    从sequence（序列，列表、元组和字符串）中随机获取k个(可能重复)元素,n用参数名传值，n省略则默认取1个，返回list。

random.shuffle(list)    将一个列表中的元素打乱(洗牌)，随机排序。直接随机改变原list的排序

random.sample(list,int)    从指定序列中随机获取指定长度的片段，原有序列不会改变。有两个参数，指定序列、需获取的片段长度。

random.randrange(start,end,step)    获取区间内的一个随机数

randrange()函数的参数与range()相同,其功能相当于choice(range(start, stop, step))，但并不实际产生range对象，该函数返回值类型是int

random.seed()    只要设置相同的seed，每次生产的随机数相同，使得随机数据可预测。可在调用其他随机模块之前调用。

 

4、数学math模块

math.pi    常量，圆周率

math.e     常量，常数

math.ceil(n) 计算≥n的最小整数，如果是整数则返回自身

math.floor(n) 计算≤n的最小整数，如果是整数则返回自身

math.exp(n) 计算e的n次方

math.pow(a, b) 返回a的b次方

math.sqrt(n) 计算n的平方根

math.fabs(n) 计算n的绝对值

math.factorial(n) 计算阶乘

math.fmod(a, b) 计算a/b的余数，返回类型为浮点数

math.trunc(n) 返回整数部分

math.fsum(seq) 对序列seq进行求和计算

math.gcd(a, b) 返回a和b的最大公约数

math.log(n) 返回以e为底指定数字的自然对数

math.log2(n) 返回以2为底的自然对数

math.log10(n) 返回以10为底的自然对数

math.sin(n) 根据弧度求正弦

math.cos(n) 根据弧度求余弦

math.tan(n) 根据弧度求正切

math.asin(n) 根据弧度求反正弦

math.acos(n) 根据弧度求反余弦

math.atan(n) 根据弧度求反正切

math.degrees(n) 将弧度转换为角度

math.radians(n) 将角度转换为弧度

 

5、数学 cmath模块

cmath模块和math模块的函数功能类似，区别在于cmath实现了所有复数数据的计算

 

6、copy模块

copy.copy()    浅拷贝

copy.deepcopy()    深拷贝

深浅拷贝的详细说明参考：https://www.cnblogs.com/gdbd/p/16124641.html

 

7、时间 time模块

time模块是python内置的日期时间管理模块，python中有3种方式来表示时间

• 时间戳(timestamp)
• 格式化的时间字符串
• 元组时间(结构化时间)

时间戳概念：时间戳是指格林尼治时间1970年1月1日00时00分00秒(北京时间1970-01-01 08:00:00)到现在的总秒数.

格式化时间

%y 2位数的年份表示(00~99)
%Y 4位数的年份表示(0000~9999)
%m 月份(01~12)
%d 月的一天(0~31)
%H 24小时制小时数(0~23)
%I 12小时制小时数(0~12)
%M 分钟数(00~59)
%M 秒(00~59)

%a 本地简化的星期名称
%A 本地完整的星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M或P.M的等价符
%U 一年中的星期数(00~53) 星期天为一星期的开始
%w 星期(0~6)星期天为一星期的开始
%W 一年中的星期数(00~53) 星期一为一星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称

时间元组

tm_year 年 0000~9999
tm_mon 月 0-12
tm_mday 日 1-31
tm_hour 时 0-23
tm_min 分 0-59
tm_sec 秒 0-60/61(60或61 61位闰秒)
tm_wday 星期 0-6(0是周一)
tm_yday 一年的第几天 1-366
tm_isdst 夏令时 -1,0,1(-1是决定是否为夏令时的旗帜)

time模块的函数

time.time() 返回当前时间的时间戳(从格林尼治时间1970-01-01 00:00:00起至现在的总秒数)

time.localtime() 将时间戳格式化为时间元组对象，如果没有传入时间戳则默认为使用当前时间戳

time.gmtime() 将时间戳转为时间元组(struct_time)对象

time.mktime() 将时间元组(struct_time)对象转为时间戳（gmtime()与mktime() 互逆）

time.ctime() 将时间戳转为格式化日期时间字符串

time.asctime() 将时间元组对象转为格式化日期时间字符串，如果没有传递时间元组，则获取当前日期时间

time.strftime() 将时间元组对象转为格式化日期时间字符串

time.strptime() 将格式化日期时间字符串转为时间元组对象（strftime()函数与strptime()函数互逆）

time.perf_counter() 返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。

time.process_time() 返回当前进程执行 CPU 的时间总和，不包含睡眠时间。

 

time模块函数之间的相互转换：

  

8、datetime模块

datetime模块是对time模块的包装，简化对日期时间等内容的操作

datetime模块的两个常量：

datetime.MINYEAR   最小的年份1

datetime.MAXYEAR  最大的年份9999 

datetime模块主要包含5个类：

• • date 日期类
  • time 时间类
  • datetime 日期时间类（其实就是日期和时间类的结合）
  • timedelta 时间间隔类
  • tzinfo 时区类

8.1 date类

datetime.date(year,month,day) 创建日期对象

属性：

datetime.date.max 获取date可以描述的最大日期 0001-01-01

datetime.date.min 获取date可以描述的最小日期 9999-12-31

datetime.date.resolution 获取date表示日期的最小单位（天） 1 day 0:00:00

方法：

datetime.date.today() 获取当前系统时间

datetime.date.weekday() 返回星期数据【0~6（周一到周日）】

datetime.date.isoweekday()返回星期数据【1~7（周一到周日）】

datetime.date.replace(year,month,day) 替换日期数据并生成新的日期

datetime.date.isocalendar() 返回日期数据元组

datetime.date.fromisocalendar() date.isocalendar()的反向操作，根据日期数据元组获取日期数据

datetime.date.fromtimestamp(timestamp) 通过时间戳获取日期数据

datetime.date.isoformat() 返回格式化日期数据 格式为：YYYY-MM-DD

datetime.date.fromisoformat() date.isoformat()的反向操作，根据YYYY-MM-DD格式字符串获得日期数据

datetime.date.fromordinal(ordinal) 接收一个大于0整数，得到从0001-01-00开始过了几天后的日期。

datetime.date.toordinal() 按年月日的顺序返回Gregorian Calendar日期；

datetime.date.timetuple() 返回与time.localtime()兼容的本地时间元组

 

8.2 time类

 

创建time对象

datetime.time(hour,minute,second,microsecond,tzinfo) 创建时间对象

time对象的属性

datetime.time.max 获取time可以描述的最大时间

datetime.time.min 获取time可以描述的最小时间

datetime.time.resolution 获取time可以表示时间的最小单位

time对象的常用方法

datetime.time.replace(hour,minute,second,microsecond,tzinfo)替换time对象中的时分秒微秒时区信息

datetime.time.isoformat() 获取格式化时间字符串 HH:MM:SS:ssssss

datetime.time.fromisoformat() time.isoformat()的反向操作，根据格式化时间字符串获取时间

 

 

8.3 datetime类

 

datetime.datetime类是日期与时间操作类，可以理解为日期类date和时间类time的信息总和

 

创建日期时间对象：

datetime.datetime()  实例化datetime对象

 

datetime类的属性：

datetime.datetime.max 获取datetime可以描述的最大日期时间

datetime.datetime.min 获取datetime可以描述的最小日期时间

datetime.datetime.resolution 获取datetime可以表示的最小日期时间单位

 

datetime类的方法：

datetime.datetime.now([tzinfo])获取本地当前日期时间或指定时区日期时间对象

datetime.datetime.utcnow() 获取当前utc日期时间对象（格林尼治时间）

datetime.datetime.today() 获取本地当前日期时间datetime对象

datetime.datetime.date() 获取datetime对象日期部分

datetime.datetime.time() 获取datetime对象时间部分

datetime.datetime.strftime() 将格式化字符串转为datetime对象

datetime.datetime.strptime()将datetime对象转为日期时间格式化字符串

datetime.datetime.fromtimestamp() 根据时间戳创建datetime对象

datetime.datetime.isoformat() 返回格式化日期时间数据

datetime.datetime.fromisoformat() datetime.isoformat()的反向操作，根据日期时间格式化字符串返回datetime对象

datetime.datetime.isocalendar() 返回日期时间元组数据

datetime.datetime.fromisocalendar() datetime.isocalendar()的反向操作，根据日期时间元组数据返回datetime对象

datetime.datetime.isoweekday() 返回一周中的某一天，1为周一，7为周日（0001-01-01为周一）

datetime.datetime.combine(date,time,tzinfo) 从给定日期和给定时间（时区）构造一个datetime对象

 

 

8.4 timedelta类

 

datetime.timedlta是可以对指定日期时间单元数据进行加法和减法计算的类

 

 

from datetime import datetime, timedelta

dt_obj = datetime(2022, 5, 29, 1, 10, 38)  # 创建一个datetime对象
dt_obj += timedelta(days=20)  # 计算20天后的日期时间
print(dt_obj)
dt_obj += timedelta(hours=20)  # 计算20小时后的日期时间
print(dt_obj)

 

 

 

备注：timedalta对象可传递的参数有day，hours、minute、seconds、milliseconds、microseconds【天、时、分、秒、毫秒、微秒】

8.5 tzinfo类 

 datetime.tzinfo时区类（我觉得这个类在我个人当前的学习中不是那么重要，就初略做了下笔记，有需求的朋友可搜下相关大牛们的讲解。）

可以通过tzinfo来设置时区信息，但是此类在使用时需要定义子类，并且在子类中重写tzname()、utcoffset()、dst() 3个方法

 

9、hashlib模块

简单的来理解hashlib模块是python提供的一些加密算法操作（哈希算法）

简单的操作如下： 

import hashlib

string = 'hello world'
# 1. md5加密算法 hashlib.md5()

md5 = hashlib.md5()
md5.update(string.encode('utf8'))  # 转码，update里的必须是字节型
res = md5.hexdigest()  # 返回字符型摘要信息
print(res)  # 返回字节型的摘要信息print("md5加密结果:",res)

# 2. sha1加密算法 hashlib.sha1()
sha1 = hashlib.sha1()
sha1.update(string.encode("utf8"))
res2 = sha1.hexdigest()
print(res2)

# 3. sha224()算法 hashlib.sha256()
# 4. sha256()算法 hashlib.sha256()
# 5. sha384()算法 hashlib.sha384()
# 6. sha512()算法 hashlib.sha512()

# 7. 高级加密
md5 = hashlib.md5()
md5.update('md5'.encode('utf-8'))
res = md5.hexdigest()
print("普通加密:", res)
md51 = hashlib.md5(b'hello')
md51.update('md51'.encode('utf-8'))
res = md51.hexdigest()
print("采用key加密:", res)

  

10、logging模块

 logging模块定义了为应用程序和库实现灵活的事件日志记录的函数和类

10.1、日志级别

 

DEBUG    打印全部的日志(NOTSET等同于DEBUG).用来记录详细的信息，方便定位问题进行调试，在生产环境我们一般不开启DEBUG

INFO    打印 INFO,WARNING,ERROR,CRITICAL级别的日志，用来记录关键代码点的信息，以便代码是否按照我们预期的执行，生产环境通常会设置INFO级别

WARNIG    打印 WARNING,ERROR,CRITICAL级别的日志.记录某些不预期发生的情况，如磁盘不足

ERROR    打印 ERROR,CRITICAL级别的日志.由于一个更严重的问题导致某些功能不能正常运行时记录的信息,软件没能执行一些功能

CRITICAL    打印 CRITICAL级别的日志.当发生严重错误，导致应用程序不能继续运行时记录的信息

 

日志级别等级排序 CRITICAL > ERROR > WARNING > INFO > DEBUG 级别越高打印的日志越少

 

 10.2、logging模块提供2种日志记录方式(logging提供的模块级别函数 和 使用logging日志系统的4大组件)

10.2.1、logging提供的模块级别函数

 

import logging


def test_logging():
    logging.debug("DEBUG Message")
    logging.info("INFO Message")
    logging.warning("WARNING Message")
    logging.error("ERROR Message")
    logging.critical("CRIRICAL Message")


def main():
    test_logging()


if __name__ == '__main__':
    main()

 

 

 

执行结果：

 

WARNING:root:WARNING Message
ERROR:root:ERROR Message
CRITICAL:root:CRIRICAL Message

进程已结束,退出代码0

 

 

 

logging模块 默认WARNING级别,低于WARNING级别不记录  test_logging()函数只输出后面3行

我们也可以手动来设置logging日志显示级别

通过logging.basicConfig()来设置日志记录级别,和日志输出格式(屏幕输出[等同于print] 和 文件输出[日志记录到文件])

logging.basicConfig()内参数说明

filename 用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中

filemode 文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”

format 指定handler使用的日志显示格式。

level 设置rootlogger的日志级别

datefmt 指定日期时间格式。

stream 用指定的stream创建StreamHandler。

可以指定输出到sys.stderr,sys.stdout或者文件(f=open('test.log','w'))，默认为sys.stderr。

若同时列出了filename和stream两个参数，则stream参数会被忽略。

 

 

format参数中可能用到的格式化串：

%(name)s Logger的名字

%(levelno)s 数字形式的日志级别

%(levelname)s 文本形式的日志级别

%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有

%(filename)s 调用日志输出函数的模块的文件名

%(module)s 调用日志输出函数的模块名

%(funcName)s 调用日志输出函数的函数名

%(lineno)d 调用日志输出函数的语句所在的代码行

%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数

%(asctime)s 字符串形式的当前时间。默认格式是 “yyyy-mm-dd hh:mm:ss,sss”。逗号后面的是毫秒

%(thread)d 线程ID。可能没有

%(threadName)s 线程名。可能没有

%(process)d 进程ID。可能没有

%(message)s 用户输出的消息

示例：

import logging


def test_logging():
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                        datefmt="%Y-%m-%d %H:%M:%S",
                        filename='./test.log',
                        filemode='a')
    logging.debug("Debug Message")
    logging.info("Info Message")
    logging.warning("Warning Message")
    logging.error("Error Message")
    logging.critical("Critical Message")


def main():
    test_logging()


if __name__ == '__main__':
    main()

 

 

 

此时会在当前目录下生成一个test.log的文件，文件内容如下：

 

10.2.2、使用logging日志系统的4大组件：日志器Logger、处理器Handler、过滤器Filter、格式器Formatter

① 日志器Logger（最常用的2个 配置和发送日志消息）

 

logging.getLogger(name) 初始化logger对象，getLogger(name)方法建议加上所要日志记录的模块名字name，配置文件和打印日志格式中的%(name)s对应的是这里的模块名字,如果不指定则返回root对象.

logger.setLevel(logging.DEBUG)设置日志级别 有DEBUG/INFO/WARNING/ERROR/CRITICAL

logger.addHandler(handler_name) 为logger对象增加一个处理器

logger.removeHandler(handler_name) 为logger对象删除一个处理器

 

② 处理器Handler  常用的StreamHandler(控制台输出处理器),FileHandler(文件写入处理器)

 

创建处理器对象后可以设置日志级别,设置格式器Formatter,增加和删除过滤器Filter(handler_name为创建的处理器对象名称)

例如：

handler_name.setLevel(logging.DEBUG)  设置日志级别

handler_name.setFormatter(formatter_name) 设置格式器

handler_name.addFilter(filter_name) 添加过滤器

handler_name.removeFilter(filter_name) 删除过滤器

 

③ 过滤器Filter

 

处理器Handlers对象和Loggers对象可以使用Filters对象来完成比级别更复杂的过滤。Filter基类只允许特定Logger层次以下的事件。

例如用A.B初始化的Filter允许Logger‘A.B’,‘A.B.C’,‘A.B.C.D’,‘A.B.D’等记录的事件，

logger‘A.BB’,‘B.A.B’等就不行.如果用空字符串来初始化,所有的事件都接受。

filter = logging.Filter(name='')

 

④ 格式器Formatter

使用Formatter对象设置日志信息最后的规则、结构和内容,默认的时间格式为%Y-%m-%d %H:%M:%S。

formatter = logging.Formatter(fmt=None, datefmt=None)

fmt是消息的格式化字符串，如果不指明fmt将使用'%(message)s'

datefmt是日期字符串,如果不指明 datefmt,将使用ISO8601日期格式

 

 

小结:

logger日志器需要通过handler处理器将日志信息输出到目标位置,不同的handler处理器可以将日志信息输出到不同位置,同一个日志器可以设置多个处理器

每个handler可以设置自己的Filter实现日志过滤,保留自己所需的日志信息

每个handler可以按需设置不同的格式器Formatter

 

代码示例：

import logging


def test():
    logging.debug("DEBUG Message")
    logging.info("INFO Message")
    logging.warning("WARNING Message")
    logging.error("ERROR Message")
    logging.critical("CRIRICAL Message")


def test_logging():
    logger = logging.getLogger()  # 创建日志器对象
    logger.setLevel(logging.DEBUG)  # 设置日志级别等级
    file_handler = logging.FileHandler("./test2.log")  # 创建写入文件的处理器对象
    console_handler = logging.StreamHandler()  # 创建控制台输出处理器对象
    file_handler.setLevel(logging.DEBUG)
    console_handler.setLevel(logging.ERROR)
    formatter = logging.Formatter("%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s")
    file_handler.setFormatter(formatter)  # 为写入文件的处理器对象file_handler设置格式化输出
    console_handler.setFormatter(formatter)  # 为控制台输出处理器对象console_handler设置格式化输出
    logger.addHandler(file_handler)  # logger对象添加file_handler处理器对象
    logger.addHandler(console_handler)  # logger对象添加console_handler处理器对象
    test()


def main():
    test_logging()


if __name__ == '__main__':
    main()

 

 

logging模块使用过程

1、第一次导入logging模块或使用reload函数重新导入logging模块,logging模块中的代码将被执行,这个过程中将产生logging日志系统的默认配置。

2、自定义配置(可选),logging标准模块支持三种配置方式: dictConfig，fileConfig，listen。

dictConfig是通过一个字典进行配置Logger,Handler,Filter,Formatter；

fileConfig是通过一个文件进行配置

listen则监听一个网络端口，通过接收网络数据来进行配置

除了以上集体化配置外，也可以直接调用Logger,Handler等对象中的方法在代码中来显式配置。

3、使用logging模块的全局作用域中的getLogger函数来得到一个Logger对象实例(其参数即是一个字符串，表示Logger对象实例的名字)。

4、使用Logger对象中的 debug，info，error，warn，critical 等方法记录日志信息。

 

 

11、configparser模块 

configparser模块是用来读取配置文件，配置文件的格式跟windows下的ini配置文件相似,可以包含一个或多个节(section),每个节可以有多个参数（键=值）

使用的配置文件的好处就是不用在程序员写死,可以使程序更灵活

configparser模块的使用：

import configparser

# 1. 使用configparser模块生成一个配置文件
config = configparser.ConfigParser()  # 创建config对象
config["login_info"] = {"user_name": "zhangsan", "user_pwd": "123456", "email": "zhangsan@qq.com"}
config["login_state"] = {"state": 1}
config["login_date"] = {}
config["login_history"] = {"address": "www.baidu.com", "type": "video"}
with open("./test.ini", "w", encoding="utf8") as f:
    config.write(f)

# 2.读取配置文件
config_2 = configparser.ConfigParser()  # 创建对象
config_2.read("./test.ini")  # 读取文件
# 2.1 获取所有 sections
print(config_2.sections())
# 2.2 获取指定section的keys
options = config_2.options(config_2.sections()[0])
print(options)
# 2.3 获取指定key的value
value = config_2.get(config_2.sections()[0], options[0])
print(value)
# 2.4 获取指定section的keys&values
item = config_2.items("login_state")
print(item)
# 2.5 检查 section 是否存在
print("login_info" in config)
# 2.6 检查指定 section 中 key 是否存在
print("user_name" in config["login_info"])
# 2.7 检查指定 section 指定 key 的 value
print("zhangsan" in config["login_info"]["user_name"])

# 3 配置文件的增删改
config_3 = configparser.ConfigParser()  # 创建对象
config_3.read("./test.ini")  # 读取文件
# 3.1 新增sections
config_3.add_section("login_log")
# 3.2 删除sections
config_3.remove_section("login_date")
# 3.3 删除sections中的key和value
config_3.remove_option("login_history", "type")
# 3.4 修改sections
config_3.set("login_state", "state", "1")
# 3.5 修改(添加)sections中的key和value
config_3.set("login_log", "datetime", "2022-4-29 19:18:20")
with open("./test.ini", "w", encoding="utf8") as file:
    config_3.write(file)

 

 

12、re模块

正则表达式(规则表达式),用于验证和查找符合规则的文本，广泛用于各种搜索引擎、账户密码的验证等

正则表达式常用的元字符

1. 行定位符(边界匹配符)

^ 匹配字符串的开头 例: ^tmp 表示要匹配的字符串是以tmp开头

$\mathrm{匹}\mathrm{配}\mathrm{字}\mathrm{符}\mathrm{串}\mathrm{的}\mathrm{末}\mathrm{尾}\mathrm{例}:tmp$ 表示要匹配的字符串是以tmp结束

 

2. 常用的元字符

. 又称作 通配符

. 匹配除换行符以外的任意字符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。

\w 匹配字母、数字、下划线或汉字

\W 匹配除匹配字母、数字、下划线、汉字以外的所有字符 与\w相反 等价于 ^\w
\s 匹配单个的空白符(包括tab制表符和换行符) 等价于 [\t\n\r\f]

\S 匹配除单个的空白符(包括tab制表符和换行符)以外的所有字符 与\s相反 等价于[^\f\n\r\t\v]

\d 匹配任意数字 等价于 [0-9]

\D 匹配任意非数字 等价于 [^0-9] 或 ^\d

\b 匹配一个单词边界，也就是指单词和空格间的位置。例:'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

3.限定符

? 匹配前面的字符0次或1次

+ 匹配前面的字符1次或多次

* 匹配前面的字符0次或多次

{n} 匹配前面的字符n次

{n,} 匹配前面的字符最少n次

{n,m} 匹配前面的字符最少n次最多m次

4. 转义字符 \ 将特殊字符(. ? \等)变为普通字符

如[1-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}表示匹配ip地址

5. 选择字符 | 包含选择的逻辑

如(^\d{15}$)|{(}^{\text{d}}18$)|(^\d{17})(\d|x|X)$ 表示的是匹配15位数字,或18位数字,或17位数字和最后一位,最后一位可以是数字或x或X

6. 分组 使用小括号()

可以改变限定符的作用范围,也可以用来表示子表达式

7. [] 又称作 字符集

注意 [] 可以取消元字符的特殊功能,^ - \ 除外

 

re模块常用的函数

re.match(pattern,string[,flag]) 从字符串的开始处进行匹配,如果在开始位置匹配成功,则返回Match对象,否则返回None

参数说明:

pattern 表示模式字符串,由要匹配的正则表达式转换而来

string 表示要匹配的字符串

falg 可选参数,标志位,用于控制匹配方式,如是否区分大小写等

常用的标志有:

A 或 ASCII 对于\w、\W、\b、\B、\d、\D、\s、\S只进行ASCII匹配

I 或 IGNORECASE 执行不区分字母大小写的匹配

M 或 MULTILINE 将^和$用于包括整个字符串的开始和结尾的每一行(默认适用于整个字符串的开始和结尾)

S 或 DOTALL 使用(.)字符匹配所有字符,包括换行符

X 或 VERBOSE 忽略模式字符串中未转义的空格和注释

re.search(pattern, string[, flags]) 在整个字符串中搜索第一个匹配的值,如果匹配成功,则返回Match对象,否则返回None

re.findall(pattern, string[, flags]) 在整个字符串中搜索所有符合正则表达式的字符串,并以列表形式返回,匹配不成功则返回空列表

re.sub(pattern, repl, string, count, flags) 替换字符串

参数说明

pattern 表示模式字符串,由要匹配的正则表达式转换而来

repl: 表示替换的字符串

string 表示要被查找替换的原始字符串

count 可选参数,表示模式匹配后替换的最大次数,默认值为0,表示替换所有的匹配

falg 可选参数,标志位,用于控制匹配方式,如是否区分大小写等

re.subn(pattern, repl, string, count, flags) 替换字符串,与sub类似,返回的是一个元组

re.finditer(pattern, string[, flags]) 返回一个存放匹配结果的迭代器

re.compile(pattern[, flags]) 将正则表达式编译成为一个 正则表达式对象

re.split(pattern, string, maxsplit, flags) 根据正则表达式来分割字符串,并返回列表

参数说明:

pattern 表示模式字符串,由要匹配的正则表达式转换而来

string 表示要被查找替换的原始字符串

maxsplit 可选参数,表示模式匹配后替换的最大次数

falg 可选参数,标志位,用于控制匹配方式,如是否区分大小写等

re.fullmatch(pattern,string[,flag]) 当且仅当整个字符串与模式匹配时,匹配成功,则返回匹配对象,否则返回None

与re.match(pattern,string[,flag])的区别:

re.match()在开始匹配；re.fullmatch()在开始匹配,也在末尾匹配 

re.escape(pattern) 转义pattern中的特殊字符。

re.purge() 清理正则表达式缓存

re.template() 编译模板模式，返回一个re.Pattern对象

 

13、josn模块

 

json概念

JSON(JavaScript Object Notation, JS对象标记) 是一种轻量级的数据交换格式

Json的数据格式其实就是python里面的字典格式,里面可以包含方括号括起来的数组,也就是python里面的列表

json模块的4个方法：

dumps()：将dict数据转化成json数据（python里是str类型）

dump()：将dict数据转化成json数据后写入json文件

loads()：将json数据转化成dict数据（python里是dict类型）

load()：读取json文件数据，转成dict数据 

示例： 

import json

# json.dumps() 将python对象编码成json字符串
dic = {"name": "xiaoming", "age": 18}
data = json.dumps(dic)
with open("./json.txt", "w") as f:
    f.write(data)

# json.dump() 将python对象转化成json数据后写入json文件
with open("./json_2.txt", "w") as f:
    json.dump(data, f)

# json.loads() 将已编码的json字符串解码为python对象
with open("./json.txt", "r") as f:
    data = json.loads(f.read())
    print(data)

# json.load() 读取json文件数据，转成python对象
with open("./json_2.txt", "r") as f:
    print(json.load(f))

 

14、pickle模块

 

与json模块类似,序列化和反序列化操作,json不能直接序列化函数,对象等类型
使用pickle模块你可以把python对象直接保存到文件,而不需要把他们转化为字符串,也不用底层的文件访问操作把它们写入到一个二进制文件里。
pickle模块会创建一个python语言专用的二进制格式,不用考虑任何文件细节,它会帮你干净利落地完成读写独享操作，唯一需要的只是一个合法的文件句柄。

示例：

import pickle


# 1. pickle.dumps() 序列化操作
data = pickle.dumps(test)
with open("test_pickle_1.txt", "wb") as f:
    f.write(data)

# 2. pickle.dump()
with open("test_pickle_2.txt", "wb") as f:
    pickle.dump(test, f)

# 3. pickle.loads() 反序列化操作
with open("test_pickle_1.txt", "rb") as f:
    data = pickle.loads(f.read())
    data()

# 4. pick.load()
with open("test_pickle_2.txt", "rb") as f:
    data2 = pickle.load(f)
    data2()

 

15、shelve模块

 

在python3中我们使用json或者pickle持久化数据,能dump多次,但只能load一次,因为先前的数据已经被后面dump的数据覆盖掉了

如果我们想要实现dump和load多次,可以使用shelve模块

shelve模块可以持久化所有pickle所支持的数据类型

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写

key必须为字符串，而值可以是python所支持的数据类型

 

示例：

 

import shelve

# 1. 数据写入
list1 = ["xiaoming", 18]
info = {"language": "python", "development_tools": "pycharm"}
with shelve.open("test_shelve") as f:
    f['list1'] = list1
    f['info'] = info

# 执行后会生成3个文件
# test_shelve.bak
# test_shelve.dat
# test_shelve.dir

# 2.数据读取
with shelve.open("test_shelve") as f:
    lis = f.get("list1")
    inf = f.get("info")
    print(lis)
    print(inf)

 需要注意的是：

使用shelve模块进行数据的写入后，会生成3个文件(.bat、.dat、.dir)

 

16、xml模块

xml协议在各个语言里的都是支持的,在python中可以用ElementTree操作xml

ElementTree是python的XML处理模块,它提供了一个轻量级的对象模型

ElementTree表示整个XML节点树,Element表示节点数中的一个单独的节点

 

示例：对test.xml内容读取，内容修改

xml文件内容

 

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

  

python代码： 

import xml.etree.ElementTree as ET


tree = ET.parse("test.xml")  # 打开文件,读出xml文件对象
# print(tree)
root = tree.getroot()  # 读出顶级节点对象
# print(root)

# root.tag 节点
# root.attrib 节点属性名
# root.text 节点内文本内容

# 1. 遍历xml
for item in root:
    print(item.tag, item.attrib)
    for i in item:
        print(i.tag, i.attrib, i.text)

# 2. 查看指定节点,在root的子节点只找一个
country = root.find("country")
# print(country.tag)
# print(country.attrib)
# print(country.text) # 文本内容为空

# 3. 递归查找country下的子节点,并获取tag,attrib,text
rank = country.find("rank")  # 等价于 root.find("country").find("rank")
print(rank.tag)
print(rank.attrib)
print(rank.text)

# 4. 查找root的所有子节点对象 root.findall()
all_country = root.findall("country")
for i in all_country:  # 遍历root的所有子节点对象
    print(i.tag, i.attrib)  # i.text为空

# 5. xml的修改
# 将country为Liechtenstein中的rank标签的属性的值改为no,文本内容+3
for country in root.findall("country"):
    if country.get("name") == "Liechtenstein":
        for note in country:
            if note.tag == "rank":
                note.set("updated", "no")  # 等价于 note.attrib = "{'updated':'no'}"

tree.write("test_2.xml")

# 6. xml的删除
# 在所有的country标签节点对象下的rank如果它的文本内容大于50, 那么就删除这个country

for country in root.findall("country"):
    rank2 = int(country.find("rank").text)
    if rank2 > 50:
        root.remove(country)
tree.write("test_3.xml")

# 7.xml的创建
new_xml = ET.Element("info")  # 创建标签节点,返回new_xml节点对象
name_note = ET.SubElement(new_xml, "name", attrib={"updated": "yes"})  # 在new_xml节点对象下创建标签名为"name"的子节点对象,并指定属性
name_note.text = "张三"
age_note = ET.SubElement(new_xml, "age", attrib={"updated": "yes"})
age_note.text = '18'

et = ET.ElementTree(new_xml)  # 生成文档对象
et.write("test_4.xml", encoding="utf-8", xml_declaration=True)  # 创建文件,将文档对象et写入xml

  

17、calendar模块

calendar模块是python提供的日历管理模块，可以方便地显示年历和月历

calendar的常用方法

calendar.calendar(theyear, w, l, c, m) 返回指定年份的年历

参数说明：

theyear 指定的年份

w 每个单元格宽度

l 每列换行数

c 月份之间的间隔宽度

m 12个月显示的列数

calendar.month(theyear, themonth, w, l)返回一个指定年和月的月历

calendar.weekday(year, month, day) 返回年、月(1-12)、日(1-31)往返工作日(0-6 ~周一-周日)

calendar.firstweekday()返回每周起始的星期数，默认返回0（星期一）

calendar.setfirstweekday(firstweekday)设置每周起始日期码，设置范围0~6（星期一~星期日）

calendar.format(cols, colwidth, spacing) 为年历打印多列格式

calendar.formatstring(cols, colwidth, spacing) 返回一个以n个字符串为格式，以n列为中心的字符串。

calendar.isleap(year)判断指定年份是否为闰年，是则返回True否则返回False

calendar.leapdays(y1, y2)返回两个年份之间的闰年总和

calendar.monthcalendar(year, month)返回有一个整数单层嵌套列表，每个字列表表示一个星期的数据，该月之内的日期从1开始编号，改月之外的日期使用0表示

calendar.monthrange(year, month)返回两个整数组成的元组，第一个数表示该月的第一天是星期几，第二个数表示改约的总天数

calendar.prcal(theyear, w, l, c, m) 输出年历，等价于calendar.calendar(theyear, w, l, c, m) 返回的信息

calendar.prmonth(theyear, themonth, w, l) 输出月历，等价于calendar.month(theyear, themonth, w, l)返回的信息

calendar.timegm(tuple) 接收一个时间元组返回该时刻的时间戳

calendar.weekheader(width)返回一周的标题