20、Python关键模块与函数深度解析

Python关键模块与函数深度解析

1. 内置类型概述

Python 解释器内置了多种标准类型，包括数值类型、序列类型等，且没有显式的布尔类型，通常使用整数替代。所有对象都能进行比较、真值测试以及转换为字符串。

1.1 真值测试

以下值被视为假：
- None
- 任何数值类型的零，如 0 、 0L 、 0.0
- 任何空序列，如 '' 、 () 、 []
- 任何空映射，如 {}
- 用户定义类的实例，若类定义了 __nonzero__() 或 __len__() 方法，且该方法返回零

其他值均被视为真。具有布尔结果的操作和内置函数通常返回 0 表示假，1 表示真，但布尔操作 or 和 and 会返回其操作数之一。

1.2 布尔操作

操作	结果	备注
x or y	若 x 为假，则返回 y ，否则返回 x	仅在需要时计算第二个参数
x and y	若 x 为假，则返回 x ，否则返回 y	仅在需要时计算第二个参数
not x	若 x 为假，则返回 1，否则返回 0	not 优先级低于非布尔运算符

1.3 比较操作

操作	含义	备注
<	严格小于
<=	小于或等于
>	严格大于
>=	大于或等于
==	相等
<>	不相等	与 != 等效
!=	不相等	与 <> 等效
is	对象标识
is not	否定的对象标识

不同类型的对象（除不同数值类型外）通常不相等，且按类型名称排序。“in” 和 “not in” 操作仅由序列类型支持。

1.4 数值类型

Python 有四种数值类型：普通整数、长整数、浮点数和复数。普通整数使用 C 语言的 long 实现，至少有 32 位精度；长整数精度无限制；浮点数使用 C 语言的 double 实现。

数值由数值字面量或内置函数和运算符创建。Python 支持混合算术运算，不同数值类型的操作数会进行类型转换。所有数值类型支持以下操作：
| 操作 | 结果 | 备注 |
| ---- | ---- | ---- |
| x + y | x 和 y 的和 | |
| x - y | x 和 y 的差 | |
| x * y | x 和 y 的积 | |
| x / y | x 除以 y 的商 | 整数除法结果为整数，向负无穷取整 |
| x % y | x 除以 y 的余数 | |
| -x | x 取反 | |
| +x | x 不变 | |
| abs(x) | x 的绝对值或模 | |
| int(x) | x 转换为整数 | |
| long(x) | x 转换为长整数 | |
| float(x) | x 转换为浮点数 | |
| complex(re, im) | 实部为 re ，虚部为 im 的复数， im 默认为 0 | |
| c.conjugate() | 复数 c 的共轭 | |

1.5 整数类型的位串操作

普通和长整数类型支持仅对位串有意义的额外操作。负数按其 2 的补码值处理。二进制位运算的优先级低于数值运算，高于比较运算。
| 操作 | 结果 | 备注 |
| ---- | ---- | ---- |
| x ¦ y | x 和 y 的按位或 | |
| x ˆ y | x 和 y 的按位异或 | |
| x & y | x 和 y 的按位与 | |
| x < n | x 左移 n 位 | 负移位数非法 |
| x >> n | x 右移 n 位 | 负移位数非法 |
| ~x | x 的位取反 | |

1.6 序列类型

序列类型包括字符串、列表和元组。字符串字面量用单引号或双引号表示，列表用方括号构建，元组用逗号运算符构建。序列类型支持以下操作：
| 操作 | 结果 | 备注 |
| ---- | ---- | ---- |
| x in s | 若 s 中有元素等于 x ，则返回 1，否则返回 0 | |
| x not in s | 若 s 中有元素等于 x ，则返回 0，否则返回 1 | |
| s + t | s 和 t 的连接 | |
| s * n 或 n * s | s 重复 n 次 | n 小于 0 视为 0 |
| s[i] | s 的第 i 个元素，索引从 0 开始 | 负数索引相对于序列末尾 |
| s[i:j] | s 从 i 到 j 的切片 | |
| len(s) | s 的长度 | |
| min(s) | s 中的最小元素 | |
| max(s) | s 中的最大元素 | |

