25、Python标准库与内置函数全解析

Python标准库与内置函数全解析

1. 标准库模块介绍

1.1 struct模块

struct模块用于在Python和二进制数据结构（以Python字节字符串表示）之间进行数据转换。这些数据结构常用于与用C编写的函数、二进制文件格式、网络协议或串口的二进制通信交互。

例如，要构建一个由C数据结构描述格式的二进制消息：

# Message format: All values are "big endian"
# struct Message {
#     unsigned short msgid;  // 16 bit unsigned integer
#     unsigned int sequence; // 32 bit sequence number
#     float x;               // 32 bit float
#     float y;               // 32 bit float
# }

import struct
data = struct.pack('>HIff', 123, 456, 1.23, 4.56)
print(data)
# 输出: b'\x00{\x00\x00\x00-?\x9dp\xa4@\x91\xeb\x85'

# 解码二进制数据
result = struct.unpack('>HIff', data)
print(result)
# 输出: (123, 456, 1.2300000190734863, 4.559999942779541)

浮点值的差异是由于转换为32位值时精度损失造成的，Python将浮点值表示为64位双精度值。

1.2 subprocess模块

subprocess模块用于将一个单独的程序作为子进程执行，并可控制执行环境，包括I/O处理、终止等。该模块有两种常见用法：

1.2.1 一次性收集程序输出

使用 check_output() 函数，示例如下：

import subprocess
try:
    out = subprocess.check_output(['netstat', '-a'])
    text = out.decode('utf-8')
    print(text)
except subprocess.CalledProcessError as e:
    print("It failed:", e)

1.2.2 详细交互子进程

使用 Popen 类，示例如下：

import subprocess
p = subprocess.Popen(['wc'],
                     stdin=subprocess.PIPE,
                     stdout=subprocess.PIPE)
p.stdin.write(b'hello world\nthis is a test\n')
p.stdin.close()
out = p.stdout.read()
print(out)

Popen 实例 p 有 stdin 和 stdout 属性，可用于与子进程通信。

1.3 tempfile模块

tempfile模块支持创建临时文件和目录。

1.3.1 创建临时文件

import tempfile
with tempfile.TemporaryFile() as f:
    f.write(b'Hello World')
    f.seek(0)
    data = f.read()
    print('Got:', data)

默认情况下，临时文件以二进制模式打开，允许读写。使用 with 语句定义文件使用范围，文件在 with 块结束时会被删除。

1.3.2 创建临时目录

import tempfile
with tempfile.TemporaryDirectory() as dirname:
    # 使用目录dirname
    pass

与文件类似，目录及其所有内容在 with 块结束时会被删除。

1.4 textwrap模块

textwrap模块可用于格式化文本以适应特定的终端宽度，在制作报告时清理文本输出有时会很有用。有两个有用的函数：

1.4.1 wrap()函数

将文本包装以适应指定的列宽，返回字符串列表。

import textwrap
text = """look into my eyes
look into my eyes
the eyes the eyes the eyes
not around the eyes
don't look around the eyes
look into my eyes you're under
"""
wrapped = textwrap.wrap(text, width=81)
print('\n'.join(wrapped))

1.4.2 indent()函数

用于缩进一段文本。

print(textwrap.indent(text, '  '))

1.5 threading模块

threading模块用于并发执行代码，常用于网络程序的I/O处理。以下是一些常见问题的解决方案示例：

1.5.1 启动线程并等待

import threading
import time

def countdown(n):
    while n > 0:
        print('T-minus', n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=countdown, args=[10])
t.start()
t.join()

1.5.2 创建守护线程

t = threading.Thread(target=countdown, args=[10], daemon=True)
t.start()

1.5.3 终止线程

需要使用标志或专用变量，并在线程中进行检查。

import threading
import time

must_stop = False

def countdown(n):
    while n > 0 and not must_stop:
        print('T-minus', n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=countdown, args=[10])
t.start()
# 一段时间后设置标志以终止线程
time.sleep(5)
must_stop = True

