Python标准库详细介绍_python标准库中文说明

前言

Python标准库非常庞大，所提供的组件涉及范围十分广泛，
本文将简单介绍标准库中常见的各种组件及其用途。

参考资料：Python 标准库

本文还在编写中，未完待续！！！

atexit – 退出处理器

允许注册在程序退出时调用的函数

atexit 模块定义了清理函数的注册和反注册函数。被注册的函数会在解释器正常终止时执行。atexit 会按照注册顺序的逆序执行; 如果你注册了 A, B 和 C, 那么在解释器终止时会依序执行 C, B, A.

中文文档：atexit–退出处理器

argparse – 命令行选项、参数和子命令解析器

提供解析命令行参数的函数

argparse 模块可以让人轻松编写用户友好的命令行接口。程序定义它需要的参数，然后 argparse 将弄清如何从 sys.argv 解析出那些参数。 argparse 模块还会自动生成帮助和使用手册，并在用户给程序传入无效参数时报出错误信息。

中文文档：argparse–命令行选项、参数和子命令解析器

bisect – 数组二分查找算法

为可排序列表提供二分查找算法

应用
用于数字表查询

import bisect

def grade(score):
    level = [60, 70, 80, 90]
    grades = 'FDCBA'
    return grades[bisect.bisect(level, score)]
1
2
3
4
5
6

调用

>>> grade(55)
F
>>> grade(90)
A
1
2
3
4

中文文档：bisect–数组二分查找算法

calendar – 日历相关函数

提供一组与日期相关的函数

调用样例

>>> import calendar
>>> c = calendar.Calendar()
>>> list(c.iterweekdays())  # 一星期的数字， 默认从0开始
[0, 1, 2, 3, 4, 5, 6]
>>> c = calendar.TextCalendar()  # 文本日历
>>> c.formatmonth(2020, 10)
 '    October 2020\nMo Tu We Th Fr Sa Su\n          1  2  3  4\n 5  6  7  8  9 10 11\n12 13 14 15 16 17 18\n19 20 21 22 23 24 25\n26 27 28 29 30 31\n'
>>> list(calendar.day_name)  # 在当前语言环境下表示星期几的数组
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
1
2
3
4
5
6
7
8
9

中文文档：calendar–日历相关函数

codecs – 编解码器注册和相关基类

提供编解码数据的函数

中文文档：codecs–编解码器注册和相关基类

collections – 容器数据类型

提供一组有用的数据结构

中文文档：collections–容器数据类型

• namedtuple
• deque
• ChainMap
• Counter
• OrderedDict
• defaultDict
• UserDict
• UserList
• UserString
• abc

namedtuple

创建命名元组子类的工厂函数

>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(5, 10)
>>> p.x
5
>>> p.y
10
>>> p._asdict()
{'x': 5, 'y': 10}
1
2
3
4
5
6
7
8

deque

类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)
返回一个新的双向队列对象，从左到右初始化

主要方法

• append
• appendleft
• clear
• index
• insert
• pop
• popleft
• maxlen
• rotate 向右循环移动 n 步。 如果 n 是负数，就向左循环

ChainMap

类似字典(dict)的容器类，将多个映射集合到一个视图里面
一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图

>>> A = {'a': 1, 'b': 2}
>>> B = {'c':３, 'b': 3}
>>> ChainMap(A, B)
ChainMap({'a': 1, 'b': 2}, {'c': 3, 'b': 3})
>>> ChainMap(A, B).get('b')
2
1
2
3
4
5
6

Counter

字典的子类，提供了可哈希对象的计数功能

>>> seq = ['a', 'b', 'a', 'c','b']
>>> Counter(seq)
Counter({'a': 2, 'b': 2, 'c': 1})
>>> Counter('asdas')
Counter({'a': 2, 's': 2, 'd': 1})
1
2
3
4
5

OrderedDict

字典的子类，保存了他们被添加的顺序
注意：python内置的dict类获得了记住插入顺序的能力（Python3.7中保证了这种新行为）

>>> d = OrderedDict({'a': 1, 'b': 2})
>>> d
OrderedDict([('a', 1), ('b', 2)])
>>> d.move_to_end('a')
>>> d
OrderedDict([('b', 2), ('a', 1)])

1
2
3
4
5
6
7

defaultDict

字典的子类，提供了一个工厂函数，为字典查询提供一个默认值