1.7 更多字符串操作

字符串对象有一个独特的内置操作： % 运算符，将左操作数视为 C 语言的 sprintf() 格式字符串，应用于右操作数并返回格式化后的字符串。右操作数可以是元组或单个非元组对象。支持多种格式字符，如 % 、 c 、 s 等。

1.8 可变序列类型

列表对象支持允许原地修改的额外操作，而字符串和元组是不可变序列类型。
| 操作 | 结果 | 备注 |
| ---- | ---- | ---- |
| s[i] = x | 将 s 的第 i 个元素替换为 x | |
| s[i:j] = t | 将 s 从 i 到 j 的切片替换为 t | |
| del s[i:j] | 等同于 s[i:j] = [] | |
| s.append(x) | 等同于 s[len(s) :len(s)] = [x] | |
| s.extend(x) | 等同于 s[len(s) :len(s)] = x | x 必须是列表对象 |
| s.count(x) | 返回 s 中等于 x 的元素个数 | |
| s.index(x) | 返回 s 中第一个等于 x 的元素的索引 | 未找到元素时抛出异常 |
| s.insert(i, x) | 等同于 s[i:i] = [x] （ i >= 0 ） | |
| s.pop([i]) | 移除并返回 s 的第 i 个元素， i 默认为 -1 | |
| s.remove(x) | 移除 s 中第一个等于 x 的元素 | 未找到元素时抛出异常 |
| s.reverse() | 原地反转 s 的元素 | |
| s.sort([cmpfunc]) | 原地对 s 的元素排序 | |

1.9 映射类型

映射对象将一种类型的值（键类型）映射到任意对象，目前只有字典一种标准映射类型。字典的键几乎可以是任意值，但包含列表、字典或其他可变类型的值不能作为键。
| 操作 | 结果 | 备注 |
| ---- | ---- | ---- |
| len(a) | a 中的项数 | |
| a[k] | a 中键为 k 的项 | 键不存在时抛出异常 |
| a[k] = x | 将 a 中键为 k 的项设置为 x | |
| del a[k] | 从 a 中移除键为 k 的项 | |
| a.clear() | 移除 a 中的所有项 | |
| a.copy() | a 的浅拷贝 | |
| a.has_key(k) | 若 a 有键 k ，则返回 1，否则返回 0 | |
| a.items() | a 的 (键, 值) 对列表的副本 | |
| a.keys() | a 的键列表的副本 | |
| a.update(b) | 将 b 中的项更新到 a 中 | b 必须与 a 类型相同 |
| a.values() | a 的值列表的副本 | |
| a.get(k[, f]) | a 中键为 k 的值，键不存在时返回 f （ f 可选，默认为 None ） | |

1.10 其他内置类型

• 模块 ：模块的唯一特殊操作是属性访问，如 m.name 。每个模块有一个特殊成员 __dict__ ，用于存储模块的符号表。
• 类和类实例 ：相关内容可参考 Python 参考手册。
• 函数 ：函数对象由函数定义创建，唯一操作是调用。有内置函数和用户定义函数两种类型。
• 方法 ：方法是使用属性表示法调用的函数，有内置方法和类实例方法两种类型。
• 代码对象 ：用于表示“伪编译”的可执行 Python 代码，可由内置的 compile() 函数返回。
• 类型对象 ：表示各种对象类型，可通过内置的 type() 函数访问。
• 空对象 ：由不显式返回值的函数返回，名为 None 。
• 省略号对象 ：用于扩展切片表示法，名为 Ellipsis 。
• 文件对象 ：使用 C 语言的 stdio 包实现，可由内置的 open() 函数创建。文件对象有多种方法，如 close() 、 flush() 、 read() 等，还有一些属性，如 closed 、 mode 、 name 等。

1.11 特殊属性

Python 为一些对象类型添加了特殊的只读属性：
- __dict__ ：存储对象的可写属性的字典
- __methods__ ：许多内置对象类型的方法列表
- __members__ ：类似于 __methods__ ，但列出数据属性
- __class__ ：类实例所属的类
- __bases__ ：类对象的基类元组

