常用模块

argparse

argparse 模块概述

argparse 是 Python 标准库中用于处理命令行参数的模块，它提供了一种简单而灵活的方式来解析命令行参数，并生成帮助文档。使用 argparse 可以轻松地创建命令行工具，以便用户可以通过命令行界面与程序进行交互。

位置参数

Positional Arguments

位置参数是命令行参数的一种类型，它们是根据它们在命令行中的位置来解析的，通常是在程序名称之后提供的。
位置参数通常用于表示必需的输入，用户必须提供它们以正确运行程序。
在 argparse 中，你可以通过 add_argument() 方法来定义位置参数。

示例：

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("input_file", help="Input file path")
parser.add_argument("output_file", help="Output file path")

args = parser.parse_args()

print("Input file:", args.input_file)
print("Output file:", args.output_file)

在上述示例中，input_file 和 output_file 都是位置参数，用户必须按照指定的顺序提供它们，例如：

python my_tool.py input.txt output.txt

位置参数的顺序非常重要，因为它们是根据它们在命令行中的位置来解析的。

选项参数

Optional Arguments

选项参数是命令行参数的另一种类型，它们通常是以前缀 - 或 -- 开头的，用户可以选择是否提供它们。
选项参数通常用于配置程序的行为，不是必需的输入。
在 argparse 中，你可以通过 add_argument() 方法来定义选项参数。

示例：

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--verbose", action="store_true", help="Enable verbose mode")
parser.add_argument("--threshold", type=float, help="Threshold value")

args = parser.parse_args()

print("Verbose mode:", args.verbose)
print("Threshold value:", args.threshold)

在上述示例中，--verbose 和 --threshold 都是选项参数，用户可以选择提供它们，例如：

collections

collections 模块是 Python 标准库中提供了一些额外的数据类型，用于扩展内建数据类型。其中一些主要的类包括 Counter、namedtuple、deque 等。

Counter 用于计数可哈希对象的出现次数
namedtuple 创建带有命名字段的元组
而 deque 则是一个双向队列，支持在两端高效地添加和弹出元素。

这些类提供了更多功能和性能上的优势，可以在不同场景中提高代码的可读性和性能。

OrderedDict

OrderedDict 是 collections 模块中的一个类，它是一个有序字典，保持插入元素的顺序。与普通的字典不同，OrderedDict 记录元素的添加顺序，并在迭代时按照插入的顺序返回元素。

from collections import OrderedDict

## 创建一个有序字典
ordered_dict = OrderedDict()

## 添加元素
ordered_dict['a'] = 1
ordered_dict['b'] = 2
ordered_dict['c'] = 3

## 打印有序字典
print(ordered_dict)
## Output: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

通过使用 OrderedDict，你可以确保字典的遍历顺序与元素添加的顺序一致。这在需要按照特定顺序处理字典元素时非常有用。

namedtuple

collections 模块中的 namedtuple 提供了一种创建具有命名字段的轻量级对象类型的方法，类似于结构体。它是一个工厂函数，用于创建命名元组类。

以下是 namedtuple 的基本用法和一些重要特性：

创建命名元组类： 使用 collections.namedtuple 函数可以创建一个命名元组类。它接受两个参数：元组类的名称和字段名称（可以是字符串，也可以是字段名的列表）。返回的是一个新的元组类。
```
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
```
创建命名元组对象： 使用创建的命名元组类，你可以像创建普通元组一样创建命名元组对象。字段可以通过名称来访问。
```
p = Point(3, 4)
print(p.x)  # 输出: 3
print(p.y)  # 输出: 4
```
字段访问： 与普通元组类似，命名元组对象的字段可以通过索引或属性名来访问。

configparser

configparser 是 Python 标准库中的一个模块，用于解析和操作 INI 文件格式的配置文件。它提供了一种简单的方法来读取和写入配置数据，支持创建、修改和删除配置文件中的节和键值对。

以下是 configparser 模块的基本用法示例：

导入模块：

首先，需要导入 configparser 模块：
```
import configparser
```
创建配置文件对象：

创建一个 ConfigParser 对象，用于操作配置文件：
```
config = configparser.ConfigParser()
```

读取配置文件：

使用 read() 方法从配置文件中读取数据：

config.read('config.ini')  # 读取名为 'config.ini' 的配置文件

访问配置数据：

使用 get() 方法来获取特定节和键的值：
```
server_name = config.get('Database', 'ServerName')
```
在上述代码中，我们获取了 Database 节中 ServerName 键的值。

修改配置数据：

使用 set() 方法来更改或添加配置数据：

config.set('Database', 'Port', '3307')  # 将 'Port' 的值更改为 '3307'
config.set('AppSettings', 'NewSetting', 'value')  # 添加一个新的键值对

写回到配置文件：

使用 write() 方法将修改后的配置数据写回到文件：
```
with open('config.ini', 'w') as configfile:
    config.write(configfile)
```
删除配置数据：

使用 remove_option() 方法来删除配置文件中的键值对：

csv

Python 提供了一个名为 csv 的内置模块，用于处理 CSV 文件。这个模块提供了一组功能，可以轻松地读取、写入和操作 CSV 文件。以下是 Python csv 模块的一些主要功能和常见用法：

导入模块：若要使用 csv 模块，首先需要导入它：
```
import csv
```

读取 CSV 文件：使用 csv.reader 类可以读取 CSV 文件。你可以提供一个文件对象或文件路径作为参数：

with open('example.csv', newline='') as csvfile:
    csvreader = csv.reader(csvfile)
    for row in csvreader:
        print(row)