1.5.4 保护共享数据

使用 Lock 保护线程要修改的共享数据。

import threading

class Counter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()

    def increment(self):
        with self.lock:
            self.value += 1

    def decrement(self):
        with self.lock:
            self.value -= 1

1.5.5 线程间等待

使用 Event 让一个线程等待另一个线程完成某事。

import threading
import time

def step1(evt):
    print('Step 1')
    time.sleep(5)
    evt.set()

def step2(evt):
    evt.wait()
    print('Step 2')

evt = threading.Event()
threading.Thread(target=step1, args=[evt]).start()
threading.Thread(target=step2, args=[evt]).start()

1.5.6 线程间通信

使用 Queue 进行线程间通信。

import threading
import queue
import time

def producer(q):
    for i in range(10):
        print('Producing:', i)
        q.put(i)
    print('Done')
    q.put(None)

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print('Consuming:', item)
    print('Goodbye')

q = queue.Queue()
threading.Thread(target=producer, args=[q]).start()
threading.Thread(target=consumer, args=[q]).start()

1.6 time模块

time模块用于访问与系统时间相关的函数，以下是一些最有用的函数：
| 函数 | 描述 |
| — | — |
| sleep(seconds) | 使Python休眠指定的秒数（浮点数） |
| time() | 返回当前系统时间（UTC）的浮点数，即自纪元（通常是UNIX系统的1970年1月1日）以来的秒数 |
| localtime([secs]) | 返回表示系统本地时间或由参数 secs 表示的时间的 struct_time 对象 |
| gmtime([secs]) | 与 localtime() 类似，但返回的结构表示UTC时间 |
| ctime([secs]) | 将秒数表示的时间转换为适合打印的文本字符串 |
| asctime(tm) | 将 localtime() 表示的时间结构转换为适合打印的文本字符串 |

1.7 urllib包

urllib包用于进行客户端HTTP请求，最有用的函数是 urllib.request.urlopen() ，可用于获取简单网页。

1.7.1 获取网页

from urllib.request import urlopen
u = urlopen('http://www.python.org')
data = u.read()
print(data)

1.7.2 编码表单参数

from urllib.parse import urlencode
from urllib.request import urlopen

form = {
    'name': 'Mary A. Python',
    'email': 'mary123@python.org'
}
data = urlencode(form)
u = urlopen('http://httpbin.org/post', data.encode('utf-8'))
response = u.read()
print(response)

urlopen() 函数适用于基本网页和涉及HTTP或HTTPS的API，但在处理涉及cookie、高级认证方案等情况时会变得很麻烦，建议使用第三方库如 requests 或 httpx 。

1.7.3 操作URL

urllib.parse 子包有操作URL的附加函数，例如 urlparse() 可拆分URL。

url = 'http://httpbin.org/get?name=Dave&n=42'
from urllib.parse import urlparse
result = urlparse(url)
print(result)

1.8 unicodedata模块

unicodedata模块用于处理涉及Unicode文本字符串的更高级操作。同一Unicode文本通常有多种表示形式，可能会导致程序出现问题。

1.8.1 示例问题

d = {}
d['Jalape\xf1o'] = 'spicy'
d['Jalapen\u0303o'] = 'mild'
print(d)

这里字典出现了两个看起来相同但实际由不同Unicode字符序列组成的键。

1.8.2 规范化Unicode字符串

使用 unicodedata.normalize() 函数确保一致的字符表示。

import unicodedata
s = 'Jalapeño'
normalized_nfc = unicodedata.normalize('NFC', s)
normalized_nfd = unicodedata.normalize('NFD', s)

1.8.3 测试字符属性

使用 unicodedata.category(c) 函数获取字符的一般属性。

import unicodedata
print(unicodedata.category('A'))  # 输出: 'Lu'

1.9 xml包

xml包是用于以各种方式处理XML数据的模块集合。如果主要目标是读取XML文档并提取信息，最简单的方法是使用 xml.etree 子包。

1.9.1 示例XML文档