1.12 内置异常

在 Python 1.5 中，所有标准异常都转换为类对象。内置异常可由解释器或内置函数生成，部分异常有“关联值”表示错误的详细原因。以下是一些常用的内置异常：
| 异常 | 描述 |
| ---- | ---- |
| AssertionError | 断言语句失败时抛出 |
| AttributeError | 属性引用或赋值失败时抛出 |
| EOFError | 内置函数（如 input() 或 raw_input() ）遇到文件结束条件（EOF）且未读取任何数据时抛出 |
| FloatingPointError | 浮点运算失败时抛出 |
| IOError | I/O 操作失败时抛出 |
| ImportError | 导入语句找不到模块定义或 from … import 找不到要导入的名称时抛出 |
| IndexError | 序列下标越界时抛出 |
| KeyError | 映射（字典）键不存在时抛出 |
| KeyboardInterrupt | 用户按下中断键（通常是 Ctrl-C 或 Del ）时抛出 |
| MemoryError | 操作内存不足时抛出 |
| NameError | 局部或全局名称未找到时抛出 |
| NotImplementedError | 用户定义的基类中，抽象方法需要派生类重写时抛出 |
| OSError | 函数返回系统相关错误时抛出 |
| OverflowError | 算术运算结果太大无法表示时抛出 |
| RuntimeError | 检测到不属于其他类别的错误时抛出 |
| SyntaxError | 解析器遇到语法错误时抛出 |
| SystemError | 解释器发现内部错误时抛出 |
| SystemExit | 由 sys.exit() 函数抛出 |
| TypeError | 内置操作或函数应用于不适当类型的对象时抛出 |
| ValueError | 内置操作或函数接收到类型正确但值不适当的参数时抛出 |
| ZeroDivisionError | 除法或取模运算的第二个参数为零时抛出 |

1.13 内置函数

Python 解释器有许多内置函数，以下是部分常用函数的介绍：

1.13.1 __import__(name[, globals[, locals[, fromlist]]])

由 import 语句调用，可替换为具有兼容接口的其他函数以改变 import 语句的语义。例如：

import string
def my_import(name):
    mod = __import__(name)
    components = string.split(name, '.')
    for comp in components[1:]:
        mod = getattr(mod, comp)
    return mod

1.13.2 abs(x)

返回数字的绝对值，参数可以是普通整数、长整数、浮点数或复数。

1.13.3 apply(function, args[, keywords])

调用可调用对象 function ，参数列表为 args ，可选关键字参数为 keywords 。

1.13.4 buffer(object[, offset[, size]])

创建一个引用 object 的新缓冲区对象。

1.13.5 callable(object)

判断对象是否可调用。

1.13.6 chr(i)

返回 ASCII 码为整数 i 的单字符字符串。

1.13.7 cmp(x, y)

比较两个对象 x 和 y ，根据结果返回负整数、零或正整数。

1.13.8 coerce(x, y)

将两个数值参数转换为相同类型，返回转换后的元组。

1.13.9 compile(string, filename, kind)

将字符串编译为代码对象，可由 exec 语句执行或 eval() 函数评估。

1.13.10 complex(real[, imag])

创建复数或将字符串、数字转换为复数。

1.13.11 delattr(object, name)

删除对象的指定属性。

1.13.12 dir([object])

无参数时返回当前局部符号表中的名称列表，有参数时返回对象的有效属性列表。

1.13.13 divmod(a, b)

返回两个数的商和余数组成的元组。

1.13.14 eval(expression[, globals[, locals]])

解析并评估 Python 表达式，返回评估结果。

1.13.15 execfile(file[, globals[, locals]])

解析并评估文件中的 Python 语句，类似于 exec 语句。

1.13.16 filter(function, list)

从列表中筛选出 function 返回 True 的元素，组成新列表。

1.13.17 float(x)

将字符串或数字转换为浮点数。

1.13.18 getattr(object, name)

返回对象的指定属性。

1.13.19 globals()

返回当前全局符号表的字典。

1.13.20 hasattr(object, name)

判断对象是否有指定属性。

1.13.21 hash(object)