写入 CSV 文件：使用 csv.writer 类可以创建 CSV 文件并写入数据。你可以提供一个文件对象或文件路径作为参数：

with open('example.csv', 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)
    csvwriter.writerow(['Name', 'Email'])
    csvwriter.writerow(['John Doe', 'johndoe@example.com'])

自定义分隔符和引号字符：默认情况下，csv 模块使用逗号作为字段分隔符和双引号作为引号字符。你可以通过设置 delimiter 和 quotechar 参数来自定义分隔符和引号字符。
处理 CSV 文件的头部：如果 CSV 文件包含列标题，你可以使用 next(csvreader) 来跳过头部行，然后再处理数据行。
处理不规则的 CSV 文件： csv 模块支持处理不规则的 CSV 文件，包括处理包含不同数量字段的行。

datetime

datetime 是 Python 的内置模块之一，用于处理日期和时间。它提供了多个类和函数，使得在 Python 中处理日期和时间变得方便。datetime 模块包括 date、time、datetime、timedelta 等类，以及一些处理日期和时间的函数。

以下是一些 datetime 模块中常用的类和函数：

datetime.datetime: 表示日期和时间的类。
datetime.date: 表示日期的类。
datetime.time: 表示时间的类。
datetime.timedelta: 表示两个日期或时间之间的差异。
datetime.now(): 返回当前日期和时间。
datetime.strptime(): 将字符串转换为 datetime 对象。
datetime.strftime(): 将 datetime 对象格式化为字符串。

datetime 模块在处理涉及日期和时间的应用程序时非常常用，例如日志记录、数据分析、Web 开发等领域。使用这个模块可以方便地进行日期和时间的计算、比较和格式化。

datetime 模块是 Python 标准库中用于处理日期和时间的模块。它包括了一些类和函数，使得在 Python 中进行日期和时间的处理更加方便。下面是对 datetime 模块的一些主要组件和功能的详细解释：

datetime 类：
- datetime.datetime 类是 datetime 模块中最常用的类，用于表示一个特定的日期和时间。
- 可以使用 datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0) 构造一个 datetime 对象。
- 常用的实例方法包括 strftime(format)（将日期时间对象格式化为字符串）、timestamp()（返回自 1970 年 1 月 1 日以来的秒数）、replace()（替换对象中的一些字段）等。
date 类：
- datetime.date 类表示一个日期（年、月、日），不包含时间。
- 可以使用 datetime.date(year, month, day) 构造一个 date 对象。
- 常用的实例方法包括 strftime(format)（将日期对象格式化为字符串）、today()（返回当前日期）等。
time 类：

functools

functools 模块是 Python 标准库中的一个模块，它提供了一些用于高阶函数（Higher-Order Functions）和函数操作的工具。高阶函数是那些接受一个或多个函数作为参数或返回一个函数作为结果的函数。functools 模块包括一些有用的函数，如 partial、reduce、wraps 等，用于函数的修饰、组合和操作。

以下是 functools 模块中一些常用函数的简要说明：

functools.partial：该函数用于部分应用（Partial Application）一个函数，即固定函数的一些参数，返回一个新的函数。这对于创建具有默认参数的函数非常有用。

from functools import partial

## 创建一个新函数，固定了一个参数
double = partial(lambda x, y: x * y, 2)
result = double(5)  # 等同于调用 lambda x: 2 * x，返回 10

functools.reduce：这个函数用于对可迭代对象中的元素进行累积操作。它接受一个二元函数和一个可迭代对象，并返回累积的结果。

from functools import reduce

## 使用 reduce 计算阶乘
result = reduce(lambda x, y: x * y, range(1, 6))  # 返回 120，即 5!

functools.wraps：这个函数用于将装饰器用于函数时，保留原函数的元数据（比如文档字符串和函数名）。这对于编写装饰器时保持函数信息的完整性很重要。

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 执行一些装饰操作
        result = func(*args, **kwargs)
        return result
    return wrapper

functools 模块还包括其他一些函数，用于缓存、比较、自定义排序和其他高级函数编程任务。这些函数可以帮助你更好地利用 Python 中的函数式编程特性，以及更灵活地操作函数。

json

json 概述

Python 提供了标准库中的 json 模块，可以用于将 Python 数据结构转换为 JSON 格式（序列化）或将 JSON 数据解析为 Python 数据结构（反序列化）。这使得在 Python 中处理 JSON 数据变得非常方便。

json 与 python 类型对应关系

以下是一个简单的对应表，显示了 JSON 数据类型和相应的 Python 数据类型之间的关系：

这个对应表可以帮助你理解 JSON 数据类型和 Python 数据类型之间的关系，以及在使用 Python 处理 JSON 数据时如何映射它们。

JSON 数据类型	Python 数据类型
对象（Object）	字典（`dict`）
数组（Array）	列表（`list`）
字符串（String）	字符串（`str`）
数字（Number）	整数（`int`）、浮点数（`float`）
布尔值（Boolean）	布尔值（`bool`）
空值（Null）	`None`

对象（Object）对应于 Python 字典（dict）

JSON 中的对象是由一组键值对组成的，而 Python 字典也是由键值对组成的数据结构，因此它们之间可以很容易地进行映射。

例如，JSON 对象：

{
  "name": "John",
  "age": 30
}

对应的 Python 字典：

kafka

概述

kafka-python 是一个纯 Python 实现的 Kafka 客户端库，适用于对 Kafka 的简单操作和中小规模的消息处理需求。尽管其性能可能不如基于 librdkafka 的 confluent-kafka-python，但它仍然是一个功能全面且易于使用的选择。

