aiwiki.page
中文
计算机 / 软件与编程 / python-programming-language

Python

Python 是一种高级通用编程语言,以语法易读、动态类型和丰富的软件生态著称。

77 个关键词20 个词条链接到这里24 个尚未撰写AI 撰写
编程语言开源软件操作系统编程范式命令式编程面向对象编程函数式编程UnicodePython

Python 是一种高级通用编程语言,由吉多·范罗苏姆创建,于 1991 年首次公开发布。它使用缩进划分代码块,强调表达清晰、易于阅读。Python 支持过程式、面向对象和函数式编程风格,自动管理内存,并提供丰富的标准库。其主要实现 CPython 以开源软件形式发布,可在主流桌面和服务器操作系统上运行。

Python 承担着多种相互交叠的角色:既是学习编程的语言,也是自动化与系统集成的工具、Web 应用的平台,以及高性能科学计算和机器学习软件的接口。它易于上手,部分得益于简洁的语法和交互式执行方式;而它在实际应用中的广泛用途,同样离不开程序库、开发工具以及与其他语言编写的软件对接的接口。因此,Python 程序既可以是简短的管理脚本,也可以是大型服务和科研系统,而这些系统中计算密集的部分则在 Python 解释器之外执行。

语言规范与语言的具体实现并不相同。表达式求值、对象行为等特性属于语言本身,而字节码格式、引用计数和特定的执行优化则可能属于 CPython 或某个具体版本。在讨论可移植性、性能、并发性和兼容性时,这一区别十分重要。

起源、发展与治理

1989 年 12 月,范罗苏姆在荷兰数学与计算机科学研究中心工作期间,开始着手实现 Python。他此前使用 ABC 语言的经验,使 Python 格外重视可读性和便于使用的高级数据类型。Python 也满足了 ABC 未优先考虑的一些需求,包括可扩展性以及与现有操作系统的交互。与 Amoeba 分布式操作系统有关的工作,也促使他对实用的脚本语言产生了兴趣。“Python”这个名字取自英国喜剧团体“巨蟒剧团”(Monty Python),而非主要指蟒蛇这种动物。

Python 0.9.0 于 1991 年 2 月公开发布。当时它就已具备类、函数、异常处理和核心集合类型。随后,Python 1.0 于 1994 年发布,Python 2.0 于 2000 年发布。Python 的开发逐渐从以单一机构及其直接合作者为中心的项目,转变为由国际社区共同参与的事业。2001 年成立的 Python 软件基金会成为支持该语言知识产权事务、社区活动和基础设施的非营利组织。基金会的职责与审查、维护语言实现的技术工作有所区别。

2008 年 12 月发布的 Python 3.0 有意引入了一些不兼容的改动,以纠正长期积累的设计问题。文本字符串默认基于 Unicode,print 改为函数,整数除法与真除法的区分也更加明确。字典方法更多地返回动态视图,而不再立即构造列表。迁移现有程序时,可能既要修改应用代码,也要调整依赖项。2010 年发布的 Python 2.7 是 Python 2 的最后一个功能版本系列;Python 2 的官方支持于 2020 年 1 月终止。

Python 的语言开发通过 Python 增强提案(简称 PEP)来组织。PEP 可以规定语言特性、软件打包约定、开发流程,也可以提供参考性指导。PEP 8 描述了影响广泛的代码风格规范,PEP 20 则收录了被称为“Python 之禅”的一组箴言。这些文档各有用途:风格建议并不等同于解析器强制执行的规则,而一项提案的存在也不意味着它已被接受或实现。

2018 年,范罗苏姆卸任“终身仁慈独裁者”一职。在此后采用的治理模式下,由选举产生的五人指导委员会全面负责语言开发,并经常将决策权委托给相关领域的专家。从 2020 年的 Python 3.9 开始,每年发布一个功能版本成为固定节奏。兼容性政策、弃用过渡期、发布负责人以及持续维护的版本分支,共同帮助这个庞大的生态系统协调变更;在这一生态系统中,语言的演进会影响库、操作系统发行版、教学资料和已部署的应用程序。

设计理念与表层语法

Python 的语法旨在让程序结构清晰可见,而不必使用大量标点符号。冒号用于引出复合语句,缩进则用于界定其语句体。每级缩进使用四个空格是最普遍的约定,但语法要求的是缩进一致,并非一律使用四个空格。制表符和空格不能随意混用;不一致的组合可能会被拒绝。圆括号、方括号和花括号允许表达式跨越多个物理行,而不会引入新的代码块。

下面这个简短的示例展示了几项典型特征:

def mean(values):
    if not values:
        raise ValueError("至少需要一个值")
    return sum(values) / len(values)

函数声明没有注明参数或返回结果的类型。sum、len 和 ValueError 等名称指向内置对象。表达式 not values 利用了对象的真值判定机制。这种简洁并不意味着没有语义上的要求:该函数假定 values 支持其中使用的操作,而不同对象可以通过不同方式满足这些要求。

