Python 有用的库&模块

简介

Python中有许多常用的库或者模块，在写代码的时候或多或少会遇到，本文对其进行总结，方便日后查阅。

pprint

Python中的pprint模块是用于打印数据结构（如字典，列表等）的模块，提供了一种以更可读的方式打印数据结构的方法。pprint在输出时会自动缩进和对齐数据，并且能够递归处理嵌套的数据结构，确保整个结构都以一致的格式打印出来。

pprint模块主要包含以下两个函数：

1. pprint.pprint(object, stream=None, indent=1, width=80, depth=None, compact=False)：这个函数打印出一个对象的可读形式。它与内置的print()函数类似，但是打印的结果更易读，并且适用于任何Python对象。

参数说明：

• object：要打印的对象。
• stream：指定打印的输出流，默认为标准输出。
• indent：每个嵌套级别的缩进空格数，默认为1。
• width：每行的最大字符宽度，默认为80个字符。
• depth：递归打印的最大深度，默认为None（没有限制）。
• compact：如果为True，则使用紧凑格式打印数据，默认为False。

2. pprint.pformat(object, indent=1, width=80, depth=None, compact=False)：该函数返回一个对象的可读字符串，而不是打印到标准输出。它与pprint()函数类似，但是返回的是一个字符串。

参数说明：

• object：要格式化的对象。
• indent：每个嵌套级别的缩进空格数，默认为1。
• width：每行的最大字符宽度，默认为80个字符。
• depth：递归格式化的最大深度，默认为None（没有限制）。
• compact：如果为True，则使用紧凑格式格式化数据，默认为False。

使用pprint模块示例：

import pprint

data = {'name': 'John', 'age': 30, 'city': 'New York'}

# 使用pprint函数打印对象
pprint.pprint(data)

# 使用pformat函数返回对象的可读字符串
formatted_data = pprint.pformat(data)
print(formatted_data)

输出结果：

{'age': 30, 'city': 'New York', 'name': 'John'}
{'age': 30, 'city': 'New York', 'name': 'John'}

import pprint

data = (
    "My name is Daniel", 
    [1, 2, 3, 4, 5], 
    ("more tuples", 1.4, 2.8, 5.7), 
    "welcome to my blog!"
    )

输出结果：

('My name is Daniel',
 [1, 2, 3, 4, 5],
 ('more tuples', 1.4, 2.8, 5.7),
 'welcome to my blog!')

从上述示例可以看出，使用pprint模块打印的对象更易读，并且字典的键值对顺序与原始字典一致，当打印复杂的嵌套数据结构时该模块十分有用。

pickle

Python中的pickle模块是一种用于序列化和反序列化Python对象的工具。pickle模块可以将Python对象转化为字节流，以便可以在文件中保存或在网络上传输，并且可以将字节流反序列化为原始对象。

pickle模块提供了四个主要的函数：

• pickle.dump(obj, file)：将对象序列化并保存到文件中。
• pickle.load(file)：从文件中读取序列化的对象并反序列化为原始对象。
• pickle.dumps(obj)：将对象序列化为字节流。
• pickle.loads(bytes)：将字节流反序列化为原始对象。

pickle模块的特点：

1. 支持几乎所有的Python数据类型，包括自定义类和函数。
2. 序列化后的字节流是二进制格式，无法直接阅读和编辑。
3. 序列化的对象包含对象的数据和类的信息，可以在不同的Python解释器中进行反序列化。

使用pickle模块保存和加载Python对象示例：

import pickle

# 将对象保存到文件中
data = {"name": "Alan", "age": 25}
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

# 从文件中加载对象
with open("data.pkl", "rb") as f:
    data = pickle.load(f)
print(data)  # {"name": "Alan", "age": 25}

# 将对象序列化为字节流
data_bytes = pickle.dumps(data)
print(data_bytes)

# 将字节流反序列化为对象
data = pickle.loads(data_bytes)
print(data)  # {"name": "Alan", "age": 25}

pickle模块对于保存和加载Python对象的状态非常有用，例如在数据持久化、缓存和进程间通信时使用。值得注意的是，pickle模块存在安全性风险，因为反序列化过程中可以执行任意代码，需谨慎使用。

json

Python中的json模块用于处理JSON（JavaScript Object Notation）格式的数据。JSON是一种轻量级的数据交换格式，常用于前后端数据的传输。