以下是对 kafka-python 的详细介绍，包括安装、基本用法和常见操作示例。

安装

首先，使用 pip 安装 kafka-python：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple kafka-python

生产者使用示例

以下是使用 kafka-python 创建 Kafka 生产者并发送消息的示例：

from kafka import KafkaProducer

## 创建生产者实例
producer = KafkaProducer(bootstrap_servers='localhost:9092')  # 替换为你的 Kafka 服务器地址

## 发送消息
producer.send('my_topic', key=b'my_key', value=b'Hello, Kafka!')

## 刷新网络缓冲区，使所有消息都被发送
producer.flush()

## 关闭生产者
producer.close()

消费者使用示例

以下是使用 kafka-python 创建 Kafka 消费者并接收消息的示例：

from kafka import KafkaConsumer

## 创建消费者实例
consumer = KafkaConsumer(
    'my_topic',
    bootstrap_servers='localhost:9092',  # 替换为你的 Kafka 服务器地址
    group_id='my_group',
    auto_offset_reset='earliest'
)

## 消费消息
for message in consumer:
    print(f"Received message: {message.value.decode('utf-8')}")

## 关闭消费者
consumer.close()

高级功能

分区和键控消息

你可以将消息发送到特定的分区，或使用键控消息来确保具有相同键的消息发送到同一分区：

logging

logging 模块概述

https://docs.python.org/3/library/logging.html?highlight=logging#module-logging

logging 模块是Python标准库中用于记录日志信息的模块。它提供了一种灵活的方式来管理应用程序的日志输出，以便在开发、调试和生产环境中跟踪和记录信息。使用 logging 模块，您可以控制日志消息的级别、输出位置和格式。

以下是一些关键的 logging 模块组件和概念：

Logger（记录器）：Logger是日志记录的主要接口。您可以创建一个或多个Logger实例，用于不同的部分或模块，以便将日志信息进行分类和组织。通常，每个模块或应用程序的不同部分都应该有自己的Logger。
Handler（处理程序）：Handler用于指定将日志消息发送到哪里。Python提供了多种内置的Handler，例如将消息发送到控制台、文件、网络套接字等。您还可以自定义Handler以满足特定需求。
Formatter（格式化程序）：Formatter用于定义日志消息的输出格式。它允许您指定消息中包含的信息（如时间戳、日志级别、模块名称和消息内容等），以便更容易阅读和分析日志。
Level（级别）：日志消息可以分为不同的级别，例如DEBUG、INFO、WARNING、ERROR和CRITICAL。您可以为每个Logger和Handler设置最低级别，以控制记录哪些级别的消息。
配置文件：您可以使用配置文件或编程方式配置logging模块，以决定日志的行为，包括级别、格式和输出位置。

logging 模块允许您根据应用程序的需求进行更高级的配置，包括将日志消息发送到不同的处理程序、在不同环境中更改日志级别等。这使得它成为一个强大的工具，用于管理和分析应用程序的日志。

Level

日志级别指的是产生日志的事件的严重程度。

以下是Python logging 模块中标准日志级别对应的数值以及它们的默认值：

日志级别	数值
CRITICAL	50
ERROR	40
WARNING（默认）	30
INFO	20
DEBUG	10
NOTSET	0

设置一个级别后，严重程度低于设置值的日志消息将被忽略。例如：设置为30（WARNING）后，只有大于等于30的（ERROR、CRITICAL）日志信息输出。

import logging

logging.info('info ~~~') # 不会输出，因为默认的的日志级别为30，而INFO为20（小于30）
logging.warning('warning ~~~') # WARNING:root:warning ~~~
logging.error('error ~~~') # ERROR:root:error ~~~

—

默认情况下，Logger、Handler和其他日志相关的对象的日志级别（例如，Logger.setLevel() 和 Handler.setLevel()）都设置为 NOTSET，这意味着它们会继承其最近的父级对象的级别设置。通常情况下，根Logger的默认级别也是 NOTSET。

如果您不显式设置级别，那么将会使用默认级别 NOTSET，这意味着它们不会阻止任何消息记录。要启用特定级别的日志记录，您需要显式设置相应的级别。

例如，在以下示例中，Logger的默认级别为 NOTSET，但我们通过Logger.setLevel(logging.DEBUG)显式设置了它的级别为 DEBUG：

import logging

## 创建一个Logger实例
logger = logging.getLogger('my_logger')

## 设置Logger的级别为DEBUG
logger.setLevel(logging.DEBUG)

## 记录DEBUG级别的日志消息
logger.debug('This is a debug message.')  # 会被记录

这样，只有 DEBUG 级别及以上的消息才会被记录。其他级别的消息将被忽略。

math

math 是 Python 标准库中的一个模块，提供了许多数学函数和常量。要使用 math 模块，需要先导入它：

import math

以下是 math 模块中常用的一些函数和常量：

常量

math.pi：圆周率，约等于 3.141592653589793。
math.e：自然常数，约等于 2.718281828459045。

数学函数

math.ceil(x)：返回不小于 x 的最小整数（向上取整）。
math.floor(x)：返回不大于 x 的最大整数（向下取整）。
math.trunc(x)：返回 x 的整数部分。
math.pow(x, y)：返回 x 的 y 次幂。
math.sqrt(x)：返回 x 的平方根。
math.exp(x)：返回 e 的 x 次幂。
math.log(x, base=math.e)：返回以 base 为底的对数，如果不指定 base，则默认为 e。
math.log10(x)：返回以 10 为底的对数。
math.sin(x)、math.cos(x)、math.tan(x)：返回 x 的正弦、余弦、正切值。
math.asin(x)、math.acos(x)、math.atan(x)：返回 x 的反正弦、反余弦、反正切值。
math.degrees(x)：将 x 从弧度转换为角度。
math.radians(x)：将 x 从角度转换为弧度。
math.hypot(x, y)：返回点 (x, y) 到原点的距离。
math.atan2(y, x)：返回点 (x, y) 的极角。