<?xml version="1.0" encoding="iso-8859-1"?>
<recipe>
    <title>Famous Guacamole</title>
    <description>A southwest favorite!</description>
    <ingredients>
        <item num="4"> Large avocados, chopped </item>
        <item num="1"> Tomato, chopped </item>
        <item num="1/2" units="C"> White onion, chopped </item>
        <item num="2" units="tbl"> Fresh squeezed lemon juice </item>
        <item num="1"> Jalapeno pepper, diced </item>
        <item num="1" units="tbl"> Fresh cilantro, minced </item>
        <item num="1" units="tbl"> Garlic, minced </item>
        <item num="3" units="tsp"> Salt </item>
        <item num="12" units="bottles"> Ice-cold beer </item>
    </ingredients>
    <directions>
        Combine all ingredients and hand whisk to desired consistency.
        Serve and enjoy with ice-cold beers.
    </directions>
</recipe>

1.9.2 提取特定元素

from xml.etree.ElementTree import ElementTree
doc = ElementTree(file="recipe.xml")
title = doc.find('title')
print(title.text)
print(doc.findtext('description'))
for item in doc.findall('ingredients/item'):
    num = item.get('num')
    units = item.get('units', '')
    text = item.text.strip()
    print(f'{num} {units} {text}')

2. 内置函数介绍

2.1 常见内置函数

Python 有许多内置函数，这些函数无需导入即可使用。以下是一些常见内置函数的介绍：
| 函数 | 描述 |
| — | — |
| abs(x) | 返回 x 的绝对值 |
| all(s) | 如果可迭代对象 s 中的所有值都为真，则返回 True；如果 s 为空，也返回 True |
| any(s) | 如果可迭代对象 s 中的任何一个值为真，则返回 True；如果 s 为空，返回 False |
| ascii(x) | 创建对象 x 的可打印表示，只使用 ASCII 字符，非 ASCII 字符会转换为适当的转义序列 |
| bin(x) | 返回整数 x 的二进制表示字符串 |
| bool([x]) | 表示布尔值 True 和 False 的类型。如果用于转换 x，根据通常的真值测试语义，若 x 为真则返回 True，否则返回 False。默认值为 False。布尔值 True 和 False 可在数学计算中作为整数 1 和 0 使用 |
| breakpoint() | 设置手动调试断点，遇到时控制将转移到 Python 调试器 pdb |
| bytearray([x]) | 表示可变字节数组的类型。创建实例时，x 可以是 0 到 255 范围内的整数可迭代序列、8 位字符串或字节字面量，也可以是指定字节数组大小的整数（此时每个条目初始化为 0） |
| bytearray(s, encoding) | 从字符串 s 中的字符创建 bytearray 实例的另一种调用方式，encoding 指定转换时使用的字符编码 |
| bytes([x]) | 表示不可变字节数组的类型 |
| bytes(s, encoding) | 从字符串 s 创建字节的另一种调用方式，encoding 指定转换时使用的编码 |

2.2 bytes 和 bytearray 的操作