>>> d = defaultdict(list)
>>> d['a'].append(1)
defaultdict(list, {'a': [1]})
1
2
3

UserDict

封装了字典对象，简化了字典子类化

>>> d = UserDict({'a': 1, 'b': 2})
>>> d
{'a': 1, 'b': 2}
>>> d.data
{'a': 1, 'b': 2}
1
2
3
4
5

UserList

封装了列表对象，简化了列表子类化

>>> d = UserDict([0, 1, 2])
>>> d
[0, 1, 2]
>>> d.data
[0, 1, 2]
1
2
3
4
5

UserString

封装了列表对象，简化了字符串子类化

>>> d = UserString('hehe')
>>> d
'hehe'
>>> d.data
'hehe'
1
2
3
4
5

abc

collections.abc 该模块定义了一些抽象基类，它们可用于判断一个具体类是否具有某一特定的接口

>>> isinstance([], collections.abc.Sequence)
True
>>> isinstance(0, collections.abc.Sized)
False
1
2
3
4

copy – 浅层 (shallow) 和深层 (deep) 复制操作

提供复制数据的函数

中文文档：copy – 浅层 (shallow) 和深层 (deep) 复制操作

注意：Python中赋值语句不复制对象，而是在目标和对象之间创建绑定 (bindings) 关系

浅拷贝

copy.copy()

构造一个新的复合对象，然后（在可能的范围内）将原对象中找到的 引用 插入其中

浅拷贝实际只会复制数据最外一层对象，深层对象还是存在引用。

深拷贝

copy.deepcopy()

构造一个新的复合对象，然后递归地将原始对象中所找到的对象的 副本 插入

深拷贝会复制整个数据对象，深层对象均是副本而非引用

讨论

python对象拷贝时，请注意对可变对象的影响
例如，对Dict的拷贝，若字典的值为列表对象List

>>> import copy
>>> L = [1, 2]
2230332089736
>>> id(L)
>>> data = {'a': L}
>>> newdata = copy.copy(data)  # 浅拷贝
>>> id(data)
2230298554088
>>> id(newdata)
2230298551640
>>> id(data.get('a'))
2230332089736
>>> id(newdata.get('a'))  # 两个id相同
2230332089736
>>> dedata = copy.deepcopy(data)  # 深拷贝
>>> id(dedata.get('a'))  # 两个id不同
2230305026632
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

浅拷贝后，新的字典的列表对象为原来列表对象的引用(两个id相同)
此时，若修改新的列表对象newdata.get('a')，则实际修改的是L
深拷贝则不影响L

>>> newdata.get('a').append('copy')  # 同时会修改L
>>> newdata.get('a')
[1, 2, 'copy']
>>> L
[1, 2, 'copy']
>>> dedata.get('a').append('decopy')  # 不影响L
>>> dedata.get('a')
[1, 2, 'decopy']
>>> L
[1, 2, 'copy']
1
2
3
4
5
6
7
8
9
10

csv – CSV 文件读写

提供用于读写csv文件的函数

>>> import csv
>>> with open('eggs.csv', newline='') as csvfile:
...     spamreader = csv.reader(csvfile, delimiter=' ', quotechar='|')
...     for row in spamreader:
...         print(', '.join(row))
Spam, Spam, Spam, Spam, Spam, Baked Beans
Spam, Lovely Spam, Wonderful Spam
1
2
3
4
5
6
7

中文文档：csv–CSV 文件读写

datetime – 基本的日期和时间类型

提供用于处理日期和时间相关的函数

中文文档：datetime–基本的日期和时间类型

常见操作：

• 时间戳转iso

>>> times = 1605087051
>>> datetime.date.fromtimestamp(times).isoformat()
'2020-11-11'
1
2
3

• iso转时间戳

>>> times = '2020-11-11'
>>> datetime.datetime.strptime(times, '%Y-%m-%d').timestamp()
1602259200.0
1
2
3

timedelta

表示两个 date 对象或者 time 对象,或者 datetime 对象之间的时间间隔，精确到微秒。

可用于两个datetime对象的相加减运算

>>> d1 = datetime.timedelta(days=10)
>>> d1
datetime.timedelta(10)
>>> datetime.datetime(2020, 1, 1) + d1
datetime.datetime(2020, 1, 11, 0, 0)
1
2
3
4
5

date

初始化

