Python测开28期 - 旎奥 - 学习笔记 -python常用模块

SLAmay · 2023 年11 月 6 日 12:14

一、模块与包

（一）模块

1、项目目录结构

程序结构

组成：
- package包
- module模块
- function方法

2、模块定义

包含python定义和语句的文件
.py文件
作为脚本运行

3、文件引用

模块导入：模块是在代码量变得相当⼤了之后，为了将需要重复使⽤的有组织的代码放在
⼀起，这部分代码可以被其他程序引⽤，从⽽使⽤该模块⾥的函数等功能，引
⽤的过程叫做导⼊（import）

在python中，⼀个⽂件（以“.py”为后缀名的⽂件）就叫做⼀个模块
导⼊模块的写法：
⽅法⼀：import modul1[,module2…[,moduleN]]
⽅法⼆：from module import <name[,name2,….[,nameN]]>
import模块名
from <模块名> import <方法名｜变量｜类>
from <模块名> import *
- 注意：
  - 同一个模块写多次，只被导入一次
  - import应该放在代码的顶端
  - 使⽤关键词“import + 模块名称” 导⼊某⼀个模块

模块分类

系统内置模块
sys、time、json模块等等；
第三⽅的开源模块
通过pip install进⾏安装，有开源的代码
⾃定义模块
⾃⼰写的模块，对某段逻辑或某些函数进⾏封装后供其他函数调⽤。

如何使用模块

Python安装好之后⾃带的⼀些⾮常有⽤的模块（sys，os，time，json模块
等）

 import sys
 print("调⽤了sys模块")
 for i in sys.argv:
 print(i)

1、内建模块

Python标准库中包含了大量的内建模块，这些模块提供了各种功能，如数学计算、字符串处理、日期时间操作、文件操作等。通过导入相应的内建模块，可以使用这些功能，避免重复编写代码。

import random

# 生成1到100之间的随机整数
random_number = random.randint(1, 100)  
print(random_number)

import datetime

# 获取当前日期和时间
current_datetime = datetime.datetime.now()

# 格式化日期输出
formatted_date = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)

2、第三⽅开源模块

是通过包管理⼯具pip完成的。必须先知道该库的名称，可以在官⽹或者pypi
上搜索，⽐如MySQL驱动程序，Web框架Flask，科学计算Numpy等
NumPy(Numerical Python) 是 Python 语⾔的⼀个扩展程序库，⽀持⼤量的维
度数组与矩阵运算，此外也针对数组运算提供⼤量的数学函数库
pip install numpy

第三方模块和库通过包管理工具(pip)安装。如：PyMySQL, PyTest, Flask, SQLAchemy等等。

dir() 函数

dir() 是Python内置函数，用于获取指定对象的所有属性和方法的列表。格式： dir(obj)

import math

print(dir(math))

3、⾃定义模块

⾃定义模块是⾃⼰写的模块，对某段逻辑或某些函数进⾏封装后供其他函数调⽤。
模块由变量，函数，或类组成
举例：
创建⼀个模块 baidu.py
创建⼀个调⽤模块 index.py
注意：⾃定义模块的名字⼀定不能和系统内置的模块重名，否则将不能再导⼊系统的内置模块。
例如，⾃定义了⼀个sys.py模块后，那系统的sys模块就不能使⽤

由开发者编写，用于封装代码、组织功能，以便在其他Python程序中复用。自定义模块是一个Python文件，可以包含函数、类、变量等。

# 创建一个my_module.py文件

def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

在其他文件中使用：

# 导入
import my_module

print(my_module.greet("Alice"))  
print(my_module.add(5, 3))

4、导⼊模块

import 模块名引⼊⼀个完整的模块
from <模块名> import <⽅法 | 变量 | 类> 引⼊模块中的⼀个或多个指定部分
from <模块名> import * 导⼊模块⾥⾯的所有的函数，变量
区别：
import 导⼊模块，每次使⽤模块中的函数，都要是定是哪个模块
from…import * 导⼊模块，每次使⽤模块中的函数，直接使⽤函数就可以了(因为已经知道该函数是那
个模块中的了)

import 导入Python中使用 import 关键字来导入模块，导入模块后，在当前文件中做为一个对象使用，可以通过 . 来引用模块中定义的函数、变量或类等。

# 导入内建模块 math
import math
#可以使用其中的 sqrt()来计算平方根
result = math.sqrt(25)
print(result)

如果被导入的模块名比较长，在使用时会不太方便，也可以使用 as 为模块指定一个别名，一旦指定了别名，原模块名就不能使用了。

# 导入内建模块 math
import math as m
#可以使用其中的 sqrt()来计算平方根
result = m.sqrt(25)
print(result)

还可以使用from module_name import object_name语法，从模块中导入特定的对象，这样可以直接使用对象名，无需使用模块名前缀。

from math import sqrt

result = sqrt(25)
print(result)

5、常用方法

dir() 找出当前模块定义的对象
dir(sys). 找出参数模块定义的对象

作用域