bytes 和 bytearray 支持一些常见操作，如下表所示：
| 操作 | 描述 |
| — | — |
| s + t | 如果 t 是 bytes，则进行拼接 |
| s * n | 如果 n 是整数，则进行复制 |
| s % x | 格式化字节，x 是元组 |
| s[i] | 返回元素 i 作为整数 |
| s[i:j] | 返回切片 |
| s[i:j:stride] | 返回扩展切片 |
| len(s) | s 中的字节数 |
| s.capitalize() | 大写第一个字符 |
| s.center(width [, pad]) | 将字符串 s 在长度为 width 的字段中居中，pad 是填充字符 |
| s.count(sub [, start [, end]]) | 计算指定子字符串 sub 的出现次数 |
| s.decode([encoding [, errors]]) | 将字节字符串解码为文本（仅适用于 bytes 类型） |
| s.endswith(suffix [, start [, end]]) | 检查字符串末尾是否有后缀 |
| s.expandtabs([tabsize]) | 用空格替换制表符 |
| s.find(sub [, start [, end]]) | 查找指定子字符串 sub 的第一次出现位置 |
| s.hex() | 转换为十六进制字符串 |
| s.index(sub [, start [, end]]) | 查找指定子字符串 sub 的第一次出现位置，如果未找到则报错 |
| s.isalnum() | 检查所有字符是否为字母数字 |
| s.isalpha() | 检查所有字符是否为字母 |
| s.isascii() | 检查所有字符是否为 ASCII 字符 |
| s.isdigit() | 检查所有字符是否为数字 |
| s.islower() | 检查所有字符是否为小写 |
| s.isspace() | 检查所有字符是否为空白字符 |
| s.istitle() | 检查字符串是否为标题大小写（每个单词的首字母大写） |
| s.isupper() | 检查所有字符是否为大写 |
| s.join(t) | 使用分隔符 s 连接字符串序列 t |
| s.ljust(width [, fill]) | 将 s 在大小为 width 的字符串中左对齐 |
| s.lower() | 转换为小写 |
| s.lstrip([chrs]) | 移除前导空白字符或 chrs 中提供的字符 |
| s.maketrans(x [, y [, z]]) | 为 s.translate() 创建翻译表 |
| s.partition(sep) | 根据分隔符字符串 sep 分割字符串，返回元组 (head, sep, tail)；如果未找到 sep，则返回 (s, ‘’, ‘’) |
| s.removeprefix(prefix) | 如果存在，返回移除给定前缀后的 s |
| s.removesuffix(suffix) | 如果存在，返回移除给定后缀后的 s |
| s.replace(old, new [, maxreplace]) | 替换子字符串 |
| s.rfind(sub [, start [, end]]) | 查找子字符串的最后一次出现位置 |
| s.rindex(sub [, start [, end]]) | 查找子字符串的最后一次出现位置，如果未找到则报错 |
| s.rjust(width [, fill]) | 将 s 在长度为 width 的字符串中右对齐 |
| s.rpartition(sep) | 根据分隔符 sep 分割 s，但从字符串末尾开始搜索 |
| s.rsplit([sep [, maxsplit]]) | 从字符串末尾开始使用 sep 作为分隔符分割字符串，maxsplit 指定最大分割次数。如果省略 maxsplit，结果与 split() 方法相同 |
| s.rstrip([chrs]) | 移除尾随空白字符或 chrs 中提供的字符 |
| s.split([sep [, maxsplit]]) | 使用 sep 作为分隔符分割字符串，maxsplit 指定最大分割次数 |
| s.splitlines([keepends]) | 将字符串分割成行列表。如果 keepends 为 1，保留尾随换行符 |
| s.startswith(prefix [, start [, end]]) | 检查字符串是否以 prefix 开头 |
| s.strip([chrs]) | 移除前导和尾随空白字符或 chrs 中提供的字符 |
| s.swapcase() | 大写转小写，小写转大写 |
| s.title() | 返回字符串的标题大小写版本 |
| s.translate(table [, deletechars]) | 使用字符翻译表 table 翻译字符串，移除 deletechars 中的字符 |
| s.upper() | 转换为大写 |
| s.zfill(width) | 在字符串左侧用零填充到指定宽度 |

2.3 bytearray 的额外操作

bytearray 除了支持上述 bytes 的操作外，还支持以下额外操作：
| 操作 | 描述 |
| — | — |
| s[i] = v | 项赋值 |
| s[i:j] = t | 切片赋值 |
| s[i:j:stride] = t | 扩展切片赋值 |
| del s[i] | 项删除 |
| del s[i:j] | 切片删除 |
| del s[i:j:stride] | 扩展切片删除 |
| s.append(x) | 在末尾追加新字节 |
| s.clear() | 清空字节数组 |
| s.copy() | 复制字节数组 |
| s.extend(t) | 用 t 中的字节扩展 s |
| s.insert(n, x) | 在索引 n 处插入字节 x |
| s.pop([n]) | 移除并返回索引 n 处的字节 |
| s.remove(x) | 移除字节 x 的第一次出现 |
| s.reverse() | 原地反转字节数组 |