Python 支持多种编程范式。普通语句提供命令式编程能力,类支持面向对象编程,而作为一等公民的函数则使函数式编程的部分特性成为可能。这门语言既不要求每个程序都使用类,也不强制使用纯函数或不可变数据。模块、函数、类和数据对象可以根据应用程序的结构组合使用。

表达式与语句仍有区别,不过两者之间的界限一直在演变。条件表达式的形式为 x if condition else y。Python 3.8 引入了赋值表达式,使用 :=,可在规定的语法限制下于表达式内部绑定名称。使用 = 的普通赋值则是语句。Python 的 lambda 语法通过单个表达式创建函数,并不提供可容纳任意语句的匿名语句块。

可读性方面的约定有一部分来自社区惯例,而非语法规则。含义明确的命名、文档字符串、适度的嵌套以及一致的格式,共同形成了易于辨认的 Python 风格。“Pythonic”一词通常用于形容有效运用这门语言惯用写法的代码,例如直接遍历对象,而不是手动管理索引。它并不是一个有正式定义的正确性类别。

在 Python 3 中,Python 源文件默认采用 UTF-8 编码;只要符合标识符规则和规范化要求,标识符就可以包含许多 Unicode统一码字符。关键字仍然是语言中固定的词法单元。交互式提示符支持即时求值,而脚本和模块则支持将程序保存下来执行。这些模式使用相同的核心语言,但提示符下显示表达式的值等细节,属于交互式环境的行为,而非普通脚本执行的行为。

对象、名称与执行模型

Python 的数据模型以对象为核心。每个对象都有标识、类型和值。类型决定对象支持哪些操作,并影响这些操作的行为。整数、函数、类、模块、异常以及用户创建的实例都是对象。这种统一性使得函数可以存储在容器中,类可以动态构建,模块也可以通过普通属性对外提供对象。

名称是与对象的绑定,而不是存储类型永久固定的容器。在 a = b 中,名称 a 会绑定到对 b 求值所得到的对象;对象本身不会自动复制。如果 a 和 b 指向同一个可变列表,通过任一名称修改该列表,都能通过另一个名称观察到变化。将 a 重新绑定到另一个对象,并不会改变 b 的绑定。这一区别是理解许多涉及混叠、复制和共享状态的实际问题的基础。

函数调用遵循同样的对象模型。形参名称会绑定到传入的实参对象。函数可以修改调用方传入的可变对象,但仅仅重新绑定局部形参,并不会改变调用方的绑定。这种行为有时称为共享传参。无论简单地称之为“值传递”,还是不加限制地称之为“引用传递”,若不进一步解释,都无法完整说明这种机制的各种影响。

可变性、标识与相等性是不同的概念。列表和字典是可变的;字符串、整数和元组是不可变的,不过不可变的元组可以包含对可变对象的引用。== 运算符要求对象执行相等性比较,而 is 检验是否为同一个对象。两个分别创建的对象可能比较相等,但并不是同一个对象。具体实现可能会复用某些不可变对象,因此,偶然观察到的标识关系不能普遍用来替代相等性检验。

名称解析通常依次查找局部作用域、外层函数作用域、模块全局作用域和内置作用域,这一顺序常缩写为 LEGB。在函数内进行赋值,通常会使名称成为该函数的局部名称,除非使用 global 或 nonlocal 改变绑定规则。类体具有特殊的作用域行为,不能简单地视为其方法的外层词法作用域。闭包保留了访问外层函数作用域中绑定的能力;这既解释了为何能创建实用的有状态函数,也解释了在循环内创建函数时遇到的后期绑定行为。

Python 规定内存由系统自动管理,但并未要求所有实现采用同一种回收策略。CPython 主要使用引用计数,并辅以处理循环引用的垃圾回收机制。其他实现可以采用不同的内存管理方式。因此,依赖对象在最后一个引用消失后立即销毁来释放外部资源,并不是一种可移植的做法。对于文件、锁和网络连接,更合适的方式是通过显式的生命周期协议,尤其是上下文管理器,来理解和管理它们,而不是假定对象会在何时被回收。

内置值与容器

Python 的内置类型涵盖常见的标量值和数据结构。整数支持任意精度,其大小受可用内存限制,而非固定的机器字长限制。这避免了整数运算中常见的定长整数溢出,不过,随着大整数表示所需的空间增大,运算开销也会增加。布尔值用 True 和 False 表示;布尔类型是整数类型的子类,但其设计用途是逻辑运算,而非数值运算。

常用的浮点数类型使用所在平台的 C 语言 double 类型实现,在主流系统上通常采用 IEEE 754 binary64 格式。因此,许多十进制小数无法被精确表示:在通常采用的表示方式下,0.1 + 0.2 == 0.3 的结果为假。这并非 Python 特有的现象。标准库通过 decimal 提供十进制算术,通过 fractions 提供有理数算术。内置复数类型具有实部和虚部,并支持常规算术运算;更广泛的数值计算方法则由库提供。