>>> from datetime import date
>>> date(1994, 12, 31)
datetime.date(1994, 12, 31)
>>> date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)
>>> import time
>>> date.fromtimestamp(time.time())
datetime.date(2020, 11, 11)
1
2
3
4
5
6
7
8

datetime

datetime与date用法相近

>>> datetime.datetime.fromtimestamp(time.time())
datetime.datetime(2020, 11, 12, 14, 33, 5, 33660)
>>> str(datetime.datetime.fromtimestamp(time.time()))
'2020-11-12 14:35:15.213926'
1
2
3
4

fnmatch – Unix文件名模式匹配

此模块提供了 Unix shell 风格的通配符，它们并不等同于正则表达式

匹配规则

• * 匹配所有
• ？ 匹配任何单个字符
• [seq] 匹配 seq 中的任何字符
• [!seq] 匹配任何不在 seq 中的字符

>>> import fnmatch
>>> fnmatch.fnmatch('test.py', '*.py')
True
>>> fnmatch.fnmatch('test.py', '*.text')
False
1
2
3
4
5

中文文档：fnmatch–Unix 文件名模式匹配

functools – 高阶函数和可调用对象上的操作

functools 模块应用于高阶函数，即参数或（和）返回值为其他函数的函数。 通常来说，此模块的功能适用于所有可调用对象。

中文文档：functools–高阶函数和可调用对象上的操作

lru_cache

简单轻量级未绑定函数缓存

lru_cache一个为函数提供缓存功能的装饰器，缓存 maxsize 组传入参数，在下次以相同参数调用时直接返回上一次的结果。用以节约高开销或I/O函数的调用时间。
由于使用了字典存储缓存，所以该函数的固定参数和关键字参数必须是可哈希的。

>>> import functools
>>> @functools.lru_cache()
... def fac(n):
...     # 实现阶乘
...     print(n)
...     return n * fac(n-1) if n else 1
... 
>>>fac(3)  # 将会递归调用fac函数4次，结果为 6
3
2
1
0
6
>>> fac(4)  # 由于缓存，将会递归调用fac函数1次，结果为 24
4
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

不同模式的参数可能被视为不同从而产生多个缓存项；
例如, f(a=1, b=2) 和 f(b=2, a=1) 因其参数顺序不同，可能会被缓存两次。

cache

返回值与 lru_cache(maxsize=None) 相同，创建一个查找函数参数的字典的简单包装器。
因为它不需要移出旧值，所以比带有大小限制的 lru_cache() 更小更快。

注意：cache需python3.9版本以上才支持

total_ordering

给定一个声明一个或多个全比较排序方法的类，这个类装饰器实现剩余的方法。这减轻了指定所有可能的全比较操作的工作。

此类必须包含以下方法之一：__lt__() 、__le__()、__gt__() 或 __ge__()。另外，此类必须支持 __eq__() 方法。
因此只需要实现两个特殊方法，该类就能参与比较

@functools.total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def __eq__(self, other):
        return self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age
1
2
3
4
5
6
7
8
9
10
11

比较时

>>> p1 = Person(12, 'a')
>>> p2 = Person(23, 'b')
>>> p1 > p2
False
>>> p1 <= p2
True
1
2
3
4
5
6

虽然此装饰器使得创建具有良好行为的完全有序类型变得非常容易
但它确实是以执行速度更缓慢和派生比较方法的堆栈回溯更复杂为代价的。
如果性能基准测试表明这是特定应用的瓶颈所在，则改为实现全部六个富比较方法应该会轻松提升速度。

partial

偏函数，用于预先固定函数的某些参数

例如，在原有add函数基础上，快速便捷生成另外一个实现加1的add_one函数

>>> def add(x, y):
...     return x + y
... 
>>> add_one = functools.partial(add, 1)
>>> add_one(10)
11
1
2
3
4
5
6

partialmethod

用法同partial差不多，不过应用于类方法

例如

>>>	class Math:
...	    def add(self, x, y):
...	        return x + y
...	
...	    add_one = functools.partialmethod(add, 1)
...	    add_ten = functools.partialmethod(add, 10)
...
>>> m = Math()
>>> m.add(1, 2)
3
>>> m.add_one(1)
2
>>> m.add_ten(1)
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14

reduce

将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值

>>> functools.reduce(add, [3, 10, 22])
35
>>> functools.reduce(lambda x, y: x* y, [3, 10, 22])
660
1
2
3
4

结合partial 和reduce，可以实现类似sum函数的功能