示例

import math

print(math.pi)              # 3.141592653589793
print(math.e)               # 2.718281828459045
print(math.ceil(3.5))       # 4
print(math.floor(3.5))      # 3
print(math.trunc(3.5))      # 3
print(math.pow(2, 3))       # 8.0
print(math.sqrt(4))         # 2.0
print(math.exp(2))          # 7.38905609893065
print(math.log(10))         # 2.302585092994046
print(math.log10(10))       # 1.0
print(math.sin(math.pi/2))  # 1.0
print(math.cos(math.pi/2))  # 6.123233995736766e-17
print(math.tan(math.pi/4))  # 0.9999999999999999
print(math.asin(1))         # 1.5707963267948966
print(math.acos(0))         # 1.5707963267948966
print(math.atan(1))         # 0.7853981633974483
print(math.degrees(math.pi))# 180.0
print(math.radians(180))    # 3.141592653589793
print(math.hypot(3, 4))

msgpack

msgpack 概述

MessagePack 是一种二进制数据序列化格式，类似于 JSON，但更加紧凑和高效。它的设计目标是在不损失性能的前提下，提供比 JSON 更快的数据序列化和反序列化操作。MessagePack 可以在不同编程语言之间进行数据交换，因为它有多种语言的实现，使得不同平台上的应用程序可以轻松地序列化和反序列化 MessagePack 数据。

以下是 MessagePack 的一些特点和使用示例：

特点：

高效性能： MessagePack 的二进制格式比 JSON 更紧凑，因此在网络传输和数据存储时占用更少的带宽和存储空间。
快速序列化和反序列化： MessagePack 的编解码速度通常比 JSON 快，这使得它适用于需要高性能的应用程序。
跨语言支持： MessagePack 有多种语言的实现，包括 Python、Java、C++、JavaScript 等，因此可以在不同编程语言之间轻松地进行数据交换。
支持丰富的数据类型： MessagePack 支持多种数据类型，包括整数、浮点数、字符串、数组、对象（字典）、布尔值等。

示例用法：

在 Python 中，你可以使用第三方库 msgpack 来进行 MessagePack 的编解码。首先，需要安装 msgpack 库：

pip install msgpack

然后，可以使用以下示例代码来演示 MessagePack 的使用：

import msgpack

## 创建一个 Python 字典
data = {
    "name": "Alice",
    "age": 30,
    "isStudent": False,
    "scores": [95, 88, 75]
}

## 序列化为 MessagePack 格式
packed_data = msgpack.packb(data)

## 打印 MessagePack 数据
print("Packed Data:", packed_data)

## 反序列化回 Python 数据
unpacked_data = msgpack.unpackb(packed_data, raw=False)

## 打印反序列化后的数据
print("Unpacked Data:", unpacked_data)

在这个示例中，我们创建了一个 Python 字典，将其序列化为 MessagePack 格式，然后再反序列化回 Python 数据。 MessagePack 提供了一个有效的方式来序列化和传输数据，特别适用于需要高性能的应用程序，例如游戏、网络通信和大规模数据处理。

multiprocessing

multiprocessing 模块概述

multiprocessing 是 Python 中用于实现并行处理的模块，它允许在多个进程中执行代码，以充分利用多核处理器。

注意事项：

全局变量问题： 多个进程之间不共享全局变量。在进程之间共享数据时，可以使用 multiprocessing 提供的 Value、Array 或 Manager 对象。
操作系统兼容性： multiprocessing 模块基于进程创建，而不是线程。因此，在处理 CPU 密集型任务时，它更适合利用多核 CPU。但是，与线程相比，创建和销毁进程的开销更大。
避免在交互式解释器中使用： 在交互式解释器（如 Jupyter Notebook）中，multiprocessing 的使用可能会遇到一些问题，因为它涉及到启动新的进程。

multiprocessing 是 Python 中强大且灵活的并行处理模块，在需要利用多核处理器的场景下，能够提高程序的执行效率。

Process()

Process（进程）： multiprocessing 中的核心对象之一。通过创建 Process 对象，可以启动一个新的进程，执行指定的函数或代码块。

terminate()

terminate() 方法是 multiprocessing 模块中 Process 对象的一个方法，用于终止该进程的执行。这个方法会强制结束一个正在运行的进程，不会给予进程进行清理或完成的机会，因此在使用时需要小心谨慎。

语法和用法：

Process.terminate()

语法： 调用 Process 对象的 terminate() 方法。
作用： 强制终止该进程的执行。
注意： 这种终止方式是比较暴力的，会直接中断进程的执行，可能会导致资源无法释放、文件未关闭或数据损坏等问题。

注意事项：

无法进行清理工作： terminate() 方法不会执行清理工作或触发 finally 代码块。因此，如果进程在执行过程中占用了资源（如打开文件、建立连接等），这些资源可能不会得到释放或关闭，可能会导致资源泄露。

NumPy

NumPy 是 Python 中用于数值操作的强大库，支持大型、多维数组和矩阵，同时提供了在这些数据结构上进行数学运算的函数。以下是一个简要概述：

数组： NumPy 的主要对象是 numpy.ndarray，一个多维元素数组。您可以使用 numpy.array() 创建数组。