搜索路径(print(sys.path())
当你导⼊⼀个模块，Python 解析器对模块位置的搜索顺序是：
1、当前⽬录
2、如果不在当前⽬录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个⽬录
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径⼀般为/usr/local/lib/python/
模块搜索路径存储在 system 模块的 sys.path 变量中。变量⾥包含当前⽬录，PYTHONPATH和
由安装过程决定的默认⽬录。

使⽤模块的好处

提⾼代码的可维护性
⼀个模块编写完毕之后，其他模块直接调⽤，不⽤再从零开始写代码了，节约
了⼯作时间；
避免函数名称和变量名称重复，在不同的模块中可以存在相同名字的函数名和
变量名（不要和系统内置的模块名称重复）

（二）包

package 导入

从包中导入模块时，导入方式非常灵活。

当前有包组织结构如下：

Project
    |
    |--- mp 
    |    |
    |    |--- __init__.py
    |    |--- mm.py 
    |    |    |
    |    |    |--- show()
    |    |--- nn.py
    |    |    |
    |    |    |--- info()
    |--- main.py

使用 import 直接导入包中指定模块

# 
import mp.mm
mp.mm.show()

import mp.nn as nn
nn.info()

使用 from-import 导入包内指定模块或包内指定模块内的成员

# 导入包内指定模块
from mp import mm
mm.show()

# 导入包内指定模块中的成员
from mp.mm import *
show()

`init.py`

__init__.py文件是包的初始化文件，该文件是是区别包与文件夹的关键。

当使用 from-import方式导入时，可以通过在文件中添加魔法属性 __all__ 属性来设置包中哪些模块可以被导入。

# 在 __init__.py 中添加下面代码 
__all__ = ["mm"]

# main.py中的代码
from mp import *
# 此时只能使用 __all__ 中指定的mm模块，nn 模块不能使用
mm.show()

二、内置模块

（一）math 模块

Python 的数学模块 math 是一个内置库，提供了对大量数学函数和常量的操作。

该模块是在 Python 中进行数学计算的重要工具。

函数分类如下：

常用的数学常量
通用的数学操作函数
对数函数相关操作
幂函数相关操作
三角函数相关操作
角度转换相关操作
双曲函数相关操作
其他数学操作

math 模块常量

常量	描述
math.e	返回欧拉数 (2.7182…)
math.inf	返回正无穷大浮点数
math.nan	返回一个浮点值 NaN (not a number)
math.pi	π 一般指圆周率。圆周率 PI (3.1415…)
math.tau	数学常数 τ = 6.283185…，精确到可用精度。Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。

math 模块方法

方法	描述
math.acos(x)	返回 x 的反余弦，结果范围在 0 到 pi 之间。
math.acosh(x)	返回 x 的反双曲余弦值。
math.asin(x)	返回 x 的反正弦值，结果范围在 -pi/2 到 pi/2 之间。
math.asinh(x)	返回 x 的反双曲正弦值。
math.atan(x)	返回 x 的反正切值，结果范围在 -pi/2 到 pi/2 之间。
math.atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值，结果是在 -pi 和 pi 之间。
math.atanh(x)	返回 x 的反双曲正切值。
math.ceil(x)	将 x 向上舍入到最接近的整数
math.comb(n, k)	返回不重复且无顺序地从 n 项中选择 k 项的方式总数。
math.copysign(x, y)	返回一个基于 x 的绝对值和 y 的符号的浮点数。
math.cos()	返回 x 弧度的余弦值。
math.cosh(x)	返回 x 的双曲余弦值。
math.degrees(x)	将角度 x 从弧度转换为度数。
math.dist(p, q)	返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。两个点必须具有相同的维度。
math.erf(x)	返回一个数的误差函数
math.erfc(x)	返回 x 处的互补误差函数
math.exp(x)	返回 e 的 x 次幂，Ex，其中 e = 2.718281… 是自然对数的基数。
math.expm1()	返回 Ex - 1， e 的 x 次幂，Ex，其中 e = 2.718281… 是自然对数的基数。这通常比 math.e ** x 或 pow(math.e, x) 更精确。
math.fabs(x)	返回 x 的绝对值。
math.factorial(x)	返回 x 的阶乘。如果 x 不是整数或为负数时则将引发 ValueError。
math.floor()	将数字向下舍入到最接近的整数
math.fmod(x, y)	返回 x/y 的余数
math.frexp(x)	以 (m, e) 对的形式返回 x 的尾数和指数。 m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。
math.fsum(iterable)	返回可迭代对象 (元组, 数组, 列表, 等)中的元素总和，是浮点值。
math.gamma(x)	返回 x 处的伽马函数值。
math.gcd()	返回给定的整数参数的最大公约数。
math.hypot()	返回欧几里得范数，sqrt(sum(x**2 for x in coordinates))。这是从原点到坐标给定点的向量长度。
math.isclose(a,b)	检查两个值是否彼此接近，若 a 和 b 的值比较接近则返回 True，否则返回 False。。
math.isfinite(x)	判断 x 是否有限，如果 x 既不是无穷大也不是 NaN，则返回 True ，否则返回 False 。
math.isinf(x)	判断 x 是否是无穷大，如果 x 是正或负无穷大，则返回 True ，否则返回 False 。
math.isnan()	判断数字是否为 NaN，如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。
math.isqrt()	将平方根数向下舍入到最接近的整数
math.ldexp(x, i)	返回 x * (2**i) 。这基本上是函数 math.frexp() 的反函数。
math.lgamma()	返回伽玛函数在 x 绝对值的自然对数。
math.log(x[, base])	使用一个参数，返回 x 的自然对数（底为 e ）。
math.log10(x)	返回 x 底为 10 的对数。
math.log1p(x)	返回 1+x 的自然对数（以 e 为底）。
math.log2(x)	返回 x 以 2 为底的对数
math.perm(n, k=None)	返回不重复且有顺序地从 n 项中选择 k 项的方式总数。
math.pow(x, y)	将返回 x 的 y 次幂。
math.prod(iterable)	计算可迭代对象中所有元素的积。
math.radians(x)	将角度 x 从度数转换为弧度。
math.remainder(x, y)	返回 IEEE 754 风格的 x 除于 y 的余数。
math.sin(x)	返回 x 弧度的正弦值。
math.sinh(x)	返回 x 的双曲正弦值。
math.sqrt(x)	返回 x 的平方根。
math.tan(x)	返回 x 弧度的正切值。
math.tanh(x)	返回 x 的双曲正切值。
math.trunc(x)	返回 x 截断整数的部分，即返回整数部分，删除小数部分

常用函数和常量

import math

print(math.pi)  # π
print(math.tau) # 2π
print(math.pow(2, 10))  # 乘方函数
print(math.sqrt(4)) # 开平方函数
print(math.ceil(3.14))  # 将数字向上舍入到最接近的整数，比当前参数大的最小整数
print(math.floor(3.14)) # 将数字向下舍入到最接近的整数，比当前参数小的最大整数

（二）random 模块

random 是Python内置的用于生成随机数的模块。

它提供了多种随机数生成函数，用于各种不同的随机数需求。

random 常用方法

random.random()：生成一个[0,1)范围内的随机浮点数。

import random

print(random.random())

random.randint(a,b)：生成一个[a,b]范围内的随机整数。

import random

print(random.randint(1,10))

random.uniform(a,b)：生成一个[a,b]范围内的随机浮点数。

import random

print(random.uniform(2,5))

random.choice(seq)：从序列 seq 中随机选择一个元素。seq 是自定义的序列。

import random

fruits = ["苹果", "香蕉", "樱桃"]
random_fruit = random.choice(fruits)
print(random_fruit)

random.shuffle(lst)：随机打乱列表 lst 的元素顺序。

import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)