2.4 其他内置函数

还有许多其他有用的内置函数，以下是部分函数的介绍和示例：

2.4.1 callable(obj)

返回 obj 是否可作为函数调用。

def func():
    pass

print(callable(func))  # 输出: True

2.4.2 chr(x)

将表示 Unicode 码点的整数 x 转换为单字符字符串。

print(chr(65))  # 输出: 'A'

2.4.3 classmethod(func)

创建函数 func 的类方法，通常在类定义内部使用 @classmethod 装饰器隐式调用。类方法接收类作为第一个参数，而不是实例。

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"Called class method of {cls.__name__}")

MyClass.class_method()

2.4.4 compile(string, filename, kind)

将字符串编译为代码对象，用于 exec() 或 eval() 。string 是包含有效 Python 代码的字符串，filename 是定义该字符串的文件名（可选），kind 可以是 ‘exec’（用于语句序列）、’eval’（用于单个表达式）或 ‘single’（用于单个可执行语句）。

code = compile("print('Hello, World!')", "<string>", "exec")
exec(code)

2.4.5 complex([real [, imag]])

表示复数的类型，具有实部和虚部 real 和 imag，可以是任何数字类型。如果省略 imag，虚部设置为零；如果 real 是字符串，则解析并转换为复数，此时应省略 imag。如果没有参数，返回 0j。

c = complex(3, 4)
print(c)  # 输出: (3+4j)

2.4.6 delattr(object, attr)

删除对象的属性，attr 是字符串，等同于 del object.attr 。

class MyClass:
    def __init__(self):
        self.value = 10

obj = MyClass()
delattr(obj, 'value')

2.4.7 dict([m]) or dict(key1=value1, key2=value2, ...)

表示字典的类型。如果没有参数，返回空字典；如果 m 是映射对象（如另一个字典），返回具有相同键和值的新字典；如果 m 不是映射对象，它必须支持迭代，生成 (key, value) 对来填充字典。也可以使用关键字参数调用。

d1 = dict()
d2 = dict({'a': 1, 'b': 2})
d3 = dict(a=1, b=2)

2.4.8 dir([object])

返回属性名的排序列表。如果 object 是模块，包含该模块中定义的符号列表；如果 object 是类型或类对象，返回属性名列表。通常从对象的 __dict__ 属性获取名称，但也可能使用其他来源。如果没有参数，返回当前局部符号表中的名称。该函数主要用于信息目的，不应用于正式的程序分析。

print(dir(list))

2.4.9 divmod(a, b)

返回长除法的商和余数的元组。对于整数，返回 (a // b, a % b) ；对于浮点数，返回 (math.floor(a / b), a % b) 。不能用于复数。

print(divmod(10, 3))  # 输出: (3, 1)

2.4.10 enumerate(iter, start=0)

给定可迭代对象 iter，返回一个新的迭代器（类型为 enumerate），生成包含计数和 iter 产生的值的元组。可选的 start 改变计数的初始值。

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)

2.4.11 eval(expr [, globals [, locals]])

计算表达式的值。expr 可以是字符串或由 compile() 创建的代码对象，globals 和 locals 分别定义操作的全局和局部命名空间。如果省略，使用调用者环境中的 globals() 和 locals() 值。

result = eval("2 + 3")
print(result)  # 输出: 5

2.4.12 exec(code [, globals [, locals]])

执行 Python 语句。code 可以是字符串、字节或由 compile() 创建的代码对象，globals 和 locals 分别定义操作的全局和局部命名空间。如果省略，使用调用者环境中的 globals() 和 locals() 值。

exec("x = 10; print(x)")

2.4.13 filter(function, iterable)

创建一个迭代器，返回可迭代对象中使 function(item) 为真的项。

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出: [2, 4]

2.4.14 float([x])

表示浮点数的类型。如果 x 是数字，转换为浮点数；如果 x 是字符串，解析为浮点数；对于其他对象，调用 x.__float__() 。如果没有参数，返回 0.0。