import numpy as np

arr = np.array([1, 2, 3])

数组操作： NumPy 提供各种操作，如逐元素加法、减法、乘法等。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

result = a + b

数组形状和重塑： 您可以检查和修改数组的形状。

arr.shape  # 返回数组的形状
arr.reshape((2, 3))  # 将数组重塑为 2x3 矩阵

索引和切片： 与 Python 列表类似，您可以使用索引和切片访问数组中的元素。

arr[0]  # 访问第一个元素
arr[1:3]  # 访问从索引 1 到 2 的元素

广播： NumPy 允许在不同形状和大小的数组之间进行操作。

arr = np.array([1, 2, 3])
scalar = 2
result = arr * scalar

数学函数： NumPy 提供了许多用于数组操作的数学函数。

np.mean(arr)  # 计算数组的平均值
np.sin(arr)   # 逐元素应用正弦函数

线性代数： NumPy 有一个用于线性代数操作的模块 (numpy.linalg)。

matrix = np.array([[1, 2], [3, 4]])
det = np.linalg.det(matrix)  # 计算矩阵的行列式
inv = np.linalg.inv(matrix)  # 计算矩阵的逆

这只是一个简要概述。NumPy 有许多其他功能，是 Python 科学计算生态系统中的基础库。

os

os 模块概述

os 模块是 Python 中的一个标准库模块，用于与操作系统进行交互，提供了许多用于文件和目录操作、环境变量管理、进程控制等功能的函数和方法。

os 模块常用函数和方法

PS：“方法”通常指的是类中定义的函数，而“函数”则是指一般的独立代码块。

os 模块提供了许多用于与操作系统进行交互的方法。以下是 os 模块中一些常用的方法：

文件和目录操作：
- os.listdir(path='.'): 返回指定目录中的文件和子目录列表。
- os.mkdir(path): 创建一个新目录。
- os.makedirs(path, mode=0o777, exist_ok=False): 递归创建目录，如果目录已经存在则不会引发异常（如果 exist_ok 为 True）。
- os.remove(path): 删除指定的文件。
- os.rmdir(path): 删除指定的目录（只能删除空目录）。
- os.removedirs(path): 递归删除目录树。
- os.rename(src, dst): 重命名文件或目录。
- os.path.exists(path): 检查指定的路径是否存在。
- os.path.isfile(path): 检查指定的路径是否是文件。
- os.path.isdir(path): 检查指定的路径是否是目录。
环境变量：
- os.getenv(name, default=None): 获取指定环境变量的值。
- os.putenv(name, value): 设置环境变量的值。
- os.environ: 包含当前环境变量的字典。
系统信息：
- os.name: 返回当前操作系统的名称（例如，‘posix’ 表示 Unix/Linux 系统，’nt’ 表示 Windows 系统）。
- os.uname(): 返回有关当前系统的信息，但在 Windows 系统上不可用。
- os.getcwd(): 返回当前工作目录。
- os.chdir(path): 改变当前工作目录。
进程管理：

pickle

pickle 概述

pickle 是 Python 中的一个模块，用于序列化和反序列化 Python 对象。它允许你将 Python 对象保存到磁盘或通过网络传输，然后在需要时将其还原为原始对象。

以下是关于 pickle 模块的一些重要信息：

序列化：使用 pickle，你可以将 Python 对象转换为二进制数据流，这个过程称为序列化。这允许你将对象保存到文件中或通过网络发送给其他计算机。
反序列化：反序列化是将二进制数据流还原为原始的 Python 对象。这使你能够重新获取已序列化的对象，并在你的程序中使用它们。

用法：使用 pickle 很简单。你可以使用 pickle.dump() 将对象序列化并保存到文件中，然后使用 pickle.load() 从文件中读取并反序列化对象。以下是一个示例：

import pickle

# 序列化对象并保存到文件
data = {'name': 'Alice', 'age': 30}
with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)

# 从文件中读取并反序列化对象
with open('data.pkl', 'rb') as file:
    loaded_data = pickle.load(file)

print(loaded_data)  # 输出: {'name': 'Alice', 'age': 30}

安全性注意事项：请注意，由于 pickle 可以序列化几乎任何 Python 对象，因此要小心从不受信任的来源加载 pickle 数据，因为它可能包含恶意代码。不要在不受信任的环境中使用 pickle。
跨 Python 版本问题：pickle 的序列化格式与 Python 版本相关，因此在不同版本的 Python 之间可能存在兼容性问题。如果需要跨版本保存和加载数据，可以考虑使用其他序列化格式，如 JSON。

总之，pickle 是 Python 中用于序列化和反序列化对象的强大工具，但需要小心使用以确保数据的安全性和兼容性。

psutil

Process()

在Python中，有一些库可以用来控制进程的CPU亲缘性绑定，比如psutil和os.sched_setaffinity。

psutil库提供了跨平台的系统信息查询和进程管理功能，可以用来设置进程的CPU亲缘性绑定。以下是使用psutil库的示例：

import psutil

def bind_process_to_cores(process_id, core_list):
    p = psutil.Process(process_id)
    p.cpu_affinity(core_list)

## 示例：将进程绑定到CPU核心0和1
process_id_to_bind = 1234  # 替换为你的进程ID
cores_to_bind = [0, 1]     # 替换为你想要绑定的CPU核心列表

bind_process_to_cores(process_id_to_bind, cores_to_bind)

这个示例使用psutil.Process获取特定进程，并使用cpu_affinity方法将其绑定到指定的CPU核心列表上。

pymysql

使用流程概述