返回对象的哈希值。

1.13.22 hex(x)

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

1.13.23 id(object)

返回对象的唯一标识符。

1.13.24 input([prompt])

等同于 eval(raw_input(prompt)) 。

1.13.25 intern(string)

将字符串加入驻留字符串表并返回驻留字符串。

1.13.26 int(x)

将字符串或数字转换为普通整数。

1.13.27 isinstance(object, class)

判断对象是否是指定类或其子类的实例。

1.13.28 issubclass(class1, class2)

判断 class1 是否是 class2 的子类。

1.13.29 len(s)

返回对象的长度。

1.13.30 list(sequence)

将序列转换为列表。

1.13.31 locals()

返回当前局部符号表的字典。

1.13.32 long(x)

将字符串或数字转换为长整数。

1.13.33 map(function, list, …)

将函数应用于列表的每个元素，返回结果列表。

1.13.34 max(s[, args…])

返回序列中的最大元素或多个参数中的最大值。

1.13.35 min(s[, args…])

返回序列中的最小元素或多个参数中的最小值。

1.13.36 oct(x)

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

1.13.37 open(filename[, model[, bufsize]])

打开文件并返回文件对象。

1.13.38 ord(C)

返回单字符字符串的 ASCII 值。

1.13.39 pow(x, y[, z])

返回 x 的 y 次幂，可选对 z 取模。

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

创建包含算术级数的列表，常用于 for 循环。

1.13.41 raw_input([prompt])

读取用户输入的一行并返回字符串。

1.13.42 reduce(function, sequence [, initializer])

将二元函数累积应用于序列的元素，将序列缩减为单个值。

1.13.43 reload(module)

重新解析并初始化已导入的模块。

1.13.44 repr(object)

返回对象的可打印表示字符串。

1.13.45 round(x[, n])

将浮点数 x 四舍五入到 n 位小数。

1.13.46 setattr(object, name, value)

将对象的指定属性设置为指定值。

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

返回表示指定索引范围的切片对象。

1.13.48 str(object)

返回对象的可打印表示字符串。

1.13.49 tuple(sequence)

将序列转换为元组。

1.13.50 type(object)

返回对象的类型。

1.13.51 vars([object])

无参数时返回当前局部符号表的字典，有参数时返回对象的符号表字典。

1.13.52 xrange([start,] stop [, step])

类似于 range() ，但返回 xrange 对象，节省内存。

1.14 模块介绍

1.14.1 sys 模块

sys 模块提供对解释器使用或维护的一些变量以及与解释器密切交互的函数的访问。以下是部分常用属性和函数：
- argv ：传递给 Python 脚本的命令行参数列表。
- builtin_module_names ：编译到 Python 解释器中的所有模块的名称元组。
- copyright ：Python 解释器的版权信息。
- exc_info() ：返回当前正在处理的异常的信息元组。
- exec_prefix ：特定于站点的目录前缀，用于安装与平台相关的 Python 文件。
- executable ：Python 解释器的可执行二进制文件的名称。
- exit([arg]) ：退出 Python，通过抛出 SystemExit 异常实现。
- exitfunc ：可由用户设置的程序退出时的清理函数。
- getrefcount(object) ：返回对象的引用计数。
- last_type , last_value , last_traceback ：未处理异常时设置的变量，用于事后调试。
- maxint ：Python 常规整数类型支持的最大正整数。
- modules ：已加载模块的字典。
- path ：模块搜索路径列表。
- platform ：平台标识符。
- prefix ：特定于站点的目录前缀，用于安装与平台无关的 Python 文件。
- ps1 , ps2 ：解释器的主提示和次提示字符串。
- setcheckinterval(interval) ：设置解释器的检查间隔。
- setprofile(profilefunc) ：设置系统的分析函数。
- settrace(tracefunc) ：设置系统的跟踪函数。
- stdin , stdout , stderr ：解释器的标准输入、输出和错误流。
- __stdin__ , __stdout__ , __stderr__ ：程序开始时的标准输入、输出和错误流的原始值。
- tracebacklimit ：未处理异常时打印的最大回溯信息级别。
- version ：Python 解释器的版本号。