文本与二进制数据被明确区分。str 是 Unicode 码位的序列,而 bytes 是由 0 到 255 之间的整数组成的不可变序列。bytearray 则提供可变的二进制序列。编码将文本转换为字节,解码则按照指定的字符编码(例如 UTF-8编码)将字节转换为文本。字符串长度统计的是码位数,不一定等于用户在某种文字系统中感知到的字符数;组合附加符号和由多个码位组成的表情符号使这一区别尤为重要。

列表是可变序列,在 CPython 中通常以可调整大小的对象引用数组实现。元组是不可变序列,常用于将若干值组合成固定的一组。两者都支持索引、切片和迭代。在内置类型的通常用法中,切片会创建新的列表或元组,而不是生成指向同一底层序列的视图。range 类型以紧凑的方式表示等差数列,无须构造包含所有值的列表。

字典将可哈希的键映射到值,集合则存储互不重复的可哈希元素。它们的实现使用哈希表,在通常假设下,查找的平均时间复杂度为常数。可哈希性要求对象的哈希值在其生命周期内保持不变,并且相等性判断与哈希计算相容。因此,元组只有在其所有元素都可哈希时才可哈希。自 Python 3.7 起,字典保留插入顺序成为语言层面的保证;插入顺序并不意味着键经过了排序。

容器语法支持推导式和解包。列表推导式构造列表,集合推导式和字典推导式则分别构造相应的容器。浅拷贝只复制外层容器,仍然保留对其中对象的引用。理解这些表示方式和共享规则,对于分析程序的正确性与时间复杂度都很重要,尤其是在反复复制、成员检测或插入操作占据应用程序主要开销时。

控制流、异常与资源管理

Python 通过 if、elif 和 else 实现条件执行,通过 for 和 while 实现循环。for 循环逐项读取可迭代对象,而不要求使用整数计数器。可迭代对象可以是列表、文件、数据库游标,也可以是按需计算值的对象。break 用于结束循环,continue 则跳到下一次迭代。循环可以附带一个 else 语句块;只要循环不是通过 break 结束的,该语句块就会执行,即使循环一次迭代也未执行。

布尔运算符返回的是操作数,不一定是布尔对象。例如,a or b 在 a 的真值为真时返回 a,否则求值并返回 b。and 和 or 都采用短路求值,这不仅影响效率,也决定了哪些操作会实际发生。链式比较(如 low <= x < high)只对共用的中间表达式求值一次,无须重复该表达式即可表示组合比较。

Python 3.10 通过 match 和 case 引入了结构化模式匹配。模式可以检查序列、映射、类以及多个备选模式,并将名称绑定到匹配的组成部分。守卫条件在模式匹配成功后附加布尔判断。这种机制比基于相等性判断的 switch 语句更为广泛:模式可以描述嵌套数据的结构。处于捕获位置的裸名称会绑定值,而不是与已有变量进行比较;在阅读或编写 match 语句时,这一区别十分重要。

异常处理将故障的检测与响应故障的代码分离开来。异常沿调用栈传播,直到找到匹配的处理程序,或执行上下文终止。try 和 except 用于选择处理程序;else 在受保护的代码块未发生异常并正常结束时运行;finally 则在控制流离开这一结构时运行。异常是按类层次结构组织的对象。Exception 涵盖大多数应用程序错误,而一些与控制流相关的异常,包括 KeyboardInterrupt 和 SystemExit,则直接派生自 BaseException。

异常链保留了故障之间的关联。在处理一个异常时引发新异常,通常会将先前的异常记录为上下文,而 raise ... from ... 则用于指定直接原因。Python 3.11 新增了异常组和 except*,使相关的并发故障能够被表示出来并得到选择性处理,而不必将它们简化为任意一个错误。

with 语句通过上下文管理器协议,实现确定性的进入与退出操作。使用 with open(...) as handle: 打开的文件,会在控制流离开代码块时关闭,包括因大多数异常而离开的情况。上下文管理器还用于管理锁、事务、临时状态和清理操作。它们的重要性源于内存与外部资源之间的区别:垃圾回收可以回收对象,却无法提供适当的应用层策略来完成事务或释放稀缺资源。

函数、迭代与惰性计算

函数是一等对象,最常通过 def 创建。它们可以作为参数传递、作为结果返回、存储在字典中,也可以通过属性进行自省。函数签名可以区分仅限位置参数、普通的位置或关键字参数、仅限关键字参数,以及可变参数集合。/ 和 * 标记明确标示了这些调用约定。这些区分通过控制哪些参数名称属于公共约定的一部分,有助于保持应用程序编程接口的稳定。

默认参数表达式在执行函数定义时求值,而不是在每次调用时求值。因此,像 items=[] 这样的可变默认值,会由所有未传入该参数的调用共享。有意利用时,这一行为很有用,但也常常出乎意料。一种常见的替代做法是使用 None 作为哨兵值,并在函数内部创建新的集合。同样,闭包保留的是绑定关系,而不是将每个值都固定在创建嵌套函数的那一刻。