PyMySQL 是一个纯 Python 实现的 MySQL 客户端库，用于与 MySQL 服务器进行通信和交互。

使用 PyMySQL 连接 MySQL 数据库主要包括以下步骤：

安装 PyMySQL：首先需要通过 pip 或其他包管理工具安装 PyMySQL 库。
```
pip install pymysql
```
连接到 MySQL 数据库：在 Python 代码中导入 PyMySQL 库，并使用 connect() 方法建立与 MySQL 数据库的连接。连接方法需要提供数据库的主机地址、用户名、密码、数据库名称等信息。
```
import pymysql

# 建立数据库连接
conn = pymysql.connect(
    host='localhost',
    user='username',
    password='password',
    database='database_name'
)
```
创建游标对象：连接成功后，需要创建一个游标对象，用于执行 SQL 查询和操作数据库。
```
# 创建游标对象
cursor = conn.cursor()
```
执行 SQL 查询：使用游标对象的 execute() 方法执行 SQL 查询语句。
```
# 执行 SQL 查询
cursor.execute("SELECT * FROM table_name")
```
获取查询结果：通过游标对象的 fetchall()、fetchone() 或 fetchmany() 方法获取执行查询后的结果。

queue

queue 模块概述

Python中的queue模块提供了多种队列数据结构的实现，用于在多线程编程中进行线程安全的数据共享和通信。以下是queue模块中常用的类和函数：

Queue 类型

queue.Queue(maxsize=0)：创建一个FIFO队列（先进先出）。maxsize参数指定队列的最大容量，如果为0或负数，则队列的容量不受限制。
queue.LifoQueue(maxsize=0)：创建一个LIFO队列（后进先出），也称为堆栈。
queue.PriorityQueue(maxsize=0)：创建一个具有优先级的队列，其中元素按照优先级顺序排列。

常用方法

适用于上述所有队列类型：

put()

put(item, block=True, timeout=None)，将元素放入到队列中。

item
- 将item放入队列中（推入队列的顶部（堆栈的顶部））。
block
- block=True（默认值），在队列已满时阻塞，直到有空间可用；
- block=False，在队列已满时，抛出queue.Full异常。
timeout
- 指定在阻塞时等待的最长时间。

put_nowait(item)

等效于put(item, block=False)，不会阻塞。

get()

get(block=True, timeout=None)，从队列的顶部（堆栈的顶部）弹出一个元素。

block：
- block=True（默认值），在队列为空时阻塞，直到有元素可用；
- block=False，在队列为空时抛出queue.Empty异常。
timeout=N
- 指定在阻塞时等待的最长时间。

get_nowait(item)

等效于get(item, block=False)，不会阻塞。

qsize()

返回队列中的元素数量。

from queue import Queue

q = Queue(3)

q.put(1)
q.put(2)
q.put(3)

print(q.qsize()) # 3

empty()

如果队列为空，则返回True；否则返回False。

from queue import Queue

q = Queue()

q.put(1)

print(q.empty()) # False，队列不为空
print(q.get()) # 1
print(q.empty()) # True，队列为空

full()

如果队列已满，则返回True；否则返回False。

re

re 基础语法

re 模块是Python中用于处理正则表达式的标准库。以下是使用 re 模块的基本步骤：

导入 re 模块：首先，需要导入 re 模块。
```
import re
```
编译正则表达式模式：使用 re.compile() 函数将正则表达式模式编译为一个可重用的正则表达式对象。
```
pattern = re.compile(r'正则表达式模式')
```
在这里，r 前缀表示原始字符串，以防止反斜杠字符 \ 被转义。
使用正则表达式对象进行匹配和搜索：有几种方法可用于在字符串中执行匹配和搜索操作：
- match()：从字符串的开头开始匹配。
  result = pattern.match(string)
- search()：在字符串中搜索匹配，返回第一个匹配项。
  result = pattern.search(string)
- findall()：返回字符串中所有匹配项的列表。
  results = pattern.findall(string)
- finditer()：返回一个迭代器，用于迭代所有匹配项。
  results = pattern.finditer(string) for match in results: print(match.group())
处理匹配结果：匹配结果通常是 Match 对象，你可以使用 group() 方法来获取匹配的文本。
```
if result:
    matched_text = result.group()
```
如果需要捕获分组中的内容，可以使用 groups() 方法或 group(1), group(2) 等。
其他操作：re 模块还提供了其他一些方法和标志，用于执行不同类型的匹配和搜索，例如，使用 sub() 方法替换匹配项，或者使用标志来控制匹配的行为，如忽略大小写、多行匹配等。

这只是一个简单的 re 模块入门，正则表达式本身可以非常复杂，具体取决于你的需求。你需要根据要解决的问题和正则表达式的复杂性来选择适当的方法和模式。

flags

re 模块中的 re.compile()、re.match()、re.search()、re.fullmatch() 等函数可以接受一个可选的 flags 参数，用于指定不同的匹配选项和标志。以下是一些常见的 flags 参数，以及它们的作用：

requests

requests 模块概述

requests 是一个Python HTTP库，用于向网络服务器发起请求和获取响应。它提供了简洁且易于使用的API，使得发送HTTP请求变得非常简单。

如果你还没有安装 requests 模块，可以使用以下命令安装：

pip install requests

https://github.com/psf/requests/tree/main

https://requests.readthedocs.io/en/latest/

requests 常用函数

requests 模块提供了一系列常用的函数，用于发送不同类型的HTTP请求以及处理响应。以下是其中一些常用的函数：