1.14.2 string 模块

string 模块定义了一些可检查字符类的常量和一些有用的字符串函数。
- 常量 ：
- digits ：字符串 '0123456789' 。
- hexdigits ：字符串 '0123456789abcdefABCDEF' 。
- letters ： lowercase() 和 uppercase() 字符串的连接。
- lowercase ：包含所有小写字母的字符串。
- octdigits ：字符串 '01234567' 。
- uppercase ：包含所有大写字母的字符串。
- whitespace ：包含所有空白字符的字符串。
- 函数 ：
- atof(s) ：将字符串转换为浮点数。
- atoi(s[, base]) ：将字符串转换为指定进制的整数。
- atol(s[, base]) ：将字符串转换为指定进制的长整数。
- capitalize(word) ：将参数的首字符大写。
- capwords(s) ：将字符串拆分为单词，每个单词首字符大写后再连接。
- expandtabs(s, [tabsize]) ：扩展字符串中的制表符。
- find(s, sub[, start[, end]]) ：返回子字符串在字符串中首次出现的最低索引。
- rfind(s, sub[, start[, end]]) ：返回子字符串在字符串中最后出现的最高索引。
- index(s, sub[, start[, end]]) ：类似于 find() ，但子字符串不存在时抛出 ValueError 。
- rindex(s, sub[, start[, end]]) ：类似于 rfind() ，但子字符串不存在时抛出 ValueError 。
- count(s, sub[, start[, end]]) ：返回子字符串在字符串中出现的次数。
- lower(s) ：将字符串中的大写字母转换为小写字母。
- maketrans(from, to) ：返回用于 translate() 或 regex.compile() 的转换表。
- split(s[, sep[, maxsplit]]) ：将字符串拆分为单词列表。
- splitfields(s[, sep[, maxsplit]]) ：与 split() 功能相同。
- join(words[, sep]) ：将单词列表连接为字符串。
- joinfields(words[, sep]) ：与 join() 功能相同。
- lstrip(s) ：返回去除字符串左侧空白字符的副本。
- rstrip(s) ：返回去除字符串右侧空白字符的副本。
- strip(s) ：返回去除字符串两侧空白字符的副本。
- swapcase(s) ：将字符串中的小写字母转换为大写字母，大写字母转换为小写字母。
- translate(s, table[, deletechars]) ：删除字符串中指定的字符并进行字符转换。
- upper(s) ：将字符串中的小写字母转换为大写字母。
- ljust(s, width) , rjust(s, width) , center(s, width) ：分别将字符串左对齐、右对齐和居中对齐。
- zfill(s, width) ：在数字字符串左侧填充零直到达到指定宽度。
- replace(str, old, new[, maxsplit]) ：将字符串中所有出现的子字符串 old 替换为 new 。

1.14.3 os 模块

os 模块提供了一种更可移植的方式来使用依赖于操作系统的功能。它搜索依赖于操作系统的内置模块并导出相同的函数和数据。以下是部分常用功能：
- 错误处理 ： error 异常在函数返回系统相关错误时抛出，等同于 OSError 。
- 操作系统名称 ： name 表示导入的依赖于操作系统的模块的名称。
- 路径操作模块 ： path 是用于路径名操作的相应依赖于操作系统的标准模块。

1.14.3.1 进程参数

• chdir(path) ：更改当前工作目录。
• environ ：表示字符串环境的映射。
• getcwd() ：返回当前工作目录的字符串表示。
• getegid() ：返回当前进程的有效组 ID。
• geteuid() ：返回当前进程的有效用户 ID。
• getgid() ：返回当前进程的组 ID。
• getpgrp() ：返回当前进程的组 ID。
• getpid() ：返回当前进程 ID。
• getppid() ：返回父进程 ID。
• getuid() ：返回当前进程的用户 ID。
• putenv(varname, value) ：设置环境变量。
• setgid(gid) ：设置当前进程的组 ID。
• setpgrp() ：调用系统调用 setpgrp() 或 setpgrp(0, 0) 。
• setpgid(pid, pgrp) ：设置与终端关联的进程组。
• setsid() ：调用系统调用 setsid() 。
• setuid(uid) ：设置当前进程的用户 ID。
• strerror(code) ：返回与错误代码对应的错误消息。
• umask(mask) ：设置当前的数字掩码并返回之前的掩码。
• uname() ：返回包含当前操作系统信息的五元组。