（三）sys模块

sys 是 Python 的内置标准库模块，提供了访问与 Python 解释器相关的变量和函数的功能。它的主要用途是与系统交互、解释器配置、命令行参数处理、标准输入输出、异常处理等。

sys 常用属性

sys.argv 获取命令行参数列表，包括脚本名称和传递给脚本的其他参数。

import sys
# 第一个元素是脚本名称，后续元素是命令行参数
script_name = sys.argv[0]
arguments = sys.argv[1:]

print("脚本名称：", script_name)
print("命令行参数：", arguments)

sys.version 获取当前 Python 解释器的版本信息。

import sys
print("Python 解释器版本：", sys.version)

sys.version_info 获取当前Python解释器的版本信息，以元组形式表示详细的版本号信息

import sys
print("Python 解释器版本信息：", sys.version_info)

sys.platform 获取当前运行的操作系统平台名称。

import sys
print("当前操作系统平台：", sys.platform)

sys.modules 返回已导入的模块信息,返回一个字典

import sys
for module_name, module in sys.modules.items():
    print(f"模块名：{module_name}, 模块对象：{module}")

sys.path 获取模块搜索路径列表，用于指定Python解释器搜索模块的路径。

print(sys.path)

sys 常用方法

sys.getdefaultencoding()：获取编码方式

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

sys.exit()：运行时退出

print("Python 解释器版本信息：", sys.version_info)
# 运行之后退出，不会运行后面的代码
sys.exit()
print(sys.getdefaultencoding())

（四）os模块

Python的内置库os（Operating System Interface）提供了与操作系统交互的函数，允许您与操作系统进行各种操作，如文件和目录操作、环境变量访问、进程管理等。使用os库，您可以编写跨平台的代码，因为它提供了对操作系统底层功能的抽象，而不用担心特定操作系统的细节。

路径操作

os.getcwd()：获取当前目录的路径

import os
directory = os.getcwd()
print("当前目录:", directory)