装饰器在定义时转换或注册函数或类。在函数上方使用 @decorator 记法,大致等同于将装饰器应用于新创建的函数,再把函数名重新绑定到所得结果。多个装饰器按嵌套顺序应用。装饰器可用于缓存、权限检查、分派注册和框架配置,但也可能改变调用行为和自省行为。functools.wraps 等标准库工具有助于保留描述性元数据。

迭代基于协议,而不是某个统一的集合超类。可迭代对象提供迭代器,迭代器通过 __next__ 依次提供值,并以 StopIteration 表示迭代结束。内置函数 iter 和 next 提供了执行这些操作的接口。这种分离使集合能够支持多次相互独立的遍历,而迭代器通常只代表一次不断向前推进的遍历。

生成器函数包含 yield。调用它会创建一个生成器对象,而不会立即将函数体执行完毕。迭代时,暂停的函数体会恢复执行,直到产出下一个值或函数返回。生成器表达式则提供了一种相关的紧凑写法。它们支持流式处理流水线,并可避免实际构建中间集合,使内存用量从与整个数据集的大小成正比,降为与当前计算的状态大小成正比。但它们不会自动消除所有缓冲,也不保证执行得更快。

生成器还支持发送值、注入异常,以及通过 yield from 委托执行。Python 3.5 通过 async def 引入的原生协程采用了类似的暂停模型,但用于异步执行,而非普通迭代。Python 通常不进行尾调用消除,因此递归层数很深的函数可能触及解释器的递归深度限制。因此,对于深度没有严格界限的遍历,通常会采用迭代写法或显式栈,尽管递归仍然是表达许多算法的自然方式。

类、继承与对象协议

Python 的类本身也是对象。执行类语句时,会在一个命名空间中执行类体,再用由此得到的定义构建类。调用类通常会创建一个实例,其中 __new__ 负责创建,__init__ 负责初始化。实例方法显式地接收实例作为第一个参数,按惯例命名为 self。这个名称只是约定,并非关键字,但这个显式参数是方法的普通函数定义的一部分。

属性访问结合了多种机制。实例属性通常存放在实例字典中,而方法和其他共享属性则存放在类上。描述符可以通过 __get__、__set__ 和 __delete__ 等方法定制属性访问行为。存放在类上的函数利用描述符行为生成绑定方法。特性(property)也采用同样的基本机制,让方法控制的访问可以通过属性语法来实现。因此,描述符是一项核心机制,而不是孤立的高级功能。

继承支持代码复用和特化,也支持多重继承。Python 使用 C3 方法解析顺序,在继承层次结构中确定一致的查找顺序。super() 函数遵循这一顺序,并不只是表示“按名称调用直接父类”。因此,协作式多重继承要求各个相关类的方法签名相互兼容,并且这些类都以一致的方式参与协作。

许多语言操作通过特殊方法定义。这些方法因名称带有双下划线,常被称为“dunder”方法。__len__ 支持 len,__iter__ 支持迭代,而算术方法则使对象能够参与运算符操作。这些协议让用户定义的对象能够融入内置语法。特殊方法的查找可能在类型上进行,而不是通过常规的实例属性查找,因此,定义一个看似对应的实例属性,并不总能改变相关操作的行为。

Python 通常倾向于采用鸭子类型:代码依据对象所支持的行为来使用它,而不要求它属于某个指定的继承体系。一个遍历其参数的函数,可以接受许多互无继承关系的类的实例。抽象基类提供了一种互补方式,用于表达和检验映射或序列等类别。组合也同样重要:对象可以将工作委托给其内部包含的对象,而不必继承这些对象的实现。

封装主要依靠约定,而不是通过严格的私有访问控制来强制实现。按照惯例,单个前导下划线表示实现细节。类内部以两个下划线开头的名称会经过名称改写,主要是为了减少子类中意外发生的名称冲突,而不是提供安全边界。__slots__ 等功能可以限制常规实例属性,并改变其存储特性;Python 3.7 加入标准库的 dataclasses 则可为以声明字段为核心的类生成常规方法。这两项功能都不会改变基本的对象协议。

动态类型、类型注解与静态分析

Python 是一门动态类型语言:执行时,对象的类型决定了操作的含义,而同一个名称可以重新绑定到不同类型的对象上。这并不意味着每个操作都会自动转换不兼容的值而不报错。例如,将整数与字符串相加通常会引发 TypeError。人们常在这一意义上将 Python 称为“强类型”语言,不过,这个说法并没有一个普遍认可的统一技术定义。

这门语言的类型系统支持广泛的运行时内省和定制。程序可以检查对象所属的类、查询属性,并判断对象是否属于某个类及其继承体系。这些功能为灵活的框架和交互式工具提供了支持,但也使某些性质难以在执行前推断出来。例如,属性可能在运行时动态添加,类可能由元类生成,函数也可能根据分析时未知的值进行分派。