1.14.3.2 文件对象创建

• fdopen(fd[, mode[, bufsize]]) ：返回与文件描述符 fd 关联的打开文件对象。
• popen(command[, mode[, bufsize]]) ：打开与命令的管道连接的文件对象。

1.14.3.3 文件描述符操作

• close(fd) ：关闭文件描述符 fd 。
• dup(fd) ：返回文件描述符 fd 的副本。
• dup2(fd, fd2) ：将文件描述符 fd 复制到 fd2 。
• fstat(fd) ：返回文件描述符 fd 的状态信息。
• fstatvfs(fd) ：返回与文件描述符 fd 关联的文件系统的信息。
• ftruncate(fd, length) ：截断文件描述符 fd 对应的文件。
• lseek(fd, pos, how) ：设置文件描述符 fd 的当前位置。
• open(file, flags[, mode]) ：打开文件并设置各种标志和模式。
• pipe() ：创建一个管道，返回一对可用于读写的文件描述符。
• read(fd, n) ：从文件描述符 fd 读取最多 n 个字节。
• tcgetpgrp(fd) ：返回与终端关联的进程组。
• tcsetpgrp(fd, pg) ：设置与终端关联的进程组。
• ttyname(fd) ：返回与文件描述符 fd 关联的终端设备的字符串。
• write(fd, str) ：将字符串 str 写入文件描述符 fd 。

1.14.3.4 文件和目录操作

• access(path, mode) ：检查进程对文件路径的读/写/执行权限。
• chmod(path, mode) ：更改文件路径的模式。
• chown(path, uid, gid) ：更改文件路径的所有者和组 ID。
• link(src, dst) ：创建指向 src 的硬链接 dst 。
• listdir(path) ：返回目录中条目的名称列表。
• lstat(path) ：类似于 stat() ，但不跟随符号链接。
• mkfifo(path[, mode]) ：创建一个命名管道。
• mkdir(path[, mode]) ：创建一个目录。
• makedirs(path[, mode]) ：递归创建目录。
• readlink(path) ：返回符号链接指向的路径。
• remove(path) ：移除文件路径。
• removedirs(path) ：递归移除目录。
• rename(src, dst) ：重命名文件或目录。
• renames(old, new) ：递归重命名文件或目录。
• rmdir(path) ：移除目录。
• stat(path) ：执行 stat() 系统调用，返回文件的状态信息。
• statvfs(path) ：执行 statvfs() 系统调用，返回文件系统的信息。
• symlink(src, dst) ：创建指向 src 的符号链接 dst 。
• unlink(path) ：移除文件路径。
• utime(path, (atime, mtime)) ：设置文件的访问和修改时间。

1.14.3.5 进程管理

• execl(path, arg0, arg1, …) ：等同于 execv(path, (arg0, arg1, …)) 。
• execle(path, arg0, arg1, …, env) ：等同于 execve(path, (arg0, arg1, …), env) 。
• execlp(path, arg0, arg1, …) ：等同于 execvp(path, (arg0, arg1, …)) 。
• execv(path, args) ：执行可执行文件 path ，替换当前进程。
• execve(path, args, env) ：执行可执行文件 path ，替换当前进程，并设置环境变量。
• execvp(path, args) ：类似于 execv(path, args) ，但会在目录列表中搜索可执行文件。
• execvpe(path, args, env) ：结合了 execve() 和 execvp() 的功能。
• _exit(n) ：以指定状态退出系统，不调用清理处理程序。
• fork() ：分叉一个子进程。
• kill(pid, sig) ：用指定信号杀死进程 pid 。
• nice(increment) ：增加进程的“友好度”。
• plock(op) ：将程序段锁定到内存中。
• spawnv(mode, path, args) ：在新进程中执行程序 path 。
• spawnve(mode, path, args, env) ：在新进程中执行程序 path ，并设置环境变量。
• system(command) ：在子 shell 中执行命令。
• times() ：返回累积的时间信息元组。
• wait() ：等待子进程完成并返回其进程 ID 和退出状态。
• waitpid(pid, options) ：等待指定进程 ID 的子进程完成并返回其进程 ID 和退出状态。