os.chdir()：用于改变当前的工作目录。工作目录是指当前正在执行的脚本所在的目录，通过使用``os.chdir()`方法，可以在脚本执行过程中切换到不同的目录。

import os
# 当前工作目录
print("当前工作目录：", os.getcwd())

# 切换到指定目录
os.chdir("/path/to/directory")

# 切换后的工作目录
print("切换后的工作目录：", os.getcwd())

path 方法	说明
os.path.abspath(path)	返回绝对路径
os.path.basename(path)	返回文件名
os.path.dirname(path)	返回文件路径
os.path.split(path)	分割路径
os.path.join(path)	拼接路径
os.path.exists(path)	判断路径是否存在
os.path.isdir(path)	判断是否是目录
os.path.isfile(path)	判断是否是文件
os.path.getsize(path)	获取文件大小

os.path.abspath(path)：获取绝对路径。path 是要获取绝对路径的路径。

import os
# 获取绝对路径
absolute_path = os.path.abspath('relative/path/to/file.txt')
print("Absolute Path:", absolute_path)

os.path.basename(path)：返回指定路径的基本名称（不包含父目录路径）

import os

# 获取基本名称
base_name = os.path.basename('/path/to/file.txt')
print("Base Name:", base_name)

os.path.dirname(path)：返回指定路径的父目录路径。

import os

# 获取父目录路径
parent_directory = os.path.dirname('/path/to/file.txt')
print("父目录为:", parent_directory)

os.path.split(path)：用于将一个路径拆分为目录部分和文件名部分。

import os

path = '/home/user/file.txt'
result = os.path.split(path)
print(result)

os.path.join(path)：用于连接多个路径部分。它将多个路径片段组合在一起，形成一个新的路径字符串。

import os

path1 = '\home\user'
path2 = 'file.txt'
result = os.path.join(path1, path2)
print(result)

os.path.exists(path) 判断路径是否存在（可以是文件或目录）

import os

# 判断路径是否存在
path_to_check = '/path/to/file.txt'
if os.path.exists(path_to_check):
    print("路径存在")
else:
    print("路径不存在")

os.path.isdir(path) 判断是否是目录

import os

# 判断路径是否是目录
directory_path = '/path/to/directory'
if os.path.isdir(directory_path):
    print("它是一个目录")
else:
    print("它不是一个目录或路径不存在")

os.path.isfile(path) 判断是否是文件

import os

# 判断路径是否是文件
file_path = '/path/to/file.txt'
if os.path.isfile(file_path):
    print("它是一个文件")
else:
    print("它不是文件或路径不存在.")

os.path.getsize(path) 获取文件大小

import os
print(os.path.getsize("main.py"))

目录和文件操作

os.listdir()：列出当前目录内容

import os

# 获取目录内容
directory_path = '/path/to/directory'
content = os.listdir(directory_path)
print("Directory Content:", content)

import os

# 创建新目录
new_directory = '/path/to/new_directory'
os.mkdir(new_directory)

os.makedirs()：递归创建多级目录

# 创建多级目录
nested_directory = '/path/to/nested/directory'
os.makedirs(nested_directory)

import os

# 删除目录
directory_to_delete = '/path/to/directory_to_delete'
os.rmdir(directory_to_delete)

import os

# 重命名目录
old_directory_name = '/path/to/old_directory'
new_directory_name = '/path/to/new_directory'
os.rename(old_directory_name, new_directory_name)

os.remove()：删除文件(只能删除文件，不能删除目录)

import os

# 删除指定的文件
file_to_delete = '/path/to/file.txt'
os.remove(file_to_delete)

其它操作

os.name：获取系统名称，在Windows上，os.name 值为 nt。在Linux、macOS，os.name 为 posix。

import os

# 获取当前平台名称
platform_name = os.name
print("Platform Name:", platform_name)

os.chmod(path, mode)：更改文件权限模式。 path 是要更改权限的文件路径，mode 是权限模式，通常用八进制表示，如0o755

import os

# 更改文件权限模式为-rwxr-xr-x
file_path = '/path/to/file.txt'
os.chmod(file_path, 0o755)

os.sep：用于表示操作系统特定的路径分隔符。在Windows操作系统上，路径分隔符是反斜杠 \ ；而在POSIX系统（如Linux、macOS等）上，路径分隔符是正斜杠 /。

import os

# 获取路径分隔符
path_separator = os.sep
print("Path Separator:", path_separator)

（五）datetime 模块

datetime 是Python标准库中用于处理日期和时间的模块。它提供了多种类和函数，用于处理日期、时间、时间间隔等操作，使得日期和时间的处理更加方便和灵活。

应用场景

作为日志信息的内容输出
计算某个功能的执行时间
用日期命名一个日志文件的名称
生成随机数（时间是不会重复的）

获取当前日期时间

datetime.now()：获取当前日期和时间

from datetime import datetime

current_datetime = datetime.now()
print("当前时间:", current_datetime)

格式化日期和时间

使用strftime()方法可以将datetime对象格式化为自动以的字符串格式。

from datetime import datetime

current_datetime = datetime.now()
date = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(f"格式化日期时间：{date}")

解析日期和时间

使用strptime()函数可以将字符串解析为datetime对象

from datetime import datetime

date = "2023-08-08 15:30:00"
datetime = datetime.strptime(date, "%Y-%m-%d %H:%M:%S")
print("Datetime:", datetime)

计算日期间隔

使用timedelta类可以进行日期间隔的计算

from datetime import timedelta, datetime

date1 = datetime(2023, 1, 1)
date2 = datetime(2023, 7, 7)
date_diff = date2 - date1
print("Date Difference:", date_diff)

current_datetime = datetime.now()
# 使用 timedelta 计算未来的日期
future_date = current_datetime + timedelta(days=30)
print("Future Date:", future_date)

比较日期

可以直接比较datetime对象来判断日期的先后关系。

from datetime import  datetime

date1 = datetime(2023, 1, 1)
date2 = datetime(2023, 8, 8)
if date1 < date2:
    print("date1 is earlier than date2")
elif date1 > date2:
    print("date1 is later than date2")
else:
    print("date1 and date2 are the same")

获取日期和时间的部分信息

可以使用 year 、month 、day、hour 、minute 、 second等属性获取日期和时间的部分信息。

from datetime import datetime

current_datetime = datetime.now()
year = current_datetime.year
month = current_datetime.month
day = current_datetime.day
hour = current_datetime.hour
minute = current_datetime.minute
second = current_datetime.second

print(f"Year: {year}, Month: {month}, Day: {day}")
print(f"Hour: {hour}, Minute: {minute}, Second: {second}")

（六）正则表达式

正则表达式是一种强大的文本处理工具，可以用于在字符串中进行模式匹配、搜索、替换等操作。

Python 的内置 re 模块，用于进行正则表达式操作，提供了一系列函数和方法，用于执行各种正则表达式操作。

常用正则表达式语法及含义

语法	含义
普通字符	大多数只会匹配字符本身
`'.'`	匹配除换行符 `\n` 外的任意字符
`'[]'`	匹配 `[]` 中列举的字符
`'*'`	匹配前一个字符的零个或多个实例
`'+'`	匹配前一个字符的一个或多个实例
`'?'`	匹配前一个字符的零个或一个实例
`'{m}'`	匹配前一个字符的 `m` 个实例
`'{m, n}'`	匹配前一个字符的 `m` 到 `n` 个实例
`'^'`	匹配字符串的开头
`'`	匹配字符串的结尾
`'\d'`	匹配任意数字字符，相当于 [0-9]
`'\D'`	匹配任意非数字字符，相当于除 [0-9]以外的字符
`'\w'`	匹配任意字母、数字或下划线字符等非特殊字符，相当于 [a-zA-Z0-9_]
`'\W'`	匹配任意除字母、数字或下划线字符以外的特殊字符，相当于除 [a-zA-Z0-9_]以外的字符
`'\s'`	匹配任意空白字符，如空格、制表符、换行等
`'\S'`	匹配任意非空白字符

常用正则表达式处理函数

re.match

re.match ：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回 none。

格式：re.match(pattern,string,flags =0)
函数参数说明

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于控制正则表达式的匹配方式

import re

# 使用 re.match 进行匹配
pattern = r"hello"
string = "hello world"
match = re.match(pattern, string)
if match:
    print("匹配成功")