f = float(3)
print(f)  # 输出: 3.0

2.4.15 format(value [, format_spec])

根据格式规范字符串 format_spec 将 value 转换为格式化字符串。对于简单数据类型，格式说明符通常包括对齐字符 ‘<’、’>’ 或 ‘^’、表示字段宽度的数字以及分别用于整数、浮点数或字符串值的字符代码 ‘d’、’f’ 或 ‘s’。

num = 123
formatted = format(num, '8d')
print(formatted)  # 输出: '    123'

2.4.16 frozenset([items])

表示不可变集合对象的类型，用 items 中的值填充，items 必须是可迭代的，且值必须是不可变的。如果没有参数，返回空集合。frozenset 支持集合的所有操作，但不支持原地修改集合的操作。

fs = frozenset([1, 2, 3])
print(fs)

2.4.17 getattr(object, name [, default])

返回对象的命名属性的值，name 是包含属性名的字符串，default 是可选值，如果属性不存在则返回该值，否则抛出 AttributeError。等同于访问 object.name 。

class MyClass:
    def __init__(self):
        self.value = 10

obj = MyClass()
attr_value = getattr(obj, 'value')
print(attr_value)  # 输出: 10

2.4.18 globals()

返回当前模块的字典，表示全局命名空间。在另一个函数或方法内部调用时，返回定义该函数或方法的模块的全局命名空间。

print(globals())

2.4.19 hasattr(object, name)

如果 name 是对象的属性名，则返回 True，name 是字符串。

class MyClass:
    def __init__(self):
        self.value = 10

obj = MyClass()
print(hasattr(obj, 'value'))  # 输出: True

2.4.20 hash(object)

返回对象的整数哈希值（如果可能）。哈希值主要用于字典、集合和其他映射对象的实现。相等的对象哈希值总是相同。可变对象通常不定义哈希值，但用户定义的类可以定义 __hash__() 方法来支持此操作。

s = 'hello'
print(hash(s))

2.4.21 hex(x)

将整数 x 转换为十六进制字符串。

print(hex(255))  # 输出: '0xff'

2.4.22 id(object)

返回对象的唯一整数标识，不应该以任何方式解释返回值（例如，它不是内存位置）。

a = [1, 2, 3]
print(id(a))

2.4.23 input([prompt])

将提示信息打印到标准输出，并从标准输入读取一行输入，返回的行不做任何修改，不包括行结束符（如 ‘\n’）。

user_input = input("Please enter something: ")
print(user_input)

2.4.24 int(x [, base])

表示整数的类型。如果 x 是数字，通过向 0 截断转换为整数；如果是字符串，解析为整数值。base 可选地指定从字符串转换时的基数。

i = int('10', 2)
print(i)  # 输出: 2

2.4.25 isinstance(object, classobj)

如果对象是 classobj 或其派生类的实例，则返回 True。classobj 参数也可以是可能的类型或类的元组。

lst = [1, 2, 3]
print(isinstance(lst, list))  # 输出: True

2.4.26 issubclass(class1, class2)

如果 class1 是 class2 的子类（派生自 class2），则返回 True。class2 也可以是可能的类的元组，此时会检查每个类。注意 issubclass(A, A) 为 True。

class A:
    pass

class B(A):
    pass

print(issubclass(B, A))  # 输出: True

2.4.27 iter(object [, sentinel])

返回用于生成对象中项的迭代器。如果省略 sentinel 参数，对象必须提供 __iter__() 方法来创建迭代器，或者实现 __getitem__() 方法，接受从 0 开始的整数参数。如果指定了 sentinel，对象应是无参数的可调用对象，返回的迭代器对象会反复调用该函数，直到返回的值等于 sentinel，此时迭代停止。如果对象不支持迭代，会生成 TypeError。

lst = [1, 2, 3]
it = iter(lst)
print(next(it))  # 输出: 1

2.4.28 len(s)

返回容器 s 中包含的项数，s 可以是列表、元组、字符串、集合或字典等。