1.14.4 os.path 模块

os.path 模块实现了一些有用的路径名操作函数：
- abspath(path) ：返回路径名的规范化绝对版本。
- basename(path) ：返回路径名的基名。
- commonprefix(list) ：返回列表中所有字符串的最长公共前缀。
- dirname(path) ：返回路径名的目录名。
- exists(path) ：判断路径是否存在。
- expanduser(path) ：将路径中的 “~” 或 “~user” 替换为用户的主目录。
- expandvars(path) ：扩展路径中的环境变量。
- getatime(path) ：返回文件的最后访问时间。
- getmtime(path) ：返回文件的最后修改时间。
- getsize(path) ：返回文件的大小。
- isabs(path) ：判断路径是否为绝对路径。
- isfile(path) ：判断路径是否为现有常规文件。
- isdir(path) ：判断路径是否为现有目录。
- islink(path) ：判断路径是否为符号链接。
- ismount(path) ：判断路径是否为挂载点。
- join(path1[, path2[, …]]) ：智能地连接一个或多个路径组件。
- normcase(path) ：规范化路径名的大小写。
- normpath(path) ：规范化路径名，消除冗余分隔符和上级引用。
- samefile(path1, path2) ：判断两个路径名是否指向同一个文件或目录。
- sameopenfile(fp1, fp2) ：判断两个文件对象是否指向同一个文件。
- samestat(stat1, stat2) ：判断两个 stat 元组是否指向同一个文件。
- split(path) ：将路径名拆分为 (目录名, 基名) 对。
- splitdrive(path) ：将路径名拆分为 (驱动器规范, 剩余部分) 对。
- splitext(path) ：将路径名拆分为 (根, 扩展名) 对。
- walk(path, visit, arg) ：遍历指定目录树中的每个目录，并调用指定函数。

1.15 总结

本文详细介绍了 Python 的内置类型、内置函数以及多个重要模块的使用。通过对这些内容的学习，我们可以更深入地理解 Python 的工作原理，提高编程效率。在实际开发中，合理运用这些内置功能和模块，可以避免重复造轮子，快速实现各种功能。同时，对于异常处理和调试相关的内容，也能帮助我们更好地定位和解决程序中出现的问题。

以下是一个简单的 mermaid 流程图，展示了 Python 解释器处理异常的基本流程：

graph TD;
    A[开始执行代码] --> B{是否发生异常};
    B -- 是 --> C[捕获异常];
    C --> D{是否有匹配的异常处理程序};
    D -- 是 --> E[执行异常处理程序];
    E --> F[继续执行后续代码];
    D -- 否 --> G[抛出异常];
    B -- 否 --> F[继续执行后续代码];

希望本文能对大家学习和使用 Python 有所帮助。在后续的学习和实践中，大家可以进一步探索这些知识的应用场景，不断提升自己的编程能力。

2. 关键函数与模块的应用示例

2.1 内置函数应用示例

2.1.1 eval() 函数动态计算表达式

eval() 函数可以动态解析并计算 Python 表达式，在需要根据用户输入进行计算的场景中非常有用。以下是一个简单的示例：

expression = input("请输入一个 Python 表达式: ")
result = eval(expression)
print(f"计算结果为: {result}")

在这个示例中，用户输入一个 Python 表达式， eval() 函数会对其进行解析和计算，并输出结果。

2.1.2 map() 函数批量处理数据

map() 函数可以将一个函数应用到序列的每个元素上，实现批量处理。以下是一个将列表中的每个元素平方的示例：

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)

在这个示例中， map() 函数将 lambda 函数应用到 numbers 列表的每个元素上，最后将结果转换为列表输出。

2.2 模块应用示例

2.2.1 sys 模块获取命令行参数

sys.argv 可以获取传递给 Python 脚本的命令行参数。以下是一个简单的示例：