else:
    print("匹配失败")

group(): 获取匹配结果

import re

# 使用 re.match 进行匹配
pattern = r"\d+"
string = "12345hello world"
match = re.match(pattern, string)
print(match.group())

span(): 获取匹配结果在原字符串中的范围

import re

# 使用 re.match 进行匹配
pattern = r"hello"
string = "hello world"
match = re.match(pattern, string)
print(match.span())

start(): 获取匹配结果在原字符串中起始下标位置

import re

# 使用 re.match 进行匹配
pattern = r"hello"
string = "hello world"
match = re.match(pattern, string)
print(match.start())

end(): 获取匹配结果在原字符串中的结束下标位置

import re

# 使用 re.match 进行匹配
pattern = r"hello"
string = "hello world"
match = re.match(pattern, string)
print(match.end())

re.search

re.search：在字符串中搜索匹配指定的模式，如果找到则返回匹配对象，否则返回 None。

格式：re.search(pattern, string, flags=0)
函数参数说明

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于控制正则表达式的匹配方式

import re

# 使用 re.search 进行搜索
pattern = r"world"
string = "hello world"
search = re.search(pattern, string)
if search:
    print("找到匹配")
else:
    print("未找到匹配")

re.match 与 re.search 的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None.
re.search匹配整个字符串，直到找到一个匹配。

re.findall

re.findall:在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

格式：findall(string[, pos[, endpos]])
函数参数说明

参数	描述
string	待匹配的字符串
pos	可选参数，指定字符串的起始位置，默认为 0
endpos	可选参数，指定字符串的结束位置，默认为字符串的长度

import re

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('hogwarts 123 python 456')
result2 = pattern.findall('hello123python563world', 0, 10)

print(result1)
print(result2)

结果：
['123', '456']
['123']

多个匹配模式，返回元组列表

import re

result = re.findall(r'(\w+)=(\d+)', 'asd width=20 sdf height=10 python100')
print(result)

结果：
[('width', '20'), ('height', '10')]

re.sub

re.sub ：用于替换字符串中的匹配项。

格式：re.sub(pattern, repl, string, count=0, flags =0)
函数参数说明

参数	描述
pattern	匹配的正则表达式
repl	替换的字符串，也可为一个函数
string	要被查找替换的原始字符串
count	模式匹配后替换的最大次数，默认0 表示替换所有的匹配

import re

pattern = r"\d+"  # 匹配一个或多个数字
string = "abc 123 def 456 ghi"

# 将字符串中的数字替换为 "NUM"
result = re.sub(pattern, "NUM", string)
print("替换后的字符串:", result)

re.split

re.split:按照能够匹配的子串将字符串分割后返回列表。

格式：re.split(pattern, string[, maxsplit=0, flags=0])
函数参数说明

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为0，不限制次数
flags	标志位，用于控制正则表达式的匹配方式

import re

pattern = r'\s+'  # 匹配一个或多个空白字符
string = 'Hello   World  Python'

# 使用正则表达式模式分割字符串
result = re.split(pattern, string)
print("分割后的子字符串:", result)

结果：
分割后的子字符串: ['Hello', 'World', 'Python']

匹配模式

在大多数正则表达式的方法中，都会有一个 flags 的参数，该参数用于控制正则表达式的匹配方式。

re.IGNORECASE

re.IGNORECASE :用于在正则表达式中启用大小写不敏感的匹配，可简写为 re.I

import re

pattern = r'apple'
string = 'Apple is a fruit. I like apple pie.'

# 使用 re.IGNORECASE 标志进行匹配
matches = re.findall(pattern, string, re.IGNORECASE)
print("忽略大小写匹配的结果:", matches)

结果：
忽略大小写匹配的结果: ['Apple', 'apple']

re.MULTILINE

re.MULTILINE: 用于启用多行模式，使用 ^ 和 $ 在每行的开头和结尾都能匹配, 可简写为 re.M

import re

pattern = r'^\d+'  # 匹配每行开头的数字
string = '123 apple\n456 banana\n789 cherry'

matches = re.findall(pattern, string)
print("单行匹配的结果:", matches)

# 使用 re.MULTILINE 标志进行匹配
matches = re.findall(pattern, string, re.MULTILINE)
print("多行匹配的结果:", matches)

结果：
多行匹配的结果: ['123', '456', '789']

匹配分组

模式	功能
`	`
`(xxx)`	将括号中字符作为一个分组
`\num`	引用分组 `num` 匹配到的字符串
`(?P<name>)`	分组起别名
`(?P=name)`	引用别名为 `name` 分组匹配到的字符串

`|` 匹配多个规则

使用 | 可以指定多个匹配表达式

import re

match_obj = re.match("[a-zA-Z0-9_]{4,20}@(163|126|qq|sina|yahoo)\.com", "hello@163.com")
if match_obj:
    print(match_obj.group())
    # 获取分组数据
    print(match_obj.group(1))
else:
    print("匹配失败")

`(xxx)` 分组

group() 方法可以获取完整的匹配结果，如果想获取匹配结果中某一个分组规则匹配到的结果，可以使用数字参数形式。

    import re
    match_obj = re.match("(\d{3,4})-(\d{4,10})", "010-888999")

    if match_obj:
        print(match_obj.group())
        # 分组:默认是1一个分组，多个分组从左到右依次加1
        print(match_obj.group(1))
        # 提取第二个分组数据
        print(match_obj.group(2))
    else:
        print("匹配失败")

`\xxx` 引用规则

在一个匹配模式中，如果一个规则出现多次，可以将规则进行分组，然后在分组后引用该规则，避免重复书写。

import re

match_obj = re.match("<[a-zA-Z1-6]+>.*</[a-zA-Z1-6]+>", "<html>hh</div>")

