Python标准库详细介绍

文章目录

• 前言
• atexit -- 退出处理器
• argparse -- 命令行选项、参数和子命令解析器
• bisect -- 数组二分查找算法
• calendar -- 日历相关函数
• codecs -- 编解码器注册和相关基类
• collections -- 容器数据类型
• copy -- 浅层 (shallow) 和深层 (deep) 复制操作
• csv -- CSV 文件读写
• datetime -- 基本的日期和时间类型
• fnmatch -- Unix文件名模式匹配
• functools -- 高阶函数和可调用对象上的操作
• glob
• io
• itertools
• json
• logging
• multiprocessing
• operator
• os
• random
• re
• select
• shutil
• signal
• tempfile
• urllib
• uuid

前言

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)]

调用

>>> grade(55)
F
>>> grade(90)
A

中文文档：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']

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

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

提供编解码数据的函数

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

collections – 容器数据类型

提供一组有用的数据结构

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

namedtuple

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

>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(5, 10)
>>> p.x
5
>>> p.y
10
>>> p._asdict()
{'x': 5, 'y': 10}

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

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})

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)])

defaultDict

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

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

UserDict

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

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

UserList

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

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

UserString

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

>>> d = UserString('hehe')
>>> d
'hehe'
>>> d.data
'hehe'

abc

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

>>> isinstance([], collections.abc.Sequence)
True
>>> isinstance(0, collections.abc.Sized)
False

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

浅拷贝后，新的字典的列表对象为原来列表对象的引用(两个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']

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

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

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

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

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

常见操作：

• 时间戳转iso

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

• iso转时间戳

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

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)

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)

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'

fnmatch – Unix文件名模式匹配

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

匹配规则

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

>>> import fnmatch
>>> fnmatch.fnmatch('test.py', '*.py')
True
>>> fnmatch.fnmatch('test.py', '*.text')
False

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

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

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

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

lru_cache

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

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

>>> @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

不同模式的参数可能被视为不同从而产生多个缓存项；
例如, 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

比较时

>>> p1 = Person(12, 'a')
>>> p2 = Person(23, 'b')
>>> p1 > p2
False
>>> p1 <= p2
True

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

partial

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

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

>>> def add(x, y):
...     return x + y
... 
>>> add_one = functools.partial(add, 1)
>>> add_one(10)
11

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

reduce

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

glob

匹配Unix风格路径模式的函数

io

处理I/O流的函数

itertools

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

json

读写Json格式数据

logging

Python内置日志功能的函数

multiprocessing

处理多进程

operator

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

os

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

random

提供生成伪随机数的函数

re

正则表达式功能

select

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

shutil

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

signal

处理POSIX信号的函数

tempfile

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

urllib

处理和解析URL的函数

uuid

生成全局唯一的标志符

本文地址：https://blog.csdn.net/qq_42988351/article/details/109614493