lst = [1, 2, 3]
print(len(lst))  # 输出: 3

2.4.29 list([items])

表示列表的类型，items 可以是任何可迭代对象，其值用于填充列表。如果 items 已经是列表，则进行浅拷贝。如果没有参数，返回空列表。

lst = list([1, 2, 3])
print(lst)

2.4.30 locals()

返回调用者的局部命名空间对应的字典，该字典仅用于检查执行环境，对字典所做的更改不会影响相应的局部变量。

def my_function():
    x = 10
    print(locals())

my_function()

2.4.31 map(function, items, ...)

创建一个迭代器，生成将 function 应用于 items 中项的结果。如果提供多个输入序列，function 应接受相应数量的参数，每个参数从不同序列中获取。此时，结果的长度与最短的输入序列相同。

numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))  # 输出: [1, 4, 9]

2.4.32 max(s [, args, ...], *, default=obj, key=func)

对于单个参数 s，返回 s 中项的最大值，s 可以是任何可迭代对象；对于多个参数，返回最大的参数。如果提供关键字参数 default，则在 s 为空时返回该值；如果提供关键字参数 key，则返回使 key(v) 返回最大值的 v。

lst = [1, 2, 3]
max_value = max(lst)
print(max_value)  # 输出: 3

2.4.33 min(s [, args, ...], *, default=obj, key=func)

与 max(s) 类似，但返回最小值。

lst = [1, 2, 3]
min_value = min(lst)
print(min_value)  # 输出: 1

2.4.34 next(s [, default])

返回迭代器 s 中的下一项。如果迭代器没有更多项，会抛出 StopIteration 异常，除非提供了 default 参数，此时返回 default。

lst = [1, 2, 3]
it = iter(lst)
print(next(it))  # 输出: 1

2.4.35 object()

Python 中所有对象的基类，可以调用它创建实例，但结果没有特别的意义。

obj = object()
print(obj)

2.4.36 oct(x)

将整数 x 转换为八进制字符串。

print(oct(8))  # 输出: '0o10'

2.4.37 open(filename [, mode [, bufsize [, encoding [, errors [, newline [, closefd]]]]]])

打开文件 filename 并返回文件对象，参数在相关文档中有详细描述。

with open('test.txt', 'w') as f:
    f.write('Hello, World!')

2.4.38 ord(c)

返回单个字符 c 的整数序号值，通常对应字符的 Unicode 码点值。

print(ord('A'))  # 输出: 65

2.4.39 pow(x, y [, z])

返回 x 的 y 次幂。如果提供 z，则返回 (x ** y) % z 。如果三个参数都提供，它们必须是整数，且 y 必须是非负的。

result = pow(2, 3)
print(result)  # 输出: 8

2.4.40 print(value, ... , *, sep=separator, end=ending, file=outfile)

打印一组值。可以提供任意数量的输入值，所有值打印在同一行。关键字参数 sep 指定不同的分隔符（默认为空格），end 指定不同的行结束符（默认为 ‘\n’），file 指定输出文件对象。

print('Hello', 'World', sep=', ', end='!\n')

2.4.41 property([fget [, fset [, fdel [, doc]]]])

为类创建属性。fget 是返回属性值的函数，fset 是设置属性值的函数，fdel 是删除属性的函数，doc 是文档字符串。属性通常使用装饰器指定。

class MyClass:
    def __init__(self):
        self._value = 0

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

obj = MyClass()
obj.value = 10
print(obj.value)  # 输出: 10

2.4.42 range([start,] stop [, step])

创建一个表示从 start 到 stop 的整数范围的 range 对象，step 表示步长，默认为 1。如果省略 start（当使用一个参数调用时），默认值为 0。负步长会创建降序数字列表。

for i in range(1, 5):
    print(i)

2.4.43 repr(object)

返回对象的字符串表示，在大多数情况下，返回的字符串是可以传递给 eval() 以重新创建对象的表达式。