json模块提供了四个主要的功能：

1. 将Python对象转换为JSON字符串（序列化）
2. 将JSON字符串转换为Python对象（反序列化）
3. 读取或写入JSON文件
4. 解析和生成复杂的JSON数据结构

下面列举json模块的一些基本操作：

1. 将Python对象转换为JSON字符串（序列化）

import json

data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}

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

输出结果：

{"name": "John", "age": 30, "city": "New York"}

2. 将JSON字符串转换为Python对象（反序列化）

import json

json_data = '{"name": "John", "age": 30, "city": "New York"}'

data = json.loads(json_data)
print(data) 

输出结果：

{'name': 'John', 'age': 30, 'city': 'New York'}

3. 读取或写入JSON文件

import json

# 读取JSON文件
with open('data.json', 'r') as file:
    data = json.load(file)

# 写入JSON文件
with open('data.json', 'w') as file:
    json.dump(data, file)

4. 解析和生成复杂的JSON数据结构

import json

data = {
    'name': 'Daniel',
    'age': 30,
    'city': 'New York',
    'friends': [
        {'name': 'Alan', 'age': 28},
        {'name': 'Bob', 'age': 32}
    ]
}

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

输出结果：

{
    "name": "Daniel",
    "age": 30,
    "city": "New York",
    "friends": [
        {"name": "Alan", "age": 28},
        {"name": "Bob", "age": 32}
    ]
}

注意：python的json模块默认对字典中的键进行排序再进行序列化，如果想保持原来的顺序可以使用json.dumps(data, sort_keys=False)。

glob

Python的glob模块是用于文件路径的通配符匹配的工具，可用于查找匹配特定模式的文件名，并返回匹配的文件名列表。glob模块提供了一个函数glob，接受一个模式参数，返回与该模式匹配的文件名列表。

下面是一些常用的模式匹配字符：

• *：匹配任意字符序列（不包括路径分隔符）。
• ?：匹配任意单个字符。
• [...]：匹配指定字符集中的任意一个字符。
• [!...]：匹配不在指定字符集中的任意一个字符。

使用示例：

import glob

# 查找当前目录下的所有py文件
py_files = glob.glob('*.py')
print(py_files)

# 查找当前目录及子目录下的所有txt文件
txt_files = glob.glob('**/*.txt', recursive=True)
print(txt_files)

# 查找当前目录及子目录下的所有以a开头的py文件
py_files_starting_with_a = glob.glob('**/a*.py', recursive=True)
print(py_files_starting_with_a)

# 查找当前目录及子目录下的所有以数字开头的文件夹
numbered_folders = glob.glob('[0-9]*', recursive=True)
print(numbered_folders)

glob模块返回的文件名列表是按照文件系统的默认顺序排序的，可能是任意顺序，如果需要按字母顺序排序，可以使用sorted函数对列表进行排序。

# 按字母顺序排序文件名列表
sorted_files = sorted(py_files)
print(sorted_files)

此外，glob模块还提供了一些其他函数，如iglob函数用于生成一个迭代器，escape函数用于转义特殊字符等。

shutil

Python的shutil模块提供了一组高级文件操作函数，可以方便地完成文件和文件夹的复制、移动、删除等操作。

1. shutil.copy(src, dst, *, follow_symlinks=True):
   复制文件从源路径src到目标路径dst。如果目标路径是一个文件夹，则将文件复制到该文件夹下，并保持原文件名。如果目标路径已存在同名文件，则会将其覆盖。如果源文件是一个符号链接并且follow_symlinks为True，则会复制符号链接指向的文件而不是符号链接本身。

2. shutil.copy2(src, dst, *, follow_symlinks=True):
   类似于copy()方法，但是在复制文件时，会连同文件的元数据（如权限、时间戳等）一起复制到目标文件。

3. shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False):
   递归地复制整个文件夹从源路径src到目标路径dst。如果目标路径已存在，则会引发FileExistsError异常。可以通过设置symlinks为True来复制符号链接（默认为False）。可以通过设置ignore参数为一个函数来过滤需要复制的文件或文件夹。可以通过设置copy_function参数来指定复制文件的方法。