if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("<([a-zA-Z1-6]+)>.*</\\1>", "<html>hh</html>")

if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

`(?P<name>) (?P=name)` 分组命名与引用

在使用分组时，可以给分组进行命名。在匹配规则中，可以通过分组命名引用某个分组中的规则。

import re
match_obj = re.match("<(?P<name1>[a-zA-Z1-6]+)><(?P<name2>[a-zA-Z1-6]+)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.ceshiren.com</h1></html>")

if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
````|匹配字符串的结尾|
|`DISCOURSE_PLACEHOLDER_16`|匹配任意数字字符，相当于 [0-9]|
|`DISCOURSE_PLACEHOLDER_17`|匹配任意非数字字符，相当于除 [0-9]以外的字符|
|`DISCOURSE_PLACEHOLDER_18`|匹配任意字母、数字或下划线字符等非特殊字符，相当于 [a-zA-Z0-9_]|
|`DISCOURSE_PLACEHOLDER_19`|匹配任意除字母、数字或下划线字符以外的特殊字符，相当于除 [a-zA-Z0-9_]以外的字符|
|`DISCOURSE_PLACEHOLDER_20`|匹配任意空白字符，如空格、制表符、换行等|
|`DISCOURSE_PLACEHOLDER_21`|匹配任意非空白字符|

### 常用正则表达式处理函数

#### re.match

`DISCOURSE_PLACEHOLDER_22` ：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，`DISCOURSE_PLACEHOLDER_23`就返回 `DISCOURSE_PLACEHOLDER_24`。

* 格式：`DISCOURSE_PLACEHOLDER_25`

* 函数参数说明

|参数|描述|
| --- | --- |
|pattern|匹配的正则表达式|
|string|要匹配的字符串|
|flags|标志位，用于控制正则表达式的匹配方式|

DISCOURSE_PLACEHOLDER_26


* `DISCOURSE_PLACEHOLDER_27`: 获取匹配结果

DISCOURSE_PLACEHOLDER_28


* `DISCOURSE_PLACEHOLDER_29`: 获取匹配结果在原字符串中的范围

DISCOURSE_PLACEHOLDER_30


* `DISCOURSE_PLACEHOLDER_31`: 获取匹配结果在原字符串中起始下标位置

DISCOURSE_PLACEHOLDER_32


* `DISCOURSE_PLACEHOLDER_33`: 获取匹配结果在原字符串中的结束下标位置

DISCOURSE_PLACEHOLDER_34


#### re.search

`DISCOURSE_PLACEHOLDER_35`：在字符串中搜索匹配指定的模式，如果找到则返回匹配对象，否则返回 `DISCOURSE_PLACEHOLDER_36`。

* 格式：`DISCOURSE_PLACEHOLDER_37`
* 函数参数说明

|参数|描述|
| --- | --- |
|pattern|匹配的正则表达式|
|string|要匹配的字符串|
|flags|标志位，用于控制正则表达式的匹配方式|

DISCOURSE_PLACEHOLDER_38


#### re.match 与 re.search 的区别

* `DISCOURSE_PLACEHOLDER_39`只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回`DISCOURSE_PLACEHOLDER_40`.
* `DISCOURSE_PLACEHOLDER_41`匹配整个字符串，直到找到一个匹配。

#### re.findall

`DISCOURSE_PLACEHOLDER_42`:在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

* 格式：`DISCOURSE_PLACEHOLDER_43`
* 函数参数说明

|参数|描述|
| --- | --- |
|string|待匹配的字符串|
|pos|可选参数，指定字符串的起始位置，默认为 0|
|endpos|可选参数，指定字符串的结束位置，默认为字符串的长度|

DISCOURSE_PLACEHOLDER_44


* 多个匹配模式，返回元组列表

DISCOURSE_PLACEHOLDER_45


#### re.sub

`DISCOURSE_PLACEHOLDER_46` ：用于替换字符串中的匹配项。

* 格式：`DISCOURSE_PLACEHOLDER_47`
* 函数参数说明

|参数|描述|
| --- | --- |
|pattern|匹配的正则表达式|
|repl|替换的字符串，也可为一个函数|
|string|要被查找替换的原始字符串|
|count|模式匹配后替换的最大次数，默认0 表示替换所有的匹配|

DISCOURSE_PLACEHOLDER_48


#### re.split

`DISCOURSE_PLACEHOLDER_49`:按照能够匹配的子串将字符串分割后返回列表。

* 格式：`DISCOURSE_PLACEHOLDER_50`
* 函数参数说明

|参数|描述|
| --- | --- |
|pattern|匹配的正则表达式|
|string|要匹配的字符串|
|maxsplit|分隔次数，maxsplit=1 分隔一次，默认为0，不限制次数|
|flags|标志位，用于控制正则表达式的匹配方式|

DISCOURSE_PLACEHOLDER_51


### 匹配模式

在大多数正则表达式的方法中，都会有一个 `DISCOURSE_PLACEHOLDER_52` 的参数，该参数用于控制正则表达式的匹配方式。

#### re.IGNORECASE

`DISCOURSE_PLACEHOLDER_53` :用于在正则表达式中启用大小写不敏感的匹配，可简写为 `DISCOURSE_PLACEHOLDER_54`

DISCOURSE_PLACEHOLDER_55


#### re.MULTILINE

`DISCOURSE_PLACEHOLDER_56`: 用于启用多行模式，使用 `DISCOURSE_PLACEHOLDER_57` 和 `DISCOURSE_PLACEHOLDER_58` 在每行的开头和结尾都能匹配, 可简写为 `DISCOURSE_PLACEHOLDER_59`

DISCOURSE_PLACEHOLDER_60


### 匹配分组