>>> sum = functools.partial(functools.reduce, add)
>>> sum([1, 4, 6, 10])
21
1
2
3

singledispatch

将一个函数转换为单分派函数

使用时，先用 @singledispatch 装饰器进行装饰，再使用泛型函数的 register() 属性
在调用时，泛型函数会根据第一个参数的类型进行分派

>>> @functools.singledispatch
... def obj(value, show=False):
...     if show:
...         print('value:{}'.format(value))
>>> obj([1, 2, 3], show=True)
value:[1, 2, 3]
>>> @obj.register(list)  # 若value的类型为list，则调用本函数
... def _(value, show=True):
...     for i in value:
...         print('value:{}'.format(i))
>>>  obj([1, 2, 3])
value:1
value:2
value:3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

wraps

使一个 wrapper 函数更类似于 wrapped 函数，用于辅助生成装饰器

def print_func(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('function name:{}'.format(func.__name__))
        result = func(*args, **kwargs)
        print('get result:', result)
    return wrapper

@print_func
def add(x, y):
    return x + y
1
2
3
4
5
6
7
8
9
10
11

>>> add(1, 2)
function name:add
get result: 3
1
2
3

itertools – 为高效循环而创建迭代器的函数

该模块标准化了一个快速、高效利用内存的核心工具集，这些工具本身或组合都很有用。
它们一起形成了“迭代器代数”，这使得在纯Python中有可能创建简洁又高效的专用工具。

由于itertools工具集比较多，为避免文章过长，已单独写在另外一篇博文中
详情请点击 – > Python标准库详细介绍之itertools篇

io – 处理流的核心工具

处理I/O流的函数

中文文档：io–处理流的核心工具

json – JSON 编码和解码器

读写Json格式数据

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。
JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。
中文文档：json–JSON 编码和解码器

json.dumps

对基本的 Python 对象层次结构进行编码，将 obj 序列化为 JSON 格式的 str

>>> json.dumps({'a': 1, 'b': 0, 'c': 23})
'{"a": 1, "b": 0, "c": 23}'
>>> json.dumps({'bc': 1, 'c': 0, 'ad': 23}, sort_keys=True)  # 排序
'{"ad": 23, "bc": 1, "c": 0}'
>>> json.dumps({'bc': 1, 'c': 0, 'ad': {'key': 'v', 'do': 3}}, sort_keys=True, indent=4)  # 美化输出，indent=4为空4个空格
{
    "ad": {
        "do": 3,
        "key": "v"
    },
    "bc": 1,
    "c": 0
}
>>> json.dumps({'key': '中国'})
'{"key": "\\u4e2d\\u56fd"}'
>>> json.dumps({'key': '中国'}, ensure_ascii=False)  # 非ASCII字符转义
'{"key": "中国"}'
>>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))  # 紧凑编码
'[1,2,3,{"4":5,"6":7}]'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：JSON 中的键-值对中的键永远是 str 类型的。
当一个对象被转化为 JSON 时，字典中所有的键都会被强制转换为字符串。
这所造成的结果是字典被转换为 JSON 然后转换回字典时可能和原来的不相等。
换句话说，如果 x 具有非字符串的键，则有 loads(dumps(x)) != x

>>> obj = {3: '3'}  # type key: int
>>> json.loads(json.dumps(obj))
{'3': '3'}  # type key: str
>>> json.loads(json.dumps(obj)) == obj
False
1
2
3
4
5

json.loads

JSON对象解码

>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
['foo', {'bar': ['baz', None, 1.0, 2]}]
>>> json.loads('{"key": "\\u4e2d\\u56fd"}')
{'key': '中国'}
1
2
3
4

json.dump

将 obj 序列化为 JSON 格式化流形式的 fp，用法同json.dumps

>>> obj = {3: '3'}
>>> with open('test.json', 'w') as f:
...     json.dump(obj, f)
1
2
3

json.load

将 fp 反序列化为一个 Python 对象，用法同json.loads

logging

Python内置日志功能的函数

multiprocessing

处理多进程

operator

实现基本的Python运算符功能的函数

os

对基本的操作系统函数的访问

random

提供生成伪随机数的函数

re

正则表达式功能

select

提供对函数select()和poll()的访问，用于创建事件的循环

shutil

对高级文件处理函数的访问

signal

处理POSIX信号的函数

tempfile

创建临时文件和目录的函数

urllib

处理和解析URL的函数

uuid

生成全局唯一的标志符