4. shutil.move(src, dst, copy_function=copy2):
   移动文件或文件夹从源路径src到目标路径dst。如果目标路径已存在同名文件或文件夹，则会引发FileExistsError异常。可以通过设置copy_function参数来指定在移动文件时使用的复制方法。

5. shutil.rmtree(path, ignore_errors=False, onerror=None):
   递归地删除整个文件夹，包括文件夹下的所有文件和文件夹。如果设置ignore_errors为True，则删除时会忽略错误。可以通过设置onerror参数为一个函数来处理删除过程中的错误。

6. shutil.make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=False, owner=None, group=None, logger=None):
   创建一个归档文件，可以选择不同的格式。base_name是归档文件名的前缀，format是归档文件的类型（如zip、tar等）。root_dir参数可以指定在归档文件中包含的根目录，默认为当前工作目录。base_dir参数可以指定在归档文件中包含的文件夹，默认为root_dir。

7. shutil.unpack_archive(filename, extract_dir=None, format=None):
   解包归档文件，将归档文件解压缩到指定的目录中。filename是归档文件的路径，extract_dir是解压缩的目标路径。format参数可以指定解包的格式，如果没有指定，则根据文件的后缀名自动选择。

shutil模块还提供了其他一些方法和常量，可以用于操作文件权限、文件名转换等。使用shutil模块可以方便地处理文件和文件夹的复制、移动和删除操作，提高了文件操作的效率和便捷性。

logging

Python的logging模块是Python中标准的日志记录工具，可以使用该模块在代码中添加日志记录，以便在程序运行时捕获和显示信息。logging模块提供了灵活且易于使用的接口，可以根据需要配置日志记录的级别、格式和目标。

logging模块包含了四个主要的组件：日志器（Logger）、处理器（Handler）、过滤器（Filter）和格式化器（Formatter）。

1. 日志器（Logger）：日志器是logging模块中的顶级接口，用于向应用程序代码暴露日志记录功能。通过创建和配置日志器，我们可以控制日志记录的级别、输出位置等。日志器通常使用名称进行标识，不同名称的日志器可以用于不同模块或功能的日志记录。

2. 处理器（Handler）：处理器是日志器的辅助组件，用于将日志消息发送到指定的目标。常见的处理器包括将日志消息输出到控制台、写入到文件、发送电子邮件等。可以根据需要创建不同的处理器，并将它们添加到日志器中。

3. 过滤器（Filter）：过滤器用于对日志消息进行筛选，只输出符合指定条件的日志消息。通过创建过滤器并将其添加到处理器或者日志器中，可以实现对日志消息的精确控制。

4. 格式化器（Formatter）：格式化器用于定义输出日志消息的格式。可以自定义格式化器的样式，例如日期时间格式、日志级别、日志消息等。

使用logging模块进行日志记录的基本步骤：

1. 导入logging模块：使用import语句导入logging模块。

2. 创建和配置日志器：使用logging.getLogger()方法创建一个日志器，并设置日志级别。

3. 创建和配置处理器：使用logging.handler()方法创建一个处理器，并设置日志级别和输出格式。

4. 创建和配置格式化器：使用logging.Formatter()方法创建一个格式化器，并设置输出格式。

5. 将处理器和格式化器添加到日志器中：使用日志器的addHandler()方法将处理器和格式化器添加到日志器中。

6. 在代码中添加日志记录：使用日志器的不同方法（例如debug()、info()、error()等）在代码中添加需要记录的日志信息。

7. 运行程序并观察日志输出：运行程序时，日志器会根据配置的级别和处理器将日志信息输出到指定的目标上。

Python的logging模块提供了一个灵活且易用的日志记录工具，便于输出和管理日志信息。通过配置日志器、处理器、过滤器和格式化器，可以根据需求对日志进行精确控制，调试和优化程序。

string

Python中的字符串是一种数据类型，用于存储和操作文本数据。在Python中，字符串是由一系列字符组成的，可以包含字母、数字、符号等字符。

1. 创建字符串：
   可以使用单引号或双引号来创建字符串。例如：

str1 = 'Hello World'
str2 = "Python is fun"

2. 字符串的索引和切片：
   可以使用索引来访问字符串中的单个字符，索引从0开始。例如，使用str[i]来访问第i个字符。还可以使用切片操作来获取字符串的子串，例如str[start:end]会返回从start位置到end位置之间的字符子串。