import sys

if len(sys.argv) > 1:
    print(f"你输入的参数是: {sys.argv[1:]}")
else:
    print("没有输入任何参数。")

在这个示例中，如果用户在运行脚本时传递了参数，脚本会输出这些参数；否则，会提示没有输入参数。

2.2.2 string 模块处理字符串

string 模块提供了许多处理字符串的函数。以下是一个使用 split() 和 join() 函数处理字符串的示例：

import string

text = "Hello, World! How are you?"
words = string.split(text)
new_text = string.join(words, "-")
print(new_text)

在这个示例中， split() 函数将字符串拆分为单词列表， join() 函数将单词列表用连字符连接成新的字符串。

2.2.3 os 模块进行文件和目录操作

os 模块可以进行文件和目录的创建、删除、重命名等操作。以下是一个创建目录和文件的示例：

import os

# 创建目录
directory = "test_directory"
if not os.path.exists(directory):
    os.mkdir(directory)
    print(f"目录 {directory} 创建成功。")

# 创建文件
file_path = os.path.join(directory, "test_file.txt")
with open(file_path, "w") as file:
    file.write("This is a test file.")
print(f"文件 {file_path} 创建成功。")

在这个示例中，首先检查目录是否存在，如果不存在则创建目录；然后在目录中创建一个文件并写入内容。

2.3 异常处理示例

在 Python 中，异常处理可以帮助我们捕获和处理程序中出现的错误。以下是一个使用 try-except 语句处理异常的示例：

try:
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
    print(f"结果为: {result}")
except ValueError:
    print("输入的不是有效的数字，请重新输入。")
except ZeroDivisionError:
    print("除数不能为零，请重新输入。")

在这个示例中，使用 try 语句包裹可能会出现异常的代码，如果出现 ValueError 或 ZeroDivisionError 异常，会执行相应的 except 块中的代码。

2.4 流程图示例：文件操作流程

以下是一个使用 mermaid 绘制的流程图，展示了使用 os 模块进行文件操作的基本流程：

graph TD;
    A[开始] --> B{选择操作};
    B -- 创建文件 --> C[指定文件路径];
    C --> D[打开文件并写入内容];
    D --> E[关闭文件];
    B -- 删除文件 --> F[指定文件路径];
    F --> G[检查文件是否存在];
    G -- 是 --> H[删除文件];
    G -- 否 --> I[提示文件不存在];
    B -- 重命名文件 --> J[指定原文件路径和新文件名];
    J --> K[检查原文件是否存在];
    K -- 是 --> L[重命名文件];
    K -- 否 --> M[提示原文件不存在];
    E --> N[结束];
    H --> N[结束];
    I --> N[结束];
    L --> N[结束];
    M --> N[结束];

2.5 总结

通过以上示例，我们可以看到 Python 的内置函数和模块在实际应用中的强大功能。合理运用这些函数和模块，可以提高代码的效率和可维护性。在处理异常时，使用 try-except 语句可以增强程序的健壮性，避免因错误输入或其他异常情况导致程序崩溃。

在实际开发中，我们可以根据具体需求选择合适的函数和模块，结合异常处理机制，编写出更加稳定、高效的 Python 程序。同时，不断学习和探索这些知识的更多应用场景，将有助于提升我们的编程能力和解决问题的能力。

以下是一个总结表格，列出了本文介绍的部分关键函数和模块及其主要功能：
| 函数/模块 | 主要功能 |
| ---- | ---- |
| eval() | 动态解析并计算 Python 表达式 |
| map() | 将函数应用到序列的每个元素上 |
| sys.argv | 获取命令行参数 |
| string.split() | 将字符串拆分为单词列表 |
| string.join() | 将单词列表连接成字符串 |
| os.mkdir() | 创建目录 |
| os.remove() | 删除文件 |
| os.rename() | 重命名文件 |
| try-except | 捕获和处理异常 |

希望这些示例和总结能帮助大家更好地理解和应用 Python 的关键函数和模块。在后续的学习和实践中，大家可以进一步深入研究这些知识，不断拓展自己的编程技能。