类型注解则提供了一个独立的、逐步采用的类型描述层。2015 年随 Python 3.5 实现的 PEP 484 将类型提示框架和 typing 模块标准化。注解可以描述参数类型、返回值类型、容器内容的类型、联合类型、可调用对象的签名以及泛型关系。解释器通常不会强制执行这些注解。即使函数被注解为返回 int,只要没有额外的检查代码介入,它仍然可以返回其他对象。

mypy 和 Pyright 等外部静态分析工具会解读注解,在程序运行之前发现不一致之处。分析结果取决于可用的注解、类型存根、配置的严格程度以及分析规则。特殊类型 Any 允许执行绕过许多常规检查的操作,有助于整合未添加注解的代码,但也限制了检查所能提供的保证。因此,类型提示形成了一个连续谱:一端是基本不受检查的动态代码,另一端是经过全面检查的接口。

通过协议实现的结构化类型机制,使注解能够描述所需的行为,而不要求显式继承。泛型将输入与输出之间的类型关联起来,重载声明则用于描述不同的调用形式。Python 3.10 引入了表示联合类型的 X | Y 写法,Python 3.12 则引入了用于类型参数和类型别名的专用语法。这些新增功能减少了语法上的繁琐之处,但采用较新的语法也会限制哪些版本的解释器能够解析源文件。

运行时验证与静态检查解决的是不同的问题。类型检查器可以推断函数所声明的输入结构,却不检查传入的网络消息的具体内容。反过来,运行时验证库可以拒绝格式不正确的外部数据,却无法证明其他地方不存在错误。注解的求值方式和运行时表示也随着版本更迭而变化,这对需要检查注解的框架尤为重要。明确区分文档说明、静态推理、运行时验证和完整的形式验证,有助于避免夸大带有类型注解的 Python 程序所能提供的保证。

模块、导入与包分发

模块是具有独立命名空间的 Python 代码单元,可以来自源文件、编译后的扩展,或导入机制支持的其他来源。包则将模块组织在共同的命名结构下。传统包使用 __init__.py 文件,而命名空间包无需此文件,就能将分布在多个位置的部分组合起来。这一区别使大型项目和单独分发的组件能够共享同一个包命名空间。

导入既是一种命名机制,也是一种执行机制。导入系统会定位模块,创建或获取其模块对象,并在需要时执行初始化代码。已加载的模块会缓存在 sys.modules 中,因此重复导入通常会复用现有对象,而不会重新执行模块主体。循环导入可能遇到尚未完成初始化的模块,因此初始化顺序是架构层面需要考虑的问题,而不只是代码排版问题。

包管理工具安装的分发包,其名称不一定与导入语句中使用的名称相同。一个分发包可以提供多个可导入的包,而历史上的命名选择也可能导致安装名称与导入名称不同。在确定依赖项或排查导入失败时,区分这两者尤为重要。搜索路径、工作目录、已安装的包以及本地文件名,都可能影响一次导入最终解析到哪个模块。

Python 包索引,简称 PyPI,是第三方 Python 分发包最主要的公共仓库。pip 是通常与之配合使用的标准安装工具。现代项目的元数据和构建配置围绕 pyproject.toml 组织,并通过标准化接口将构建前端与构建后端分离。这减少了对直接执行项目传统 setup.py 文件的依赖,不过旧式打包做法对遗留软件仍然具有现实意义。

分发包通常以源码归档或 wheel 的形式提供。wheel 是一种已构建的分发格式,通常无需运行编译器即可安装。纯 Python wheel 可以支持多个平台,而包含原生代码的 wheel 则可能面向特定的 Python 版本、应用二进制接口、操作系统和处理器架构。因此,在某个平台上很容易安装的依赖项,到了另一个平台上可能就需要本地编译器或外部系统库。

通过标准库的 venv 模块提供的虚拟环境,可为各个项目提供独立的安装位置和解释器配置。虚拟环境并不是安全沙箱,也不一定能隔离系统库或所有环境变量。可复现性还取决于依赖项版本、间接依赖、构建工具、平台细节以及构建产物的来源。因此,包安装属于软件工程和发布管理的一部分,而不只是语言导入语法的延伸。

标准库与开发工具

Python 标准库随解释器一同提供,涵盖广泛的基础功能,包括处理文件与目录、日期与时间、正则表达式、序列化、网络、子进程、并发、压缩、测试和内省的模块。“自带电池”(batteries included)这一说法形容的正是这种广泛性,但并不意味着它覆盖了所有应用领域,也不意味着其中所有模块都具有同等地位。有些接口依赖操作系统提供的功能,而已弃用的模块则可能按照既定流程移除。

pathlib、os 和 shutil 模块在不同的抽象层次上支持与文件系统交互。subprocess 用于启动外部程序并与之通信。socket、ssl 和 http 等模块为网络通信提供基础组件。sqlite3 提供对嵌入式关系数据库的访问接口,而 json 则负责处理 JSON 数据交换。这些模块帮助脚本连接现有系统,使其不必为每一项基本任务都引入单独的第三方依赖。