requests.get(url, params=None, **kwargs)：发起一个GET请求，并返回一个 Response 对象。可以通过 params 参数传递查询字符串参数。
requests.post(url, data=None, json=None, **kwargs)：发起一个POST请求，并返回一个 Response 对象。可以通过 data 参数传递表单数据，或使用 json 参数传递JSON数据。
requests.put(url, data=None, **kwargs)：发起一个PUT请求，并返回一个 Response 对象。
requests.delete(url, **kwargs)：发起一个DELETE请求，并返回一个 Response 对象。
requests.head(url, **kwargs)：发起一个HEAD请求，并返回一个 Response 对象，通常用于检查资源的头部信息而不获取其内容。
requests.options(url, **kwargs)：发起一个OPTIONS请求，并返回一个 Response 对象，用于获取目标URL支持的HTTP方法。
requests.request(method, url, **kwargs)：发起一个自定义类型的HTTP请求，并返回一个 Response 对象。method 参数指定请求方法，如 ‘GET’、‘POST’ 等。

Scapy

Scapy是一个Python模块，用于处理、发送和捕获网络数据包。它允许用户构建自定义的网络协议和执行各种网络任务。以下是Scapy模块的一些主要功能：

构建和解析数据包： Scapy允许你构建和解析各种网络协议的数据包，包括TCP、UDP、ICMP等。
发送和接收数据包： 你可以使用Scapy发送自定义的数据包到网络，并捕获网络中传输的数据包。
嗅探网络流量： Scapy可以用于嗅探网络流量，分析和捕获经过网络接口的数据包。
网络扫描： 通过Scapy，你可以进行端口扫描和其他类型的网络扫描，以便检查网络中的主机和服务。
攻击和测试网络： Scapy可用于模拟各种网络攻击和测试，帮助发现和修复网络中的安全漏洞。

以下是一个简单的Scapy示例，用于构建和发送Ping数据包：

from scapy.all import IP, ICMP, sr1

## 构建Ping数据包
packet = IP(dst="www.example.com") / ICMP()

## 发送数据包并接收响应
response = sr1(packet, timeout=2)

## 打印响应信息
if response:
    response.show()
else:
    print("No response received.")

这只是Scapy的简单用法，你可以根据需要深入学习其更高级的功能和用法。

scapy.all 中的 .all 是什么意思

在Scapy中，.all并不表示“全部”或“所有”，而是指导入Scapy模块中的所有功能。当你使用from scapy.all import *语句时，它会导入Scapy模块的所有子模块和功能，使得你可以直接访问它们，而无需使用模块名称作为前缀。

这样的导入语句允许你方便地使用Scapy的所有功能而不必每次都明确指定模块名称。然而，要注意过度使用*通配符可能导致命名冲突和代码可读性降低，因此在大型项目中最好只导入需要的具体功能，而不是整个scapy.all模块。

如果不加.all会怎样

如果不使用.all，你需要显式地导入你要使用的Scapy模块或功能。这意味着你需要按照模块层次结构来引入相应的组件。例如：

from scapy.layers.inet import IP, ICMP
from scapy.sendrecv import sr1

## 构建Ping数据包
packet = IP(dst="www.example.com") / ICMP()

## 发送数据包并接收响应
response = sr1(packet, timeout=2)

## 打印响应信息
if response:
    response.show()
else:
    print("No response received.")

在这个例子中，我从scapy.layers.inet模块导入IP和ICMP，以及从scapy.sendrecv模块导入sr1。通过这种方式，你只引入了需要的部分，避免了导入整个scapy.all模块可能带来的潜在问题。

shutil

shutil 模块是 Python 的标准库之一，用于执行各种文件操作。它构建在 os 模块之上，提供了更高级的文件和目录操作功能，包括文件的复制、移动、删除、压缩等。以下是一些常用的 shutil 模块函数和方法：

复制文件或目录：

import shutil
shutil.copy('/path/to/source', '/path/to/destination')

递归复制目录及其内容：

shutil.copytree('/path/to/source', '/path/to/destination')

移动文件或目录：

shutil.move('/path/to/source', '/path/to/destination')

删除文件或目录（与 os.remove() 和 os.rmdir() 不同，shutil.rmtree() 可以删除非空目录）：

shutil.rmtree('/path/to/directory')

压缩文件或目录为 ZIP 文件：

shutil.make_archive('/path/to/archive', 'zip', '/path/to/source')

解压 ZIP 文件：

shutil.unpack_archive('/path/to/archive.zip', '/path/to/destination')

复制文件的权限和元数据：

shutil.copy2('/path/to/source', '/path/to/destination')

获取文件或目录的大小：

total_size = shutil.disk_usage('/path/to/directory').total

检查文件是否存在并且可读：

exists_and_readable = shutil.os.path.isfile('/path/to/file') and os.access('/path/to/file', os.R_OK)

获取文件的最后访问和修改时间：

atime, mtime = shutil.os.path.getatime('/path/to/file'), shutil.os.path.getmtime('/path/to/file')

拷贝文件权限和状态信息（包括所有者和组）：

shutil.copymode('/path/to/source', '/path/to/destination')

shutil 模块提供了许多功能强大的文件和目录操作工具，非常适合在 Python 中处理文件系统任务。在使用 shutil 模块时，要小心确保你有适当的权限，并注意对文件和目录的操作可能会对系统造成影响。

simplejson

simplejson 是 Python 中一个流行的 JSON 解析和编码库，它提供了一种更快、更轻量级的替代方案。下面是对 simplejson 库的详细解释：