|模式|功能|
| --- | --- |
|`DISCOURSE_PLACEHOLDER_61`|匹配左右任意一个表达式， `DISCOURSE_PLACEHOLDER_62`|
|`DISCOURSE_PLACEHOLDER_63`|将括号中字符作为一个分组|
|`DISCOURSE_PLACEHOLDER_64`|引用分组 `DISCOURSE_PLACEHOLDER_65` 匹配到的字符串|
|`DISCOURSE_PLACEHOLDER_66`|分组起别名|
|`DISCOURSE_PLACEHOLDER_67`|引用别名为 `DISCOURSE_PLACEHOLDER_68` 分组匹配到的字符串|

#### `DISCOURSE_PLACEHOLDER_69` 匹配多个规则

使用 `DISCOURSE_PLACEHOLDER_70` 可以指定多个匹配表达式

DISCOURSE_PLACEHOLDER_71


#### `DISCOURSE_PLACEHOLDER_72` 分组

`DISCOURSE_PLACEHOLDER_73` 方法可以获取完整的匹配结果，如果想获取匹配结果中某一个分组规则匹配到的结果，可以使用数字参数形式。

DISCOURSE_PLACEHOLDER_74


#### `DISCOURSE_PLACEHOLDER_75` 引用规则

在一个匹配模式中，如果一个规则出现多次，可以将规则进行分组，然后在分组后引用该规则，避免重复书写。

DISCOURSE_PLACEHOLDER_76


#### `DISCOURSE_PLACEHOLDER_77` 分组命名与引用

在使用分组时，可以给分组进行命名。在匹配规则中，可以通过分组命名引用某个分组中的规则。

DISCOURSE_PLACEHOLDER_78


## （七）JSON 模块

### JSON 概念

JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式，用于在不同应用程序之间传输和存储数据。它以文本形式表示结构化数据，易于理解和编写，同时也易于计算机解析和生成。

### JSON 的结构

* 对象：用花括号 `{}` 包裹,包含一系列键值对，每个键值对之间用逗号 `,` 分隔。
* 数组：用方括号 `[]` 包裹，包含一系列值，每个值之间用逗号 `,` 分隔。
* 键值对：键和值之间使用冒号 `:` 分隔，键必须是字符串，值可以是字符串、数字、布尔值、对象、数组、或null
* JSON数据的最外层只能是数组或对象
* JSON中的字符串，必须使用双引号包含

{
“name”: “John”,
“age”: 30,
“is_student”: false,
“address”: {
“city”: “New York”,
“zip”: “10001”
},
“hobbies”: [“reading”, “swimming”, “traveling”]
}


### Python 与 JSON 数据类型对应

|Python|JSON|
| --- | --- |
|dict|object|
|list, tuple|array|
|str|string|
|int, float|number|
|True|true|
|Flase|false|
|None|null|

### JSON 序列化与反序列化

JSON的序列化指的是将Python对象转换为JSON格式的字符串。

通过序列化，Python对象可以被编码为符合JSON规范的字符串，从而可以在不同的应用程序、平台或语言之间进行数据交换。

* `json.dumps()`：可以完成序列化的操作。这个函数将Python的数据结构转换为JSON格式的字符串。

import json

定义一个Python字典

data = {
“name”: “Alice”,
“age”: 30,
“city”: “New York”
}

将Python字典序列化为JSON格式的字符串

json_str = json.dumps(data)
print(json_str)


* `json.loads()`：用于将JSON格式的字符串解码为Python对象。

import json

json_str = ‘{“name”: “Alice”, “age”: 30, “city”: “New York”}’

将JSON字符串解码为Python对象

Python_obj = json.loads(json_str)
print(Python_obj)


### JSON 文件的写入和读取

* `with open(file_path, mode, encoding) as file`
  * `file_path`：要打开的文件路径
  * `mode`：打开文件的模式，如 `r` (只读)、`w` (写入)、`a`(追加) 等
  * `encoding`(可选)：文件的编码方式，默认为`None`，表示使用系统默认编码

* `json.dump()`：将Python对象序列转化为JSON格式并写入文件中。

import json

data = {
“name”: “John”,
“age”: 25,
“city”: “New York”
}

将数据写入JSON文件

with open(“data.json”, “w”) as file:
json.dump(data, file)


* `json.load`：从文件中读取JSON格式的数据并解码为Python对象。

import json

从JSON文件中读取数据

with open(“data.json”, “r”) as file:
data = json.load(file)

print(data)


## （八）日志模块

Pythono中的日志模块 `logging` 是用于记录应用程序运行时的信息，帮助开发者诊断问题，跟踪应用程序的状态以及记录重要的事件。

`logging` 模块提供了丰富的配置选项和灵活性，可以将日志信息输出到不同的位置，设置不同的日志级别等。

### logging模块的四大组件

* `logger`：日志器，提供程序可使用的接口。
* `handler`：处理器，用于写入日志文件并输出到指定位置，如文件、控制台或网络等。
* `filter`：过滤器，用于输出符合指定条件的日志记录。
* `formatter`：格式器，决定日志记录的输出格式。

### 日志等级

|级别|用法|
| --- | --- |
|DEBUG|最低级别的日志，用于调试和记录详细信息，通常用于开发和调试阶段|
|INFO|信息性信息，用于调试和记录详细信息，通常用于开发和调试阶段,确认程序按预期运行。|
|WARNING|表示警告，用于指示应用程序已经或即将发生的意外（例如：磁盘空间不足）。程序仍按预期进行。|
|ERROR|表示错误，由于严重的问题，程序的某些功能已经不能正常执行|
|CRITICAL|最高级别的日志，表示严重错误，表明程序已不能继续执行|

### logging.basicConfig() 函数

`logging.basicConfig()` 是Python中提供一个用来配置日志管理的函数。