不同的序列化格式有不同的用途,也基于不同的信任假设。JSON 表示的是一种有限的、与语言无关的数据模型。pickle 模块可以表示范围广泛得多的 Python 对象图,但它是 Python 专用的,而且在重建对象时可能执行代码。因此,选择序列化表示形式不只是选择存储方式:它还界定了兼容性预期,以及数据与可执行行为之间的边界。

文档字符串存储在对象上,为交互式帮助、API 文档和内省提供支持。inspect 模块可获取签名及其他属性,但对某些原生对象和经过动态变换的可调用对象存在限制。pdb 调试器支持断点和调用栈检查。异常回溯可指出引发异常的调用序列,而结构化日志则提供由应用程序定义的上下文,这些信息可能无法仅从异常回溯中获得。

unittest 为软件测试提供支持,包含测试用例、测试夹具、断言和测试发现等功能。doctest 用于检查嵌入在文档类文本中的示例。第三方框架 pytest 提供了另一种广泛使用的测试方式,以普通测试函数、测试夹具和插件为基础。测试、类型检查和格式检查通常通过与版本控制和持续交付相关的自动化工作流运行,但它们各自检测的是不同类别的问题。

性能工具包括用于对小段代码进行受控计时的 timeit、用于确定性性能剖析的 cProfile,以及用于跟踪 Python 内存分配的 tracemalloc。测量时需要留意启动开销、缓存、输入规模、解释器版本,以及工作是否在原生扩展中执行。Python 源代码中看似开销很小的一行,可能触发大规模数值计算、网络请求或数据库查询。因此,有效使用工具,需要将源码层面的观察与实际执行工作的系统联系起来。

实现、编译与性能

CPython 是 Python 的参考实现,也是许多其他工具和发行版的基础。其实现代码很大一部分使用 C编程语言编写。在常规执行流程中,源代码先经过解析,再编译为包含字节码的代码对象,最后由解释器执行。缓存的 .pyc 文件可以避免重复编译源代码,但它们并不是可独立运行的原生可执行文件,而且依赖于特定实现的字节码约定。

将 Python 简单描述为“解释型而非编译型”语言,会掩盖这一过程。编译和解释可以发生在不同阶段,而不同的实现也会采用不同的策略。CPython 的字节码求值器是一种虚拟机,而原生扩展模块执行的则是从其他语言编译而来的机器指令。语言与执行引擎之间的区别,解释了为什么同一份源代码在不同实现中会表现出不同的性能特征。

CPython 3.11 引入了专门化自适应解释器,可根据观察到的运行时行为优化某些操作。这类技术在保留语言动态语义的同时降低了开销。CPython 3.13 还引入了一项实验性的即时编译功能,需要在构建时启用。这些进展并不意味着所有 Python 代码都会变成静态编译的代码,也不意味着所有工作负载都能同等受益。动态分派、内存分配、外部调用和内存访问仍可能带来显著开销。

PyPy 是另一种 Python 实现,以其追踪式即时编译器著称。它能够识别并优化频繁执行的路径,从而加速适合这种方式的、长时间运行的 Python 工作负载。它在垃圾回收、扩展兼容性等方面的行为与 CPython 不同。其他一些实现则面向特定环境:Jython 与 Java 平台集成,IronPython 与 .NET 集成,而 MicroPython 则提供了适用于资源受限系统的 Python 实现。这些实现所支持的语言版本和可用库不一定与 CPython 一致。

与原生代码集成,是 Python 在实际应用中获得高性能的重要途径。扩展模块、外部函数接口和代码生成工具,可以将计算密集型工作转移到已编译的例程中。例如,Cython 将面向 Python 的语法与支持编译执行、C 级声明的功能结合起来。标准库中的 ctypes 模块可以调用共享库中的函数。这些方法也会对内存所有权、错误处理、二进制兼容性和软件分发提出各自的要求。

性能还取决于算法和数据表示方式。将时间复杂度为平方级的过程替换为近线性过程,所带来的收益可能超过解释器层面的改进。反过来,在 Python 对象与原生数组之间进行转换,也可能占据一次短时计算的大部分耗时。只有明确说明工作负载、实现、库、硬件和测量方法,语言之间的性能比较才有意义。Python 特有的权衡并非性能一概低下,而在于将便捷的高层组织协调与具体被调度操作的成本分离开来。

线程、异步执行与并行性

Python 支持多种形式的并发计算,每种形式都有不同的执行模型。线程共享进程的地址空间。进程的状态彼此更为独立,并通过显式机制通信。异步任务则通过在指定位置挂起自身来协作。并发意味着多个活动可以在相互重叠的时间段内推进;并行计算则意味着多项工作同时执行。程序可以是并发的,却不一定能并行执行 Python 指令。

在常规的 CPython 构建版本中,全局解释器锁(GIL)限制了 Python 代码的执行,使相关解释器内同一时刻只能有一个线程执行代码。这简化了部分内存管理和扩展集成工作,但也限制了普通 Python 线程中 CPU 密集型任务的并行执行能力。这并不意味着 Python 无法使用多个处理器核心。独立进程、会释放 GIL 的原生库以及其他执行方式都可以并行完成工作。