3. 字符串的拼接：
   可以使用加号（+）来拼接字符串。例如：

str1 = 'Hello'
str2 = 'World'
str3 = str1 + str2
print(str3)  # HelloWorld

4. 字符串的长度：
   可以使用len()函数来获取字符串的长度。例如：

str1 = 'Hello World'
print(len(str1))  # 11

5. 字符串的分割：
   可以使用split()函数将字符串按照指定的分隔符分割成多个子串。例如：

str1 = 'Hello World'
words = str1.split(' ')
print(words)  # ['Hello', 'World']

6. 字符串的替换：
   可以使用replace()函数将字符串中的指定字符或子串替换成新的字符或子串。例如：

str1 = 'Hello World'
new_str = str1.replace('World', 'Python')
print(new_str)  # Hello Python

7. 字符串的格式化：
   可以使用格式化操作符%来格式化字符串。例如：

name = 'John'
age = 25
print('My name is %s and I am %d years old' % (name, age))  # My name is John and I am 25 years old

collections

Python的collections模块是Python标准库中的一个模块，它提供了一些方便的数据结构，这些数据结构可以用来替代Python内置的数据结构，或者是对它们进行扩展。

collections模块中的一些常用数据结构包括：

1. namedtuple：namedtuple提供了一种创建具有命名字段的元组的方法。与普通元组不同的是，可以通过字段名来访问元组的元素，这样就不需要使用索引来访问。

2. deque：deque是一个双端队列，可以在队列的两端进行添加和删除操作。与列表相比，deque在插入和删除元素时速度更快，特别是在队列的开头进行操作时。

3. Counter：Counter是一个简单的计数器，用于统计可哈希对象的出现次数。它可以接收可迭代对象作为输入，并返回一个字典，其中键是对象，值是对象在可迭代对象中出现的次数。

4. OrderedDict：OrderedDict是一个有序的字典，它保持插入元素的顺序。与普通字典不同的是，OrderedDict可以按照插入元素的顺序进行迭代，这对于需要有序访问字典的场景非常有用。

5. defaultdict：defaultdict是一个字典的子类，它可以指定一个默认的值，当访问不存在的键时，返回指定的默认值。这样可以避免了判断键是否存在的烦恼。

collections模块还提供了其他一些数据结构，如ChainMap、Counter、UserDict等，使用collections模块可以提高代码的可读性和效率，避免了手动实现一些常用的数据结构和操作。

requests

Python的requests库是一个用于发送HTTP请求的第三方库。它提供了简单且易于使用的接口，使得发送HTTP请求变得非常方便。以下是对requests库的详细介绍：

1. 安装：可以在命令行中使用pip install requests命令来安装requests库。

2. 导入：在Python脚本中，使用import requests语句来导入requests库。

3. 发送GET请求：可以使用requests.get()函数来发送一个GET请求。例如，response = requests.get('https://api.github.com')将发送一个GET请求到https://api.github.com并将响应保存在变量response中。

4. 发送POST请求：可以使用requests.post()函数来发送一个POST请求。例如，response = requests.post('https://httpbin.org/post', data={'key': 'value'})将发送一个POST请求到https://httpbin.org/post，并将data参数中的数据作为请求体发送。

5. 设置请求头：可以使用headers参数来设置请求头。例如，headers = {'User-Agent': 'Mozilla/5.0'}将设置请求头中的User-Agent字段为Mozilla/5.0。

6. 获取响应内容：可以使用response.text属性来获取响应内容的文本形式。例如，content = response.text将获取响应内容的文本形式，并将其保存在变量content中。

7. 获取响应状态码：可以使用response.status_code属性来获取响应的状态码。例如，status_code = response.status_code将获取响应的状态码，并将其保存在变量status_code中。

8. 异常处理：可以使用try-except语句来处理异常。例如，以下代码将捕获所有requests库可能抛出的异常，并打印错误信息：

   try:
       response = requests.get('https://api.github.com')
   except requests.exceptions.RequestException as e:
       print(e)
   

使用requests库可以轻松发送HTTP请求，并方便地处理响应数据。

总结

本文所列举的库或者模块都是平时代码中比较常见的，属于基础知识，还有更多的用法我在文中没有赘述。平时多写写代码，留意这些tools的细节就好，需要的时候就拿来用。