lst = [1, 2, 3]
print(repr(lst))  # 输出: '[1, 2, 3]'

2.4.44 reversed(s)

创建序列 s 的反向迭代器，该函数仅在 s 定义了 __reversed__() 方法或实现了序列方法 __len__() 和 __getitem__() 时有效，不适用于生成器。

lst = [1, 2, 3]
reversed_lst = reversed(lst)
print(list(reversed_lst))  # 输出: [3, 2, 1]

2.4.45 round(x [, n])

将浮点数 x 四舍五入到最接近的 10 的 -n 次幂的倍数。如果省略 n，默认值为 0。如果两个倍数同样接近，当前一位数字为偶数时向 0 舍入，否则远离 0 舍入。

print(round(1.5))  # 输出: 2

2.4.46 set([items])

创建一个用 items 中的值填充的集合，items 必须是可迭代的，且值必须是不可变的。如果 items 包含其他集合，这些集合必须是 frozenset 类型。如果省略 items，返回空集合。

s = set([1, 2, 3])
print(s)

2.4.47 setattr(object, name, value)

设置对象的属性，name 是字符串，等同于 object.name = value 。

class MyClass:
    def __init__(self):
        self.value = 0

obj = MyClass()
setattr(obj, 'value', 10)
print(obj.value)  # 输出: 10

2.4.48 slice([start,] stop [, step])

返回表示指定范围内整数的切片对象，切片对象也可以通过扩展切片语法 a[i:i:k] 生成。

s = slice(1, 3)
lst = [1, 2, 3, 4]
print(lst[s])  # 输出: [2, 3]

2.4.49 sorted(iterable, *, key=keyfunc, reverse=reverseflag)

从可迭代对象中的项创建一个排序列表。关键字参数 key 是一个单参数函数，用于在比较值之前转换值；关键字参数 reverse 是一个布尔标志，指定结果列表是否按降序排序。

lst = [3, 1, 2]
sorted_lst = sorted(lst)
print(sorted_lst)  # 输出: [1, 2, 3]

2.4.50 staticmethod(func)

创建用于类的静态方法，通常使用 @staticmethod 装饰器。

class MyClass:
    @staticmethod
    def static_method():
        print("Called static method")

MyClass.static_method()

2.4.51 str([object])

表示字符串的类型。如果提供 object，通过调用其 __str__() 方法创建其值的字符串表示，这与打印对象时看到的字符串相同。如果没有参数，创建空字符串。

num = 123
str_num = str(num)
print(str_num)  # 输出: '123'

2.4.52 sum(items [, initial])

计算可迭代对象 items 中项的总和，initial 提供起始值，默认为 0。该函数通常仅适用于数字。

lst = [1, 2, 3]
total = sum(lst)
print(total)  # 输出: 6

2.4.53 super()

返回表示使用该函数的类的所有超类的对象，主要用于调用基类中的方法。

class A:
    def foo(self):
        print("A's foo method")

class B(A):
    def foo(self):
        super().foo()
        print("B's foo method")

b = B()
b.foo()

2.4.54 tuple([items])

表示元组的类型。如果提供 items，它是用于填充元组的可迭代对象。如果 items 已经是元组，则直接返回。如果没有参数，返回空元组。

t = tuple([1, 2, 3])
print(t)

2.4.55 type(object)

Python 中所有类型的基类，作为函数调用时，返回对象的类型，该类型与对象的类相同。

lst = [1, 2, 3]
print(type(lst))  # 输出: <class 'list'>

2.4.56 vars([object])

返回对象的符号表（通常在其 __dict__ 属性中找到）。如果没有参数，返回对应于局部命名空间的字典。返回的字典应被视为只读，修改其内容不安全。

class MyClass:
    def __init__(self):
        self.value = 10

obj = MyClass()
print(vars(obj))  # 输出: {'value': 10}

总之，Python 的标准库模块和内置函数为开发者提供了丰富的工具，能够处理各种不同的任务，从简单的文件操作到复杂的并发编程。熟练掌握这些工具，将大大提高开发效率和代码质量。