对于网络或文件访问等需要花时间等待的操作,线程仍然有助于让它们交叠进行。解释器通常会在执行阻塞操作时释放 GIL,让其他线程得以运行。原生数值计算库在执行大量计算时也可能释放 GIL。不过,GIL 不能替代应用层的同步机制。由多个逻辑相关操作组成的序列仍然可能出现竞态条件,扩展代码也可能引入额外的并发行为。

multiprocessing 模块和基于进程的执行器允许 CPU 密集型 Python 任务在多个进程中运行。这会带来进程启动、序列化、通信和状态复制等开销。进程启动方式因平台而异,会影响哪些内容可以被继承,以及工作进程如何初始化。共享内存可以减少一部分复制操作,但也使程序再次需要谨慎协调。并行设计能否带来收益,取决于有效工作量是否足以抵消这些开销。

asyncio 库围绕事件循环、任务、future 对象和协程来组织异步编程。await 会挂起协程,直到可等待对象能够继续推进或完成。这种方式非常适合同时进行大量 I/O 操作,但协程内普通的 CPU 密集型循环可能会阻塞同一事件循环线程上的其他任务。异步语法不会自动将阻塞式库变成非阻塞式库。

CPython 3.13 引入了一种实验性的自由线程构建版本,其中可以禁用 GIL,落实了 PEP 703 所提出的方向。移除这把锁需要调整对象访问、引用管理和扩展行为;它不会自动使现有的共享状态程序变得正确。另有针对子解释器和每解释器独立锁的工作,探索另一种隔离模型。这些进展意味着,要准确描述 Python 的并发能力,就必须考虑实现版本、构建配置和库兼容性。

科学计算、数据分析与机器学习

Python在科学计算中的作用依托于分层的软件生态,而非内置的数值数组。NumPy提供元素类型一致的多维数组,其运算主要由编译后的代码实现。广播机制可以对形状兼容的数组执行运算,无须为每个元素显式编写Python循环。数组视图可以共享底层存储,而高级索引及其他一些操作则会创建副本。因此,形状、步长、数据类型和内存布局都会影响程序的语义与性能。

SciPy在NumPy的基础上,提供用于优化、积分、插值、信号处理、线性代数及相关数值计算任务的算法。许多例程封装了成熟的编译型程序库。Python充当协调与表达层,而计算密集型工作则在原生代码中完成。这种安排也使Python能够衔接以Fortran编程语言和C编写、长期沿用的科学软件,而不必要求科学界将每个数值计算组件都替换为Python实现。

大熊猫提供用于表格数据处理的带标签数据结构,其中最主要的是Series和DataFrame。索引对齐、分组、连接、时间序列操作和缺失数据处理等功能,使其有别于简单的二维数组。这些便利也带来了语义上的取舍:标签可能自动对齐,数据类型可能在操作后发生变化,缺失值也可能影响比较或聚合。要开展可靠的分析,就必须理解这些规则,在合并异构数据集时尤其如此。

Matplotlib等可视化库支持绘制用于探索分析和正式发表的图表,而Jupyter则提供笔记本界面,将可执行代码、说明文字、公式和输出结合在一起。笔记本是一种交互式文档,而不只是把脚本放进一些经过美化的单元格中。它的状态可能取决于执行顺序,而非界面上显示的单元格顺序,因此,要确保结果可复现,就需要关注运行环境、输入数据以及实际执行计算的顺序。

在机器学习领域,scikit-learn提供预处理、模型拟合、评估和流水线工具。PyTorch和TensorFlow支持张量计算与自动微分,大量运算由编译后的后端和加速器执行。Python通常用于定义模型结构和统筹训练过程,而矩阵运算则在图形处理器或其他设备上执行。设备间的数据传输、同步和张量形状,对性能的影响可能比外围Python语句的执行速度更大。

Python在这些领域的突出地位,并不意味着使用它就能保证分析有效。正确使用仍有赖于统计学、数值问题的条件性、实验设计,以及对训练数据和评估数据的适当划分。即使程序库准确执行了数学上明确规定的运算,整体分析仍可能存在数据泄漏(机器学习),或采用了不恰当的模型假设。这一生态系统的重要意义,在于让复杂方法易于获取和组合使用;至于科学解释与方法的正确性,则仍需另行负责把关。

Web 应用、自动化与教育

Python 广泛用于万维网的服务端。Django 提供一套集成框架,涵盖路由、数据库映射、模板、身份验证功能和管理界面。Flask 的核心则更为精简,通过扩展提供更多功能。包括 FastAPI 在内的其他框架注重带类型标注的接口和异步服务开发。这些框架提供应用结构和通信协议,并不改变 Python 的基本执行模型。