**格式说明**：`logging.basicConfig(filename, filemode, format, level)`

* `filename`：指定将日志记录到文件中，如果不指定，则默认将日志输出到控制台。
* `filemode`：指定文件打开模式，默认为`'a'`（追加模式）。
* `format`：指定日志记录的格式。
* `level`：指定记录的最低级别，默认为`logging.WARNING`。

**format格式说明:**

* `%(asctime)s` 打印日志的时间
* `%(filename)s` 打印当前模块名
* `%(lineno)s` 打印日志当前的行号
* `%(levelname)s` 打印日志级别名称
* `%(message)s` 打印日志信息

**示例**

#导入日志模块
import logging

设置日志输出格式

fmt = “%(asctime)s - %(filename)s [line:%(lineno)d] - %(levelname)s - %(message)s”

配置日志

logging.basicConfig(filename=“myLog.log”,filemode=“w”,format=fmt ,level=logging.NOTSET)
#调用日志器触发日志信息
logging.debug(‘This is a debug message’)
logging.info(‘This is an info message’)
logging.warning(‘This is a warning message’)
logging.error(‘This is an error message’)
logging.critical(‘This is a critical message’)


## （九）虚拟环境的管理

虚拟环境是一个独立于系统全局环境的独立Python运行环境，用于隔离不同项目的依赖关系。

可以使每个项目都可以拥有独立的包依赖，从而避免包之间的冲突。

### venv 虚拟环境

* 虚拟环境是什么
* 虚拟环境的用途
* venv & virtualenv

### venv 虚拟环境的优点

* 独立的 Python 环境，不会产生冲突
* 有助于包的管理
* 删除和卸载方便

### venv 使用方法

* 创建虚拟环境
* 激活虚拟环境
* 安装 Python 包

### venv 创建虚拟环境

* 在终端中，进入要创建虚拟环境的目录，执行以下指令

Python3 -m venv myenv


### 激活虚拟环境

* 在 `macOS` 和 `Linux`上

source myenv/bin/activate


* 在Windows上

myenv\Scripts\activate


  * 虚拟环境被激活，在命令行提示符前看到环境名称（如`myenv`），表示已经在虚拟环境中。

## venv 安装 Python 包

* Python 版本选择
  * 进入 Python2.7 环境：`Python2`
  * 进入 Python3.x 环境: `Python3`

* pip 安装 Python 包
  * 安装 Python2.x 版本的包
  * 安装 Python3.x 版本的包

进入 Python2.7 环境

Python2

进入 Python3.x 环境

Python3

安装 Python2.x 版本的包

pip install xxx

安装 Python3.x 版本的包

pip3 install xxx


## venv 退出和删除

* 退出虚拟环境：deactivate
* 删除虚拟环境：删除环境目录

Windows和macOS通用的退出指令

deactivate


## （十）pip 工具使用

`pip`是Python中用于管理第三方包的工具，他可以帮助下载、安装、升级和管理各种Python包，能够轻松的引入外部库和模块到项目中。

### pip 常用命令

|功能|指令|
| --- | --- |
|查看 pip 版本|pip -V|
|查看帮助文档|pip help|
|查看包列表|pip list|
|安装|pip install 包名|
|升级|pip install --upgrade 包名|
|卸载|pip uninstall 包名|

### pip 安装包

* 普通安装

默认安装最新版本

pip install pytest


* 指定版本安装

指定版本

pip install pytest==6.2.0


* 批量安装

从文件清单中批量安装

pip install -r requirments.txt

文件格式

pytest==6.2.0
Faker==9.3.1
selenium==3.14.1


### pip 升级包

pip install --upgrade 包名


### pip 卸载包

pip uninstall 包名


### pip 列出已安装的包

pip list


### 升级pip

`Python -m pip install --upgrade pip`

### pip 指定安装源

* `pip install 包名 -i 镜像源`

* 国内常用源
  * 阿里源：https://mirrors.aliyun.com/pypi/simple/
  * 清华源：https://pypi.tuna.tsinghua.edu.cn/simple/
  * 豆瓣源：http://pypi.douban.com/simple/

使用镜像

pip install pytest -i Simple Index

Python测开28期 - 旎奥 - 学习笔记 -python常用模块

一、模块与包

（一）模块

1、项目目录结构

2、模块定义

3、文件引用

dir() 函数

（二）包

package 导入

__init__.py

二、内置模块

（一）math 模块

math 模块常量

math 模块方法

常用函数和常量

（二）random 模块

random 常用方法

（三）sys模块

sys 常用属性

sys 常用方法

（四）os模块

路径操作

目录和文件操作

其它操作

（五）datetime 模块

应用场景

获取当前日期时间

格式化日期和时间

解析日期和时间

计算日期间隔

比较日期

获取日期和时间的部分信息

（六）正则表达式

常用正则表达式语法及含义

常用正则表达式处理函数

re.match

re.search

re.match 与 re.search 的区别

re.findall

re.sub

re.split

匹配模式

re.IGNORECASE

re.MULTILINE

匹配分组

| 匹配多个规则

(xxx) 分组

\xxx 引用规则

(?P<name>) (?P=name) 分组命名与引用

定义一个Python字典

将Python字典序列化为JSON格式的字符串

将JSON字符串解码为Python对象

将数据写入JSON文件

从JSON文件中读取数据

设置日志输出格式

配置日志

进入 Python2.7 环境

进入 Python3.x 环境

安装 Python2.x 版本的包

安装 Python3.x 版本的包

Windows和macOS通用的退出指令

默认安装最新版本

指定版本

从文件清单中批量安装

文件格式

使用镜像

`init.py`

`|` 匹配多个规则

`(xxx)` 分组

`\xxx` 引用规则

`(?P<name>) (?P=name)` 分组命名与引用