快速和高效：simplejson 库以纯 Python 实现，具有快速和高效的特性。它使用 C 扩展模块（如果可用）来加速 JSON 解析和编码，从而在处理大型 JSON 数据时表现出色。
兼容性：simplejson 库与 Python 标准库中的 json 模块兼容，实际上 simplejson 库是 json 模块的增强版本。因此，你可以将 simplejson 库视为 json 模块的一个替代品，但是具有更好的性能。
支持各种 Python 数据类型：simplejson 库支持 Python 中几乎所有的基本数据类型，包括字符串、整数、浮点数、布尔值、列表、字典等。它可以将这些数据类型转换为 JSON 格式，并且可以从 JSON 格式中解析出这些数据类型。
自定义编码和解码行为：simplejson 库提供了许多参数和选项，可以用来自定义 JSON 数据的编码和解码行为。例如，你可以设置缩进、排序键、跳过不可序列化的对象等。
异常处理：simplejson 库提供了丰富的异常类型，用于处理在解码 JSON 数据时可能出现的错误情况。这些异常类型使得在处理 JSON 数据时更容易捕获并处理错误。
广泛应用：simplejson 库被广泛应用于许多 Python 项目中，特别是在需要处理大量 JSON 数据或对性能要求较高的项目中。它的性能和易用性使得它成为了许多开发者首选的 JSON 解析和编码库。

总的来说，simplejson 库是一个功能强大、性能优越的 JSON 解析和编码库，它使得在 Python 中处理 JSON 数据变得更加简单和高效。

下面是一个简单的 simplejson 库的使用范例，包括如何将 Python 数据转换为 JSON 格式，以及如何将 JSON 数据解析为 Python 数据：

subprocess

subprocess 是 Python 中用于创建和管理新进程的模块。它提供了一个更灵活的接口，用于执行外部命令、访问系统 I/O 流以及进行进程间通信。

常用函数：

subprocess.run()
- 执行命令，并等待其完成。可控制输入、输出、错误处理和超时。
- 示例：subprocess.run(['ls', '-l'])
subprocess.Popen()
- 更灵活的创建子进程的方法，允许更多的交互和控制。
- 示例：subprocess.Popen(['echo', 'Hello, subprocess!'])
subprocess.call()
- 执行命令，等待其完成，返回退出码。
- 示例：subprocess.call(['ls', '-l'])
subprocess.check_output()
- 执行命令并获取其输出。如果返回非零退出码，则引发 CalledProcessError 异常。
- 示例：subprocess.check_output(['ls', '-l'])

常用类：

subprocess.CompletedProcess
- run() 函数的返回类型，包含有关已完成进程的信息，如退出码、输出等。
subprocess.Popen
- 用于创建新进程的类，可用于与子进程进行交互和控制。
- 可以使用 communicate() 方法与子进程进行通信。

这些函数和类可以让你在 Python 中方便地执行外部命令，并控制子进程的输入、输出和行为。使用它们时要留意异常处理、输入输出流的管理以及子进程的交互。

—

run()

subprocess.run() 是 Python subprocess 模块中的一个函数，用于执行外部命令并等待其完成。它是 Python 3.5 引入的一个便捷函数，简化了执行外部命令并处理输入、输出和错误的过程。

语法

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, shell=False, timeout=None, check=False, text=None, encoding=None, errors=None, env=None, cwd=None, pass_fds=(), executable=None, start_new_session=False)

常用参数

args

要执行的命令及其参数，可以是列表形式（如 ['ls', '-l']）或字符串形式（如 'ls -l'）。

sys

sys 模块概述

sys 是 Python 标准库中的一个模块，它提供了与 Python 解释器以及与解释器交互的功能。sys 模块包含了一些有用的函数和变量，可以让你访问和控制 Python 解释器的一些运行时环境设置。以下是一些常用的 sys 模块功能：

argv

这是一个包含命令行参数的列表。当你在命令行中运行 Python 脚本时，sys.argv 会包含脚本名和传递给脚本的参数。

import sys

print(sys.argv)  # 打印命令行参数列表

## python3 test_sys.py arg1 arg2 arg3
['test_sys.py', 'arg1', 'arg2', 'arg3']

path

这是一个包含用于查找模块的目录列表的字符串列表。你可以修改它以添加或删除模块搜索路径。

import sys

sys.path # 模块当前搜索路径

sys.path.append("/path/to/your/module")  # 添加模块搜索路径

modules

这是一个字典，包含了当前已导入的模块。你可以使用它来查询已加载的模块。

import sys

print(sys.modules.keys())  # 打印已导入模块的名称

stdin

这是标准输入流，你可以用它来获取用户的输入。

import sys

user_input = sys.stdin.readline()  # 读取用户输入

stdout & stderr

这些变量表示标准输出和标准错误流，你可以重定向它们以捕获或修改程序的输出。

time

在Python中，你可以使用内置的 time 模块来实现休眠功能，从而让程序暂停执行一段时间。time.sleep() 函数是用于实现休眠的主要方法。以下是一个简单的示例：

import time

print("开始执行")
time.sleep(5)  # 休眠5秒
print("休眠结束，继续执行")

在上面的示例中，程序会在执行到 time.sleep(5) 这一行时暂停执行5秒钟，然后继续执行后续代码。

time.sleep() 的参数是休眠的秒数，可以是小数，表示休眠的部分秒。例如，time.sleep(0.5) 会让程序休眠半秒钟。

请注意，虽然 time.sleep() 在某些情况下很有用，但在多线程或异步编程中使用时需要谨慎，因为它会阻塞当前线程的执行。在这种情况下，你可能需要考虑使用异步编程工具或定时器来代替 time.sleep()，以避免阻塞整个程序的执行。