Web 服务器与框架通过标准化接口进行通信。WSGI 由 PEP 333 及后续的 PEP 3333 规定,定义了 Web 应用与服务器之间的同步接口。ASGI 支持异步交互和长连接,包括 WebSocket。应用的部署架构可能涉及反向代理、多个工作进程、任务队列和外部数据库。因此,应用处理请求的能力远不只取决于单独执行某个 Python 函数所需的时间。

自动化是 Python 的另一项主要用途。Python 脚本可用于转换文件、查询服务、采集测量数据、生成报告以及协调命令行程序。借助标准库提供的功能,可以方便地将文件系统操作、通过适当客户端发起的超文本传输协议(HTTP)请求、结构化数据和子进程结合起来。这种作用常被称为“胶水”,但集成逻辑也可能发展成规模可观的系统,其正确性取决于重试、幂等性、可观测性以及对局部故障的处理。

Python 也支持桌面应用和专业领域应用。许多标准安装都包含 Tkinter,可用来访问 Tk 图形工具包;其他 GUI 系统也有相应的 Python 绑定。Blender 在计算机图形学领域提供 Python 接口,用于自动化和扩展。地理、天文、工程和实验室软件同样使用 Python 作为扩展语言。在微控制器上,MicroPython 及相关环境支持交互式开发,但受到内存、库和硬件条件的限制。

在教育中,Python 的标点符号相对较少,并能提供即时反馈,有助于将编程入门概念与一些底层实现问题分开。学习者可以先接触变量、循环、函数、集合与算法,再学习如何显式分配内存或使用原生编译工具链。与此同时,动态类型和便捷的内置功能也可能掩盖数据表示及计算成本方面的细节。因此,不同教学方法的侧重点有所不同:有的强调解决问题,有的则着重揭示这些底层机制。

Python 并不像 JavaScript 那样,是普通 Web 浏览器原生支持的脚本语言。基于浏览器的 Python 环境通常依赖额外机制,例如编译为 WebAssembly 的解释器,或在远程服务器上执行代码。移动应用也存在类似区别:Python 可以通过框架或嵌入式解释器参与其中,但其平台工具和分发限制与操作系统厂商直接支持的语言不同。Python 的广泛适用性源于可灵活适配的实现和集成方式,而不是在所有运行时环境中都获得同等的一等支持。

安全边界与实际局限

Python 的动态机制既带来了实用的灵活性,也引出了特定的安全问题。内置函数 eval 和 exec 可以执行 Python 表达式或语句,而导入模块也可能执行模块的初始化代码。因此,将攻击者可控的输入当作可执行源代码处理,就跨越了代码执行的安全边界。仅限制几个内置函数,通常无法构建可靠的沙箱,因为对象模型和可用的运行时机制可能提供间接途径,让代码得以执行权限强大的操作。

序列化涉及另一道安全边界。对不可信数据进行 pickle 反序列化,可能通过该格式支持的对象重建机制执行任意代码。这是设计层面的问题,而非偶发的解析器缺陷:pickle 的设计目的是重建 Python 对象,而不是为恶意输入提供安全的数据交换格式。即使是看似只承载数据的格式,也需要考虑解析器行为、资源消耗和应用层验证。

自动内存管理并不能消除应用程序漏洞。Python 程序仍可能存在 SQL 注入、shell 命令注入、不安全的路径处理、授权错误和敏感信息泄露等问题。参数化的 SQL结构化查询语言查询将数据值与查询结构分离;而子进程的行为则会因是否由 shell 解析命令字符串而有所不同。Web 应用框架提供的防护措施,只有在其文档所述的前提条件下才有效。身份认证和访问控制仍然是应用程序与系统设计需要解决的问题。

原生扩展扩大了安全攻击面。纯 Python 代码通常无法进行任意指针运算,但 C 扩展可能存在缓冲区溢出,也可能错误地处理对象生命周期。解释器本身、外部库和二进制依赖项都需要维护。安装依赖项也意味着信任其发布者和构建链;恶意软件包、遭入侵的账户以及具有欺骗性的名称,都是软件供应链风险,无论应用程序自身的 Python 源代码写得多好,这些风险都依然存在。

Python 3.8 通过 PEP 578 引入了审计钩子,可将特定运行时事件提供给监控工具,并支持与安全系统集成。但仅靠审计钩子,无法为任意恶意代码建立完整的隔离边界。强隔离通常依赖常规语言语义之外的机制,例如独立进程、受限的操作系统权限以及受控的执行环境。虚拟环境能够隔离软件包的安装,但并不提供这种安全隔离。

Python 还存在一些与恶意输入无关的工程局限。对象开销可能导致包含大量小型 Python 值的集合占用较多内存。解释器的指令分派开销可能使细粒度的 CPU 密集型循环执行成本较高,而垃圾回收和操作系统调度则使常规 Python 执行无法提供硬实时保证。原生代码、专用数组、进程隔离和其他实现可以应对某些特定限制,但每一种方案都会改变部署和维护时需要面对的问题。因此,合理的系统设计必须依据实际工作负载、延迟要求、信任边界和具体实现,而不能仅凭语言名称作出判断。