Python

Python，是一种广泛使用的解释型、高级和通用的编程语言。Python支持多种编程范型，包括结构化、过程式、反射式、面向对象和函数式编程。它拥有动态类型系统和垃圾回收功能，能够自动管理内存使用，并且其本身拥有一个巨大而广泛的标准库。它的语言结构以及面向对象的方法，旨在帮助程序员为小型的和大型的项目编写逻辑清晰的代码。

吉多·范罗苏姆于1980年代后期开始研发Python，作为ABC语言的后继者，它也可以被视为采用了叫做M-表达式的中缀表示法的一种LISP方言。吉多·范罗苏姆于1991年首次发布 Python 0.9.0。Python 2.0于2000 年发布并引入了新功能。Python 3.0于2008年发布，它是该语言的主要修订版，并非完全向后兼容。Python 2于2020年随2.7.18版停止支持。

Python的设计哲学，强调代码的可读性和简洁的语法，尤其是使用空格缩进来划分代码块。相比于C语言或Java，Python让开发者能够用更少的代码表达想法。

Python解释器本身几乎可以在所有的操作系统中运行，它的官方直译器CPython是用C语言编写的。Python是一个由社群驱动的自由软件，目前由Python软件基金会管理。Python是最受欢迎的编程语言之一。

## 历史

Python的创始人吉多·范罗苏姆，在1982年至1995年间，参与了荷兰数学和计算机科学研究学会多个项目的工作。1989年的圣诞节期间，他决心开发一个新的脚本解释程式，作为ABC语言的后继者，并且用它替代Unix shell和C语言来进行系统管理，担负与Amoeba (操作系统)之间的交互操作并进行例外处理。他是BBC电视剧《Monty Python的飞行马戏团》的爱好者，所以选取了Python作为这个编程语言的名字。范罗苏姆作为Python的主要开发者，独自担负这个项目的发展决策者职责，直到2018年7月12日，他宣布从终身仁慈独裁者（BDFL）的职位上“永久休假”。他参与了2019年第一届领导项目发展的五人掌控委员会。

在1991年2月，范罗苏姆在Usenet新闻组alt.sources上发布了标记为版本0.9.0的最初代码，这时就已经存在了带继承的类、例外处理、函数和核心类型`list`、`dict`、`str`等。在这个最初发行中就有了从Modula-3引进的模块系统，和例外处理机制。在1994年1月，Python 1.0发布，其主要新特征是由Amrit Prem提供的函数式编程工具`lambda`、`map`、`filter`和`reduce`。受Modula-3启发，版本1.1介入了参数缺省值，版本1.3介入了关键字参数。版本1.4介入了对复数的内建支持。

在2000年10月，Python 2.0发布，它从函数式编程语言Haskell中引进了列表推导式。版本2.1支持了静态嵌套作用域。版本2.2进行了重大革新，将Python中用C语言写成的类型，和用Python语言写成的类，统一成在同一个层级中，使得Python的对象模型成为纯粹而一致的对象模型；还介入了迭代器，受CLU和Icon启发的生成器，和描述器协议。版本2.3介入了从Dylan引进的方法决定次序。版本2.4介入了集合 (抽象数据类型)类型，和函数修饰器。版本2.5在官方实现中介入了抽象语法树。

在2008年12月，Python 3.0发布，它对语言做了较大修订而不能完全后向兼容，尽管提供了进行自动转换的`2to3`实用工具，仍有大量现存代码不能移植，故而版本2.7的产品寿命结束延期至2020年元旦。版本3.4介入了异步I/O模块。版本3.5介入了类型提示，和采用async/await语法的协程。版本3.8介入了赋值表达式。

在2020年10月，版本3.9介入了内建的针对容器类的泛化别名（`types.GenericAlias`）类型，并在官方实现中介入了新的语法解析器。版本3.10介入了从Haskell和OCaml等借鉴来的结构式模式匹配，和内建的联合类型（`types.UnionType`）。版本3.11对官方实现进行了优化提速。版本3.12介入了类型参数语法，并废弃或移除了一些过时的模块和功能。

在2024年10月，版本3.13介入了从PyPy引进的新交互式解释器，实验性的支持了即时编译器和自由线程。版本3.14正式支持了自由线程的官方实现构建选项，并增加了使用尾调用的官方实现新类型的解释器。版本3.15介入了对模块的显式惰性导入。

目前每个版本首次发行后，享有2年的完全支持，随后是3年的安全支持。当前只有Python 3的稳定版本3.13与3.14正在被完全支持，但仍提供对版本3.10、3.11和3.12的安全性修正。

自从2003年，Python始终排行于TIOBE编程社区索引前十最流行编程语言，在2021年10月它首次达到了第一名最流行语言（居于C和Java之前），并被选为2007年、2010年、2018年、2020年、2021年和2024年的年度编程语言。

在2025年12月，活跃的Python核心开发者，选举Pablo Galindo Salgado、Savannah Ostrowski、Barry Warsaw、Donghee Na和Thomas Wouters，为2026年度掌控委员会的五位成员来领导这个项目。

## 特征与设计哲学

Python是多范型编程语言。它完全支持结构化编程和面向对象编程，还有很多特征支持函数式编程和元编程比如元对象协议（元类和魔术方法）。通过扩展还可以支持很多范型，包括面向方面编程、契约式设计和逻辑编程。

Python使用动态类型，在内存管理上采用的垃圾回收器基于了引用计数，并且结合了检测环引用的分代垃圾回收优化。它的特征还有动态名字解析（后期绑定），即在程序执行期间绑定方法和变量的名字。

Python对遵循LISP传统的函数式编程提供了有限的支持，它提供了 `map`、`filter`和`reduce`函数；列表推导式、字典推导式、集合 (抽象数据类型)推导式和生成器表达式。标准库中的模组`functools`和`itertools`，实现了从Haskell和Standard ML借鉴来的函数式工具。

Python的设计理念是“优雅”、“明确”、“简单”，它的一些重要准则被合称为“Python之禅”。在Python解释器内运行`import this`可以获得完整的列表，下面举出其中首要：

- 优美优于丑陋。明了优于隐晦。
- 简单优于复杂。复杂优于凌乱。
- 扁平优于嵌套。稀疏优于稠密。
- 可读性很重要。

Python开发者的方法论是“用一种方法，最好是只有一种方法来做一件事”，显著不同于以Perl语言为代表的“不止一种方法去做一件事”风格。Python开发者在设计语言时，如果面临多种选择，一般会选择明确没有或者很少有歧义的语法。

范罗苏姆将Python本身设计为可扩充的，并不把所有的特性和功能都集成到语言核心，而是提供了丰富的API和工具，以便程序员能够轻松地使用Python、C语言、Cython来编写扩充模组。Python还可以通过外界函数接口如标准库中的ctypes等，来提供C语言兼容数据类型，并访问动态链接库或共享库中的函数，从而对用其他语言编写的程式进行集成和封装。

在Python的官方解释器实现CPython中，一般避开不成熟的或者对非重要部位的加快运行速度的优化。在某些对运行速度要求很高的情况，可以使用具备即时编译技术的解释器。

## 语法和语义

Python为了让程式码具备高度的可阅读性，在设计时尽量使用了其它语言常用的符号和英文单字。

### 行结构

Python程序在词法分析上被分成若干逻辑行。简单语句包含在一个单一的逻辑行之内，Python支持使用分号作为分隔符，将多个简单语句合并入一个逻辑行之中。

注释开始于并非字符串文字一部分的一个井号`#`，并结束于物理行结尾；注释标示逻辑行的结束，除非已受制于隐式行接续规则；注释在语法上被忽略。

Python支持使用反斜杠作为行接续符，将多个物理行合成为一个逻辑行。在圆括号、方括号或花括号之中的表达式，可以分裂跨越多于一个物理行而不使用反斜杠，这被称为“隐式行接续”。

### 缩排

Python语法中的复合语句，包含了一些其他语句，它们以某种方式影响或控制这些其他语句的执行。Python的复合语句包含一个或多个子句（clause），子句构成自一个头部（header）和一个套件（suite）。特定复合语句的子句头部都在同样的缩排层级上，每个子句头部开始于一个唯一标识关键字，并结束于一个冒号。套件即语法意义上的块，是这个子句所控制的一组语句。

套件有两种形式：可以是与头部在同一行上的一个或多个由分号分隔的简单语句，它们跟随在这个头部的冒号之后；或者是遵循越位规则的在连续诸行上的一个或多个缩排的语句，只有这种套件形式可以包含嵌套的复合语句。缩排示例：

```python
def is_even(a: int) -> bool:
    """确定数a是否是偶数."""
    if a % 2 == 0:
        print('偶数!')
        return True
    print('奇数!')
    return False

# 参数比后续部份多一层缩进
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    # 可选的圆括号内后续行多一层缩进
    if (this_is_first_thing
            and that_is_second_thing):
        do_something()
    # 可选的圆括号内后续行不额外缩进
    elif (this_is_third_thing and
          that_is_fourth_thing):
        do_something_different()
# 参数相对行首缩进一层
spam = long_function_name(
    arg_one, arg_two,
    arg_three, arg_four)
# 参数按开括号界定垂直对齐
eggs = long_function_name(arg_one, arg_two,
                          arg_three, arg_four)
# 可选的闭括号位置
my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
# 可选的闭括号位置
my_set = {
    1, 2, 3,
    4, 5, 6,
}
```

根据PEP 8的规定，使用4个空格来表示每级缩排。

缩排层级的变迁，被用来生成语法解析器才能见到的`INDENT`和`DEDENT`记号，增加缩排就生成`INDENT`记号，减少缩排就生成`DEDENT`记号。二者的作用相当于C语言家族的花括号，或Pascal语言家族的关键字`begin`和`end`。

### 关键字

Python有如下35个关键字；它们不能用作标识符：

- `and`、`as`、`assert`、`async`、`await`｜、`break`、`class`、`continue`、`def`、`del`｜、`elif`、`else`、`except`、`False`、`finally`｜、`for`、`from`、`global`、`if`、`import`｜、`in`、`is`、`lambda`、`None`、`nonlocal`｜、`not`、`or`、`pass`、`raise`、`return`｜、`True`、`try`、`while`、`with`、`yield`

内建常量`True`、`False`和`None`于Python版本3.0中成为关键字，关键字`nonlocal`介入于版本3.0，关键字`async`和`await`介入于版本3.5，并在版本3.7中成为正式关键字。

在Python中，将只在特定上下文中保留的标识符，称为“软关键字”：

- `match`、`case`和通配符`_`，介入于版本3.10，它们在与模式匹配语句有关的上下文中，可以在语法上充当关键字；但是这种区分只在语法解析器层次进行，并非在词法分析记号化层次。
- `type`，介入于版本3.12，它用于`type`语句。
- `lazy`，介入于版本3.15，它用于`import`语句。

### 标识符

标识符就是名字，在ASCII范围内（U+0001..U+007F），可用于标识符的字符为：大写字母`A`至`Z`和小写字母`a`至`z`，下划线`_`以及数字`0`至`9`，但首字不可以用数字。如下命名约定，是为“保留标识符类”：

- `_spam`（单下划线开头）：弱“内部使用”标识。对于`from M import *`，将不导入所有以下划线开头的对象。
- `spam_`（单下划线结尾）：为了避免与python关键字的命名冲突。
- `__spam`（双下划线开头）：在命名一个类特性的时候，采用名字修饰，比如在类`SpamEggs`内，`__spam`将变成`_SpamEggs__spam`。
- `__spam__`（双下划线开头结尾）：指那些包含在用户控制的命名空间中的“魔术”方法或特性，比如`__delattr__`、`__dir__`、`__doc__`、`__getattribute__`、`__init__`、`__new__`、`__repr__`、`__setattr__`、`__sizeof__`等。建议永远不要将这样的命名方式应用于自己的变量或函数。

### 语句

Python的语句包括简单语句：

- 赋值语句，采用的中缀记号是等号`=`。赋值语句被用来将名字绑定（含重新绑定）到值，以及用来修改可变对象的特性或项目。赋值语句支持链式赋值，自从版本3.6介入了标注赋值语句。
- Python还支持增广赋值语句，将一个二元运算和一个赋值语句合并成一个单一语句，例如`x += 1`。
- Python支持“序列解包”：在等号左侧可以是一个表达式列表，其中每个表达式都可求值成能被赋值的东西；在等号右侧相应的是一个“可迭代”对象，它在被迭代时产生的值的数量，同于左手侧可写表达式的数量；赋值语句对这个对象进行迭代，将产生的每个值分别赋值给左侧对应的可赋值者。在等号右侧直接包装出序列解包所要求的元组，就形成了并行赋值。序列解包示例：

```pycon
>>> a = [1, 2, 3]
>>> i, j, k = a
>>> print(i, j, k)
1 2 3
```

采用了并行赋值的斐波那契数列函数示例：

```Python
def fib(n):  # 写出从第0项到第n项的Fibonacci系列
    a, b, i = 0, 1, 0 
    while i <= n:
        print(a, end=' ')
        a, b, i = b, a+b, i+1
    print()
```

- 表达式 (计算机科学)语句，用来交互式的计算并写出一个值，或者用来调用一个过程（即返回无含义结果的函数），在Python中过程返回值`None`。
- `global`语句，是在整个当前代码块中成立的声明，它意味着随后列出的标识符被解释为全局变量。
- `nonlocal`语句，导致随后列出的标识符，提及在除了全局作用域之外的最近包围作用域中的先前绑定变量。
- `del`语句，递归的进行删除。
- `type`语句，声明作为类型别名类型（`typing.TypeAliasType`）的实例的一个类型别名。
- `pass`语句，充当无操作指令，表示此行为空，不执行任何操作。
- `assert`语句，用于程式调适阶段时测试执行条件是否满足。
- `continue`语句，越过这次迭代并继续进行下个项目。
- `break`语句，从循环中跳出。
- `raise`语句，抛出一个例外。
- `return`语句，用来从函数返回值。当函数执行到`return`语句时，它会停止执行并将指定的值返回给调用者。
- `yield`语句，用来从一个生成器中返回一个值，`yield`语句在语义上等价于加圆括号的`yield`表达式，在函数主体中使用`yield`表达式将导致它成为生成器函数。产生素数的惰性生成器的示例：

```python
from itertools import count

def generate_primes(stop_at=0):
    if stop_at != 1:
        primes = [2]
        yield 2
    for n in count(3, 2):
        if 0 < stop_at < n:
            return # 引发StopIteration例外
        composite = False
        for p in primes:
            if not n % p:
                composite = True
                break
            elif p ** 2 > n:
                break
        if not composite:
            primes.append(n)
            yield n
```

上述函数的隐式迭代用例：

```python
for i in generate_primes():  # 迭代于100以内所有素数上
    if i > 100:
        break
    print(i)
```

在生成器表达式中使用上述函数，定义了一个惰性的、巨大而并非无限的搜集的示例：

```python
from itertools import islice

primes_under_million = (i for i in generate_primes() if i < 1000000)
two_thousandth_prime = islice(primes_under_million, 1999, 2000) 
print(next(two_thousandth_prime))
```

- 通过生成器的`send()`方法传入的信息，就是其中`yield`表达式的返回值。下面的示例用生成器模拟协程：

```Python
def produce(n):
    try:
        for item in range(n):
            print(f'producing item {item} ->') 
            yield item
    except GeneratorExit:
        return

def consume():
    item = None
    try:
        while True:
            item = yield item
            print(f'consuming item {item} <-')
    except GeneratorExit:
        return

def main():
    r = []
    t1 = produce(10)
    t2 = consume()
    try:
        next(t2)
        while True:
            p = next(t1)
            r += [t2.send(p)]
    except StopIteration:
        t2.close()
    print(f'result items: {r}')

main()
```

- 自从版本3.3，介入了`yield from`语句，它在语义上等价于加圆括号的`yield from`表达式，含有此表达式的生成器函数将特定任务委托给另一个子生成器函数，将传入信息递送给它并直接回传它产生的值。
- 自从版本3.6，在协程函数主体中使用`yield`表达式将导致它成为异步生成器函数。
- `import`语句，导入一个模块或包，它组合了两种操作，查找指名的模块，接着将找到的结果绑定到在局部作用域中的名字。导入语句有三种形式（下述语句样本采用了EBNF，这里的方括号表示其中内容为可选的）：
- `import <small>模块名字</small> <small>[</small>as <small>别名</small><small>]</small>`，找到一个模块，装载它，如果有需要的话初始化它；在这个导入语句出现的作用域的局部名字空间中，定义一个名字或一些名字。
- `from <small>模块名字</small> import <small>定义1</small> <small>[</small>as <small>别名1</small><small>]</small>, <small>定义2</small> <small>[</small>as <small>别名2</small><small>]</small>, …`，找到、装载、必需时初始化一个模块；接着在局部名字空间中，增加到找到指名特性的引用。
- `from <small>模块名字</small> import *`，在导入语句出现的作用域的局部名字空间中，绑定模块中定义的所有公开的名字。

复合语句：

- `if`语句，当条件成立时执行语句套件。它经常包含`elif`、`else`子句。
- `while`语句，当条件为真时，重复执行语句套件。
- `for`语句，遍历列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
- `match`语句，用于模式匹配。
- `class`语句，是定义类的可执行语句。
- `def`语句，是定义函数和方法的可执行语句。
- `async def`语句，用于协程函数定义。`await`表达式、`async for`语句和`async with`语句，只能用在协程函数的主体中。原生的协程示例：

```Python
import asyncio
import random

async def produce(queue, n):
    for item in range(n):
        # 生产一个项目，使用sleep模拟I/O操作
        print(f'producing item {item} ->') 
        await asyncio.sleep(random.random())
        # 将项目放入队列
        await queue.put(item)
    # 指示生产完毕
    await queue.put(None)

async def consume(queue):
    while True:
        # 等待来自生产者的项目
        item = await queue.get()
        if item is None:
            break
        # 消费这个项目，使用sleep模拟I/O操作
        print(f'consuming item {item} <-')
        await asyncio.sleep(random.random()) 

async def main():
    queue = asyncio.Queue()
    task1 = asyncio.create_task(produce(queue, 10))
    task2 = asyncio.create_task(consume(queue))
    await task1
    await task2

asyncio.run(main())
```

- `例外处理语法`语句，它经常包含`except`、`else`、`finally`子句，处理在程式执行中出现的例外情况。版本3.11介入了`except*`子句。Python支持并广泛使用EAFP（请求原谅比获得许可更容易）风格的例外处理，作为检测错误状况和程序中其他“例外”事件的方式。例如：在访问一个文件或资源之时，事先不进行测试就尝试使用它，事后再捕获可能的访问失败所引发的例外。遵循EAFP（请求原谅比获得许可更容易）风格的例外处理示例：

```python
f = None
try:
    f = open("aFileName", mode="w")
    f.write(could_make_error()) # 不存在could_make_error()则产生错误
except IOError as error:
    print(error)
    print("不能打开文件")
except:  # 捕获所有例外
    print("未预期的错误")
else:  # 在没有出现例外时执行
    print("文件写入完全成功")
finally:  # 清除行动，总是执行
    if f:
        f.close()
```

- `with`语句，把一块代码包裹在一个上下文管理器之内。它允许了RAII（对象初始化时获取资源）方式的行为，可替代常见的`try`/`finally`编程惯用法。Python使用`with`语句处理资源，例如：在执行一块代码时，事先获取一个锁，并且事后释放这个锁；或事先打开一个文件，并且事后关闭这个文件。使用`with`将文件作为资源来管理的示例：

```python
from contextlib import contextmanager
@contextmanager
def opened(filename, mode="r"):
    try:
        f = open(filename, mode)
    except IOError as error:
        print(error)
        yield None
    else:
        try:
            yield f
        finally:
            f.close()

with opened("aFileName", mode="w") as f:
    try:
        f.write(could_make_error()) # 不存在could_make_error()则产生错误
    except AttributeError:
        print("不能打开文件")
    except:  # 捕获所有例外
        print("未预期的错误")
    else:  # 在没有出现例外时执行
        print("文件写入完全成功")
```

### 块与模块

在Python的执行模型中，程序构造自块（也称为代码块）。块是作为一个单元执行的Python程序文本，模块、函数主体和类定义都是块。交互式键入的每个命令、脚本文件和脚本命令都是块。传递给内建函数`eval()`和`exec()`执行的字符串是块。块在执行框架（frame）中执行。框架包含一些用于调试的管理信息，并确定在这个块执行完成后，执行在何处以及如何继续。

模块是包含Python定义和语句的一个文件，这个文件名字是模块名字附加上后缀`.py`；在一个模块中，模块的名字（作为字符串）可获得为全局变量`__name__`的值。包（package）是可以包含子模块或递归性的子包的模块。包在技术上是具有`__path__`特性的Python模块。可以将包视为文件系统上的目录，而将模块视为这种目录中的文件，但是包和模块不必然源自文件系统。

名字即标识符，是通用的引用持有者，它不关联于一个固定的数据类型，但是，一个名字在给定时间，总是被绑定到有一个类型的某个对象上，这就是动态类型的特征。名字的存储位置不“包含”所指示的值，一个共同的值可以赋值给多个名字，一个名字在任何时候，都可以重新绑定到各种不同类型的对象上，包括字符串、过程、具有数据和方法的复杂对象等。

如果一个名字绑定在一个块中，它是这个块的局部变量，除非被声明为`nonlocal`或`global`。如果一个名字绑定在模块层次，它是全局变量。模块对应的块的变量，既是局部的也是全局的。如果一个变量使用在一个块中，却不定义在这里，它是自由变量。

在Python中，赋值所进行的操作，是将一个名字绑定为到一个分立的动态分配的对象的一个引用。

作用域定义一个名字在一个块中的可见性。如果一个局部变量被定义在一个块中，它的作用域包括这个块。如果这个定义出现在一个函数块中，作用域扩展到在所界定作用域内包含的任何块，除非所包含的块为这个名字介入了不同的绑定。对一个块可见的所有这种作用域的集合，叫做这个这个块的“环境”。

当一个名字在一个块之中使用，它采用最近包围作用域来解析。如果一个名字绑定在一个块中，并且在其中于绑定之前就被使用，会导致一个错误。局部变量示例：

pycon

>>> def spam():

... print(a)

...

>>> a = 10

>>> spam()

10

>>> def spam():

... a = 100

... print(a)

...

>>> spam()

100

>>> a

10

>>> def spam():

... a *= 10

... print(a)

...

>>> spam()

Traceback (most recent call last):

File "", line 1, in

File "", line 2, in spam

UnboundLocalError: cannot access local variable 'a' where it is not associated with a value

当一个函数或类的定义被嵌套到其他函数的定义之内，它的非局部作用域就是这个包围函数的局部作用域。`nonlocal`语句导致其列出的标识符，提及在非局部作用域内先前绑定的名字（即非局部变量）。非局部变量示例：

```pycon
>>> def spam():
...     def eggs():
...         nonlocal a
...         a *= 10
...         print(a)
...     a = 10
...     eggs()
... 
>>> spam()
100
>>> def spam():
...     def eggs():
...         nonlocal a
...         a *= 10
...         print(a)
...     global a
...     eggs()
... 
  File "<stdin>", line 3
SyntaxError: no binding for nonlocal 'a' found
```

名字空间是存储变量的地方，它被实现为字典。有局部名字空间、全局空间即包含这个块对应的模块的名字空间，和内建名字空间即模块`builtins`的名字空间；对象的方法是定义在类主体内的函数，它有着嵌套的名字空间。名字空间通过防止命名冲突而支持了模块性，还通过明晰了哪个模块实现了哪个函数而增进可读性和可维护性。

如果`global`语句出现在一个块之中，在这个语句中指定的所有名字，提及在顶层名字空间中这些名字的绑定。名字在顶层名字空间解析，首先查找全局名字空间，未果查找内建名字空间。`global`语句与在同一个块中的名字绑定运算有同样的作用域。如果一个自由变量的最近包围作用域包含针对它的`global`语句，这个自由变量被当作全局的。全局变量示例：

```pycon
>>> def spam():
...     global a
...     a *= 10
...     print(a)
... 
>>> a = 10
>>> spam()
100
>>> a
100
>>> def spam():
...     def eggs():
...         print(a)
...     global a
...     eggs()
... 
>>> a = 10
>>> spam()
10
>>> def spam():
...     def eggs():
...         a *= 10
...         print(a)
...     global a
...     eggs()
... 
>>> spam()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in spam
  File "<stdin>", line 3, in eggs
UnboundLocalError: cannot access local variable 'a' where it is not associated with a value
```

### 表达式

Python的表达式 (计算机科学)主要包括如下：

- 在Python中，表达式的最基本元素被称为原子，最简单的原子是文字 (计算机编程)或标识符。由逗号`,`分隔的一系列表达式，叫做表达式列表。
- 在Python中，加圆括号（parenthesized）形式被归类为原子，它是包围在圆括号中的可选的表达式列表。加圆括号的表达式列表产生的东西，就是这个表达式列表所产生的：如果这个列表包含至少一个逗号，例如`(a,b,c)`，则它产生一个元组；否则它产生的就是这个单一表达式，例如`(a)`产生`a`。要表示仅有单个元素的元组，需要给这个元素后缀一个逗号，例如`(a,)`。空的圆括号产生空元组对象。元组不是圆括号形成的，而是使用逗号形成的，在没有歧义的情况下，元组的圆括号是可选的。
- Python提供了称为展示（display）的特殊语法来构造列表、字典或集合 (抽象数据类型)，展示被归类为原子，并且有两种方式：要么其所包容的元素是显式的列举出来的，要么它们是通过叫做“推导式”的特定循环和过滤指令运算出来的。列表展示，是包围在方括号中的可以为空的一系列表达式，例如`[a,b,c]`。字典展示，是包围在花括号中的可能为空的一系列的用冒号`:`分隔的键-值对。集合 (抽象数据类型)展示，是包围在花括号中的一系列表达式。通过表达式列表建立元组示例：

```python
a_tuple = 1, 2, 3, 'four'
```

通过列表展示建立列表示例：

```python
a_list = [1, 2, 3, 'a dog']
```

通过字典展示建立字典示例：

```python
a_dictionary = {'key 1': 'value 1', 2: 3, 4: []}
```

通过集合展示建立集合示例：

```python
some_set = {0, (), False}
```

- Python支持列表推导式和更一般性的生成器表达式，Python 3.0增补了字典推导式和集合推导式。列表推导式示例：

```Pycon
>>> [x + 3 for x in range(4)]
[3, 4, 5, 6]
```

使用列表推导式可以优雅的将快速排序算法表达为：

```python
def qsort(L):
    if L == []:
        return []
    pivot = L[0]
    return (qsort([x for x in L[1:] if x < pivot])
        + [pivot]
        + qsort([x for x in L[1:] if x >= pivot]))
```

生成器表达式示例：

```Pycon
>>> sum(x * x for x in range(10))
285
>>> dict((n, n*n) for n in range(5))
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> set(n*n for n in range(5))
{0, 1, 4, 9, 16}
```

字典推导式示例：

```Pycon
>>> {x: x + 3 for x in range(4)}
{0: 3, 1: 4, 2: 5, 3: 6}
```

集合推导式示例：

Pycon

{3, 4, 5, 6}

自从版本3.5，介入了在表达式列表中的“可迭代解包”`*`，和在字典展示中的“字典解包”`**`。可迭代解包和字典解包示例：

```Pycon
>>> a = [1, 2, 3]; b = [4, 5]
>>> c = [*a, b]
>>> c
[1, 2, 3, [4, 5]]
>>> d = {*a, *b}
>>> d
{1, 2, 3, 4, 5}
>>> e = (*a, *b)
>>> e
(1, 2, 3, 4, 5)
>>> f = {'as':1, 'bs':2 }; g = {'cs':3, 'ds':4}
>>> h = {**f, **g}
>>> h
{'as': 1, 'bs': 2, 'cs': 3, 'ds': 4}
```

- Python对容器类实例，比如序列类型的列表、元组或字符串，支持形如`a[<small>索引</small>]`的下标，和形如`a[<small>开始</small>:<small>停止</small>]`或`a[<small>开始</small>:<small>停止</small>:<small>步长</small>]`的阵列分片。此二者与函数调用和特性引用，一起被归类为表示语言中最紧密运算绑定的初等项（primary）。这里的下标索引是基于零的，负数是相对于结尾的。分片范围自从开始索引，直到但不包括停止索引，分片的第三个步长参数，允许元素被跳过和用负数指示反向。分片的每个元素都是对象复制的。分片索引可以省略，例如`a[:]`，这返回整个列表的一个复本。列表分片示例：

```Pycon
>>> nums = [0, 1, 2, 3, 4, 5, 6]
>>> nums[2:5]  #从下标2的元素剪切直到下标5之前的元素
[2, 3, 4]
>>> nums[1:]  #从下标1的元素剪切直到末位元素
[1, 2, 3, 4, 5, 6]
>>> nums[:-3]  #从首位元素剪切直到倒数第3个元素之前的元素
[0, 1, 2, 3]
>>> nums[:]  #复制所有元素
[0, 1, 2, 3, 4, 5, 6]
>>> nums[::-1]  #反转所有元素
[6, 5, 4, 3, 2, 1, 0]
>>> nums[1:5:2]  #从下标1的元素剪切直到下标5之前的元素且步长为2
[1, 3]
```

- 在Python中，算术运算的加法`+`、减法`-`、乘法`*`，与C语言和java相同的。除法和模除`%`的行为有所不同，在Python中有两种除法：除法`/`和下取整除法`//`。Python增加了指数算符`**`。自从版本3.5，介入了矩阵乘法算符`@`，它已经用于了NumPy库。中缀算符`+`、`-`，还可以分别表示取原数和取相反数的一元算符。
- 在Python中，有如下必须用于整数的位运算：AND（与）`&`、OR（或）`|`、NOT（非）`~`、XOR（异或）`^`、右移`>>`、左移`<<`。
- 在Python中，有如下比较运算：大于`>`、小于`<`、大于等于 `>=`、小于等于`<=`、等于`==`、不等于`!=`，用来比较两个对象的值的大小。Python有同一性测试算符：`is`、`is not`，用来比较两个运算元是否引用了同一个对象；还有成员关系测试算符：`in`、`not in`，用于判断一个对象是否属于另外一个对象。Python允许由比较运算链接起来的布尔表达式，比如`a < b < c`，它测试`a < b and b < c`；C语言将它解析为`(a < b) < c`：即首先求值`a < b`得出结果`0`或`1`，接着将此结果比较于`c`。
- Python使用`and`、`or`、`not`表示逻辑运算与、或、非，不采用C语言和Java中所用的符号`&&`、`

`、`!`。

- Python的条件表达式表示为`x if c else y`。意思是当`c`为真时，表达式的值为`x`，否则表达式的值为`y`。在运算元的次序上不同于很多其他语言中常见的`c ? x : y`。
- Python的`lambda`表达式是匿名函数，其函数体只能是一个表达式。`lambda`表达式示例：

```Pycon
>>> from functools import reduce
>>> reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 
15
>>> fac = lambda n: (1 if n<2 else n*fac(n-1))
>>> fac(5)
120
>>> [*map(fac, [1, 2, 3, 4, 5])]
[1, 2, 6, 24, 120]
```

不动点组合子和邱奇编码可参见专门介绍。

- 自从版本3.8，介入了赋值表达式，其记号是`:=`。它将一个表达式赋值给一个标识符，同时还返回这个表达式的值。

Python中运算符具有优先级，下表中的运算符按照从最高（最先绑定）到最低（最后绑定）的次序列出。在相同单元格中运算符具有相同的优先级，它们从左至右结合，除了指数表达式和条件表达式从右至左结合之外：

运算符｜描述

`(<small>表达式</small> …)`，`[<small>表达式</small> …]`，`{<small>键</small>: <small>值</small> …}`，`{<small>表达式</small> …}`｜绑定或加圆括号表达式，列表展示，字典展示，集合展示

`x[<small>索引</small>]`，`x[<small>索引</small>:<small>索引</small>]`，`x(<small>参数</small> …)`，`x.<small>特性</small>`｜下标，分片，调用，特性引用

`await x`｜`await`表达式

`**`｜指数

`+x`，`-x`，`~x`｜取原数，相反数，逐位NOT

`*`，`@`，`/`，`//`，`%`｜乘法，矩阵乘法，除法，下取整除法，余数

`+`，`-`｜加法和减法

`<<`，`>>`｜移位

`&`｜逐位AND

`^`｜逐位XOR

`|`｜逐位OR

`in`，`not in`，`is`，`is not`，`<`，`<=`，`>`，`>=`，`!=`，`==`｜包含成员关系测试，同一测试，各种比较

`not x`｜布尔NOT

`and`｜布尔AND

`or`｜布尔OR

`… if … else …`｜条件表达式

`lambda`｜`lambda`表达式

`:=`｜赋值表达式

Python为序列提供了串接算符`+`和倍增算符`*`。自从版本3.9，介入了字典归并算符`|`和字典更新算符`|=`。

Python为集合 (抽象数据类型)提供了集合论运算：并集`|`、交集`&`、相对补集`-`、对称差`^`，和子集测试`<=`、真子集测试`<`、超集测试`>=`、真超集测试`>`。

在Python中，语句不能成为表达式的一部分，表达式比如列表推导式和字典推导式以及`lambda`表达式，都不能包含语句。这个限制的一个示例：赋值语句比如`a = 1`，不能用作条件语句的条件判断表达式的一部分；这能够避免C语言编程中的一个常见错误，即在条件判断时把等于算符`==`误写为赋值算符`=`，这不是预期代码却在语法上有效而能通过C语言编译器检查，在Python中这会导致一个语法错误。

#### 数值运算

Python的二元算术运算，先将两运算元转为共同类型，加法、减法、乘法、下取整除法、模除和指数运算的结果也采用此类型，举下取整除法`//`例子：`5//2 == 2`而`5.0//2 == 2.0`。自从Python 3.0，除法`/`总是产生浮点数结果，例如`5/2 == 2.5`。

下取整除法`//`的修约是朝向负无穷的，这意味着等式(a + n)//n == a//n + 1在`n != 0`条件下永远成立；很多其它编程语言比如C99，其整数除法采用截尾取整规则，不能保证这个等式永远成立。Python提供了`round()`内建函数，用于把一个浮点数修约成最近的整数，自从Python 3.0，为了打破平局它采用了IEEE 754的约半成偶规则，例如`round(1.5) == 2 == round(2.5)`。

Python的模除`%`运算结果余数的定义，需要确使等式a == (a//n)*n + a%n在`n != 0`条件下永远成立；由于`//`采用下取整规则，`%`所得余数的符号同于除数，例如`-5%2 == 1`而`5%-2 == -1`。数学中的欧几里得除法，其余数总是非负数。很多其它语言的整数除法采用截尾取整规则，其模除所得余数的符号同于被除数。

Python对所有整数运算，使用任意精度算术。在`decimal`模块中的`Decimal`类，提供十进制浮点数，具有用户可按需要而更改的缺省28个十进制有效数位精度，并有多种修约方式。在`fractions`模块中的`Fraction`类，提供任意精度的有理数。第三方库gmpy2，提供了到任意精度计算库GMP/MPIR (数学软件)、GNU MPFR和MPC的接口。

除了求绝对值函数`abs()`列入内建函数之外，大多数数学函数，处于`math`和`cmath`模块内。前者用于实数运算，而后者用于复数运算。Python有着广泛的数学库，特别是第三方库NumPy进一步扩展了固有能力。

#### 字符串操作

Python的文本序列类型，包括字符串`str`和字节序列`bytes`与`bytearray`。文本序列的文字有多种写法：

- 短字符串文字，由单引号`'`或双引号`"`界定。不同于Unix shell、Perl和受Perl影响的语言，单引号和双引号功能相同。这二种字符串都使用反斜杠`\`作为转义字符。
- 长字符串文字，是开始并结束于三个单引号`'''`或三个双引号`"""`的序列。它们可以跨越多行，其功能就像shell、Perl和Ruby中的here文档。
- 字节文字 (计算机编程)总是前缀上一个`b`或`B`，它产生`bytes`类型的实例。它们只可以包含ASCII字符，其数值大于等于`128`的字节必须通过转义来表达。
- 字符串文字或字节文字都可选的能前缀上一个`r`或`R`，这叫做字符串文字#原始字符串。转义序列不被解释，因此在文字反斜杠常见的地方很有用，比如正则表达式和Windows风格的路径。
- Python允许多个毗邻的字符串文字或字节文字（它们以空白分界并可以使用不同的引述约定），在编译时间于语法层面上串接起来。要在运行时间串接字符串，必须使用序列串接算符`+`。

自从Python 3.0，字符串类`str`提供了内容格式化方法`format()`，例如`"spam={0} eggs={1:04d}".format("blah", 2)`，它求值为`'spam=blah eggs=0002'`。格式化方法被推荐用来替代早先的字符串对象内建格式化算符`%`，它在功能上类同于C语言中的`printf`格式化字符串，例如`"spam=%s eggs=%04d" % ("blah", 2)`。

自从版本3.6，介入了字符串插值，即“格式化字符串文字”或称为“f字符串”，它向字符串文字前缀上`f`或`F`，例如`x="blah"; y=2; f'spam={x} eggs={y:04d}'`。

### 类型

<image>

Python使用鸭子类型，并拥有有类型的对象，和无类型的变量名字。在编译期不检查类型约束，而宁愿在一个对象上的操作出现可能的失败，表现出这个给定对象不具有适合的类型。尽管是动态类型系统，Python却是强类型的，禁止没有明确定义的操作，比如将一个数和一个字符串相加，而不是默默的去尝试转换使其有意义。

Python有着范围广泛的基本数据类型。同时具备常规的整数和浮点算术，它透明的支持任意精度算术、复数和十进制浮点。Python支持种类繁多的字符串操作。在Python中，字符串是不可变的，所以在其他编程语言中可能就地改变字符串的字符串操作，比如字符替换，在Python中返回新的字符串。

Python有一个非常有用特征，就是搜集（或称容器）类型的概念。一般的说，搜集是以一种易于引用或索引的方式，包含其他对象的对象。Python的搜集类型包括了序列、映射和集合，Python提供了广泛的搜集操纵能力，比如内建包含检查和通用迭代器协议。

列表（动态数组）、元组和字符串是序列类型。所有序列类型都有位置索引，并且除了字符串，都可以包含任意类型的对象，在同一个序列中可以包括多种类型的对象。字符串和元组是不可变的，使得它们成为字典的键的完美候选者。列表是可变的，元素可以被插入、删除、修改、添加或就地排序。

字典是无次序的映射类型，它将一组不可变的键，映射到相应的元素上。在字典中的键，必须是不可变的Python类型，比如整数或字符串，因为在底层它们是通过散列函数实现的。集合 (抽象数据类型)是无次序的类型，它包含唯一性的不可变对象作为元素。有二种类型的集合：可变的`set`和不可变的`frozenset`。

Python允许编程者使用类，定义自己的类型。类的新实例，是通过调用这个类的构造器而创建的，而类型和类都是元类`type`的实例，元类`type`更是其自身的实例，这允许了元编程和反射。Python支持对类型和类的广泛内省，它们可以被读取和比较。efn|1= 两个类及元类等的实例关系（蓝色连接）与继承关系（绿色连接）示意图：

<image>

```python
r = object
c = type
class M(c): pass

class A(metaclass=M): pass

class B(A): pass

b = B()
```

```pycon
>>> type(b)
<class '__main__.B'>
>>> print(type(B), B.__bases__)
<class '__main__.M'> (<class '__main__.A'>,)
>>> print(type(A), A.__bases__)
<class '__main__.M'> (<class 'object'>,)
>>> print(type(M), M.__bases__)
<class 'type'> (<class 'type'>,)
>>> print(type(c), c.__bases__)
<class 'type'> (<class 'object'>,)
>>> print(type(r), r.__bases__)
<class 'type'> ()
```

Python支持渐进类型，自从版本3.5，在语法上逐渐允许建立静态类型系统。缺省官方实现CPython不检查静态类型，静态类型检查器mypy，支持编译期类型检查。

类型｜可变性｜描述｜语法例子

`bool`｜不可变｜布尔值，有表示值`False`和`True`的两个对象。作为整数类型的子类型，除了在转换成字符串时转换为`"False"`和`"True"`之外，它们在几乎所有上下文中表现得如同`0`和`1`。｜TrueFalse

`int`｜不可变｜整数，其大小在理论上无限制，实际上受限于内存。｜42

`float`｜不可变｜双精度浮点数，确切精度依赖于机器。一般实现为IEEE 754标准binary64浮点数，它有53个二进制有效数位精度。

`complex`｜不可变｜复数，即分别表示实部与虚部的两个双精度浮点数的有序对。｜3+2.7j

`range`｜不可变｜数的序列，通常用在`for`循环中指定循环次数。｜range(1, 10)range(10, -5, -2)

`str`｜不可变｜字符串，即Unicode代码点序列。其代码点都在区间`[\u0000, \uffff]`或`[\U00010000, \U0010ffff]`之内。｜'Wiki' "pedia"

```python
"""Spanning
multiple lines"""
```

`bytes`｜不可变｜字节序列，其项目是8位字节，可以用区间`[0x00, 0xff]`的整数表示。｜b'Wiki' b"pedia"bytes(0x68, 0x65, 0x78)

`bytearray`｜可变｜bytearray(b'Wiki' b"pedia")bytearray(0x68, 0x65, 0x78)

`list`｜可变｜列表，可以包含任意的Python对象。｜4.0, 'string', True

`tuple`｜不可变｜元组，可以包含任意的Python对象。｜(4.0, 'string', True)

`dict`｜可变｜字典是键-值对的搜集。键在其生存期间是不可变的（称其为可散列的），列表、字典或其它可变对象和包含它们的对象不可以用作键。

`set`｜可变｜无序的集合 (抽象数据类型)，包含唯一性的不可变的对象，它们不能用任何下标来索引。｜set

`frozenset`｜不可变｜frozenset(4.0, 'string', True)

`types.EllipsisType`｜不可变｜这个类型的值是有一个单一对象，它表示为文字 (计算机编程)`...`或内建名字`Ellipsis`，它的真值为真。它用于NumPy多维阵列索引。｜Ellipsis

`types.NoneType`｜不可变｜这个类型的值是一个单一对象`None`（相当于其他语言的`Null`），它被用来指示值的缺席，它的真值为假。

`types.NotImplementedType`｜不可变｜这个类型的值是一个单一对象`NotImplemented`，数值方法和丰富比较方法如果没有实现在所提供运算元上的这个运算则应当返回这个值，它不应该在布尔值上下文中求值。｜NotImplemented

除了各种数据类型，Python解释器还内建了很多其他类型，包括可调用类型：用户定义函数、实例方法、生成器函数、协程函数、异步生成器函数、内建函数、内建方法、类、类方法；模块，定制类，类实例，I/O对象（也叫做文件对象），和暴露给用户的一些内部类型：代码对象、框架对象、溯回对象、切片对象、静态方法对象、类方法对象。

### 函数

Python中的用户定义函数是其内建的函数类型的实例，函数的递归调用被限制了最大深度可以通过`sys.getrecursionlimit()`，获知当前的递归最大深度限制，还可以通过`sys.setrecursionlimit()`来设置这个限制。例如递归定义的阶乘函数：

```python
def fac(n):
    return 1 if n <= 1 else fac(n-1) * n
```

目前`fac(994)`可以递归执行至缺省的最大深度限制`1000`，CPython解释器自身占用了初始的那几层。

Python不支持函数重载即不能创建具有相同名字而有不同实现的多个函数，但自从版本3.4，其标准库可支持单一分派泛化函数。Python中的函数支持闭包和其他头等函数特征词法闭包的例子：

python

def f(x):

def g(y):

return x + y

return g # 返回一个闭包。

h = lambda x: lambda y: x + y

# 将指定闭包赋值给变量。

a = f(1)

b = h(1)

c = f(2)

# 使用存储在变量中的闭包。

assert a(5) == 6

assert b(5) == 6

assert c(5) == 7

# 使用闭包而不事先把它们绑定到变量。

assert f(1)(5) == 6 # f(1)是个闭包。

assert h(1)(5) == 6 # h(1)是个闭包。

assert f(2)(5) == 7 # f(2)是个闭包。

。Python官方实现不提供尾调用优化或头等续体，吉多·范罗苏姆曾声称他不会对其加以支持，有第三方函数式编程库支持弹跳床 (计算机术语)。

Python的修饰器（decorator）可用来修改任何可调用对象，其用法是将已定义的对象比如函数、方法或类定义传递给修饰器，再将它所返回的修改后的对象绑定到原来对象的名字。Python使用`@`作为关键字形成修饰符，它是用来应用修饰器的语法糖。定义修饰器的示例：

```python
def viking_chorus(func):
    def wrapper(*args, **kwargs):
        for i in range(3):
            func(*args, **kwargs)
    return wrapper
```

调用修饰器的示例：

```python
@viking_chorus    
def menu_item(*args):
    print(", ".join(args)+", and spam")
```

它等价于：

```python
def menu_item(*args):
    print(", ".join(args)+", and spam")

menu_item = viking_chorus(menu_item)
```

`viking_chorus`修饰后的`肉罐头 (巨蟒剧团)_item`将原来定义运行3次：

```pycon
>>> menu_item("egg","bacon")
egg, bacon, and spam
egg, bacon, and spam
egg, bacon, and spam
```

通过在毗连的行上放置多个修饰符，多个修饰器可以链接起来应用。修饰器工厂示例，这里的`favourite_colour`接受一个实际参数，并返回一个修饰器：

```python
def favourite_colour(colour):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"My favourite colour is {colour}.")
            func(*args, **kwargs)
        return wrapper
    return decorator

def invincible(func):
    def wrapper(*args, **kwargs):
        print("I'm invincible!")
        func(*args, **kwargs)
    return wrapper
```

使用毗连的修饰符链接修饰器示例：

```python
@invincible
@favourite_colour("blue")
def black_knight():
    print("None shall pass.")
```

它等价于：

```python
black_knight = invincible(favourite_colour("blue")(black_knight))
```

黑骑士 (巨蟒剧团)结果为：

```pycon
>>> black_knight()
I'm invincible!
My favourite colour is blue.
None shall pass.
```

修饰器可用于元编程例如：设置先决条件和后置条件，还可以用来实现记忆化和可作为主编程范型的多分派。

在Python中，函数调用的实际参数与函数定义的形式参数之间的结合，所传递的是“对象引用”，函数在被调用之时，所给予的实际参数被介入到一个局部符号表中，实际参数使用传值调用来传递，而这个值总是对象引用，并非这个对象的值。如果形式参数绑定到一个可变对象，则通过形式参数对此对象内容的修改，在函数外也是可见的。如果形式参数绑定到一个不可变对象，则通过形式参数不能修改此对象内容，但可以把形式参数重新绑定到其它对象上，这并不影响函数外的对象的值。函数的形实参数二者结合示例。例如：

```pycon
>>> def spam(a):
...     a.append('LovelySpam')
...     
>>> def eggs(b):
...     b=100 #实际上是重新绑定了另一个整型对象100
... 
>>> a=[]
>>> b=10
>>> spam(a)
>>> eggs(b)
>>> print(a)
['LovelySpam']
>>> print(b)
10
```

Python在函数定义时，可以在形式参数序列中，以`<small>形式参数</small>=<small>值</small>`的样式指定形式参数缺省值。在函数调用时可以省略有缺省值的形式参数，这时这个缺省值就被代入到它的位置中。在这个函数定义被执行之时，从左至右的求值作为形式参数的缺省值的这些表达式。这意味着这种表达式在这个函数被定义之后只被求值一次，而每次函数调用之时都使用相同的“预先计算”的值。当形式参数的缺省值是可变对象比如列表或字典的时候，如果这个函数修改了这个对象，则这个形式参数的缺省值就在实效上被修改了。比如：

```pycon
>>> def f(a, L=[]):
...     L.append(a)
...     return L
...     
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(0, []))
[0]
>>> print(f(3))
[1, 2, 3]
```

这通常不是所预期的效果。一种解决办法是使用`None`作为缺省值，并在函数主体中显式的测试它：

```python
def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L
```

Python在函数调用中，可以给予位置实际参数和关键字实际参数。实际参数可以如同C语言那样，按照位置与函数定义的形式参数匹配；也可以采用关键字实际参数，即`<small>形式参数</small>=<small>值</small>`样式的实际参数。Python在函数定义中，可以使用不对应实际参数的特殊形式参数`/`和`*`，将形式参数序列分为三部分：唯位置形式参数、可位置可关键字形式参数和唯关键字形式参数。如果一个形式参数有缺省值，则在其后直到`*`之前的所有形式参数也都必须有缺省值。函数的形式参数缺省值的定义示例：

```pycon
>>> from inspect import getfullargspec
>>> def func(p1, /, p2, p3="x", *, p4): pass
... 
>>> getfullargspec(func)
FullArgSpec(args=['p1', 'p2', 'p3'], varargs=None, varkw=None, defaults=('x',), kwonlyargs=['p4'], kwonlydefaults=None, annotations={})
```

在函数定义中的位置形式参数序列和关键字形式参数序列，可以分别在其末尾有`*args`或`**kwargs`这样的加了前缀`*`或`**`的形式参数，它们捕获在函数调用时提供的，超出形式参数序列规定而无所对应的多个实际参数；在形式参数`args`前加`*`号，则`args`是元组类型，它捕获可变数目的位置实际参数；在形式参数`kwargs`前加`**`号，则`kwargs`是字典类型，它捕获可变数目的关键字实际参数。函数的可变参数的定义示例：

```pycon
>>> from inspect import getfullargspec
>>> def func(p1, /, p2, *args, p3, **kwargs): pass
... 
>>> getfullargspec(func)
FullArgSpec(args=['p1', 'p2'], varargs='args', varkw='kwargs', defaults=None, kwonlyargs=['p3'], kwonlydefaults=None, annotations={})
```

在函数调用的实际参数序列中，关键字实际参数必须出现在位置实际参数之后。如果要传递给一个函数的一些位置实际参数，已经在一个序列类型如列表或元组的对象中，则可以在函数调用中给它前缀`*`来进行可迭代解包；如果要传递的一些关键字实际参数已经在字典对象中，则可以给它加`**`号来进行字典解包。

在函数定义头部之后可以插入“文档字符串”，用作函数的使用帮助，它可以使用内置函数`help()`打印出来。自从Python 3.0，函数定义可以对形式参数与返回值增加类型标注。自从版本3.5，开始支持类型提示。

### 对象

在Python中所有东西都是对象，包括数、函数、类和模块，其标准库支持对对象的弱引用。Python允许多态性，采用了鸭子类型方式，就是说针对变量的方法调用和特性（attribute）访问，不事先限制这个的变量的类型，它可被绑定到任何对象。Python的类继承支持多重继承，这可以用来实现混入。Python支持元类，还支持抽象基类，自从版本3.6，提供了定制化类创建的简单机制。

对象的方法，是附属于这个对象的类的函数。对于正常的方法和函数，语法`<small>实例</small>.<small>方法</small>(<small>实际参数</small>)`，是`<small>类</small>.<small>方法</small>(<small>实例</small>, <small>实际参数</small>)`的语法糖。Python不提供其他一些面向对象编程语言比如C++和Java中的隐式的`this (计算机编程)`关键字，Python的对象方法沿袭自Modula-3，使用显式的第一个形式参数来访问实例特性，习惯上将其命名为`this (计算机编程)`。对象的方法示例：

```Pycon
>>> class Fish(object):
...     hungry = True
...     def eat(self, food=None):
...         if food is not None:
...             self.hungry = False
... 
... def status(self):
...     print("Hungray!" if self.hungry else "Not hungray!")
... 
>>> e = Fish()
>>> Fish.hungry = False
>>> e.hungry
False
>>> Fish.hungry = True
>>> e.hungry
True
>>> e.__dict__
{}
>>> status(e)
Hungray!
>>> Fish.status = status
>>> type(Fish.status)
<class 'function'>
>>> type(e.status)
<class 'method'>
>>> e.status()
Hungray!
>>> e.eat("earthworm")
>>> e.__dict__
{'hungry': False}
>>> e.status()
Not hungray!
>>> Fish.hungry
True
```

Python不提供隐式的`super`关键字而是提供了`super()`内建函数，在一个类的方法中调用此函数返回一个代理（proxy）对象，它为了在类层级内这个类所有基类中查找实现了特定方法的基类，确定了优先次序即方法决定次序（MRO），次序居前的基类优先于位居其后的它的父辈类或平辈类。当一个子类的方法覆盖了其超类方法的时候，可通过调用`super().<small>方法</small>`，将这个方法调用委托给与子类的`self.<small>方法</small>`同名的超类方法。类方法`__init_subclass__`和在子类中用内建函数`super()`调用超类的实例方法和类方法的例子：

```pycon
>>> class Thought(object):
...     __cls_descr = "Thought类型"
...     @classmethod 
...     def descript(cls):
...         return cls.__cls_descr
...     def __init_subclass__(cls, /, **kwargs):
...         super().__init_subclass__(**kwargs)
...         cls.__cls_descr = "Thought类型的子类型"
...     def __init__(self, *args, **kwargs):
...         self.idea = "我感觉自己斜停在了平行宇宙里。"
...         print(f"我是{type(self).descript()}的新对象！")
...     def message(self, *args):
...         print("\n".join([self.idea] + [*args]))
... 
... class Advice(Thought):
...     @classmethod
...     def descript(cls):
...         return super().descript() + "Advice类型"
...     def message(self):
...         super().message("警告：日历中的日期比实际显示的更近！")
... 
>>> t = Thought()
我是Thought类型的新对象！
>>> t.message()
我感觉自己斜停在了平行宇宙里。
>>> a = Advice()
我是Thought类型的子类型Advice类型的新对象！
>>> a.message()
我感觉自己斜停在了平行宇宙里。
警告：日历中的日期比实际显示的更近！
>>> super(Advice, a).message()
我感觉自己斜停在了平行宇宙里。
>>> Advice.super = super(Advice)
>>> a.super.message()
我感觉自己斜停在了平行宇宙里。
>>> [*super.__dict__]
['__new__', '__repr__', '__getattribute__', '__get__', '__init__', '__thisclass__', '__self__', '__self_class__', '__doc__']
>>> super(Advice).__thisclass__
<class '__main__.Advice'>
>>> assert super(Advice).__self__ is None
>>> assert super(Advice).__self_class__ is None
>>> super(Advice, a).__self__
<__main__.Advice object at 0x754299f19940>
>>> super(Advice, a).__self_class__
<class '__main__.Advice'>
>>> super(Thought, Advice).__thisclass__
<class '__main__.Thought'>
>>> super(Thought, Advice).__self__
<class '__main__.Advice'>
>>> super(Thought, Advice).__self_class__
<class '__main__.Advice'>
```

Python使用名字修饰，有限的支持私有变量。Python支持一些名字以`__`开始和结束的特殊方法，它们用于实现实现多种特殊功能，某些特殊方法可以实现运算符重载，比如定义了`__add__()`，将会允许在这个类的实例上使用`+`算符。

在Python中，最常用的特殊方法是实例初始化方法`__init__()`，它在实例创建之后返回给调用者之前被调用，给它的实际参数就是传递给对象构造器表达式的那些实际参数。自从版本3.7，Python标准库提供了`@dataclass`修饰符，用来向用户定义类自动增加特殊方法比如`__init__()`和`__repr__()`。

在Python中，不强制采用访问子与变异子方法，来访问对象的数据成员。对象的特殊特性`__dict__`，是存储其所有（可写）特性的字典。在一个类中的类变量`__slots__`，可以被赋值为变量名字序列，它为所声明的这些变量在类实例对象中保留空间，并阻止其自动建立`__dict__`。特殊方法`__init__`和类变量`__slots__`（槽）示例：

```Pycon
>>> class Bird(object):
...     __slots__ = ['hungry']
...     def __init__(self, *args, **kwargs):
...         self.hungry = True
...     def eat(self, food=None):
...         if food is not None:
...             self.hungry = False
...     def status(self):
...         print("Hungray!" if self.hungry else "Not hungray!")
... 
>>> Bird.hungry
<member 'hungry' of 'Bird' objects>
>>> type(Bird.hungry)
<class 'member_descriptor'>
>>> f = Bird()
>>> f.status()
Hungray!
>>> f.eat("mealworm")
>>> f.status()
Not hungray!
```

在Python中，定义了一个或多个特殊方法`__get__()`、`__set__()`、`__delete__()`的类，可以用作描述器（descriptor）。Python使用`@classmethod`和`@staticmethod`修饰符，来分别建立类方法和静态方法。在方法调用之时，类方法接收这个类的作为其隐式的第一个实际参数，而静态方法不接收隐式的第一个实际参数。类方法、静态方法`__new__`（它是特殊情况而不需要加以修饰）、特殊方法`__call__`、`__len__`、`__getitem__`、`__setitem__`和弱引用集合 (抽象数据类型)示例：

```pycon
>>> from weakref import WeakSet
... class D():
...     __template = {}
...     __obj_set = WeakSet()
...     def __new__(cls, *args, **kwargs):
...         obj = super().__new__(cls)
...         cls.__obj_set.add(obj)
...         return obj
...     @classmethod
...     def load(cls, dict):
...         cls.__template |= dict
...     @classmethod
...     def create(cls, *args, **kwargs):
...         return cls(cls.__template, *args, **kwargs)
...     @classmethod
...     def count(cls):
...         return len(cls.__obj_set)
...     @classmethod
...     def contains(cls, obj):
...         return obj in cls.__obj_set
...     def __init__(self, dict={}, /, *args, **kwargs):
...         self.__dict__ |= dict
...         self.__dict__ |= kwargs
...     def __call__(self, *args, **kwargs):
...         self.__dict__ |= kwargs
...         return self.__dict__.copy()
...     def __len__(self):
...         return len(self.__dict__)
...     def __getitem__(self, key):
...         return self.__dict__[key]
...     def __setitem__(self, key, value):
...         self.__dict__[key] = value
...  
>>> a = {'ak': 1, 'bk': 2, 'ck': 3}
>>> d = D(a, dk=4)
>>> d()
{'ak': 1, 'bk': 2, 'ck': 3, 'dk': 4}
>>> D.load(a)
>>> e = D.create(ck=4)
>>> e()
{'ak': 1, 'bk': 2, 'ck': 4}
>>> f = D(ak=1, bk=2)
>>> f(ck=3)
{'ak': 1, 'bk': 2, 'ck': 3}
>>> f['ak']
1
>>> f['ak'] = 5
>>> f()
{'ak': 5, 'bk': 2, 'ck': 3}
>>> len(f)
3
>>> D.count()
3
>>> del f
>>> D.count()
2
>>> d.__weakref__
<weakref at 0x72652697ede0; to 'D' at 0x72652713b230>
>>> D.contains(d)
True
>>> D.contains(1)
False
```

在类的定义中，如果一个成员若是另一个描述器类的实例，则它被称为这个类的属性（property），使用与特性（attribute）访问相同的语法，访问这个类的实例对象中的属性。在类中采用数据描述器的示例：

```pycon
>>> from weakref import WeakKeyDictionary
>>> class RevealAccess():
...     """ 在存取时披露提示消息的数据描述器
...     """
...     def __init__(self, default=None):
...         self.default = default
...         self.dict = WeakKeyDictionary()
...     def __get__(self, obj, objtype=None):
...         print('Retrieving')
...         return (self.dict[obj] if obj in self.dict
...             else self.default)
...     def __set__(self, obj, val):
...         print('Updating')
...         self.dict[obj] = val
... 
>>> class MyClass():
...     x = RevealAccess(10)
... 
>>> a = MyClass()
>>> a.x
Retrieving
10
>>> a.x = 20
Updating
>>> a.x
Retrieving
20
>>> b = MyClass()
>>> b.x
Retrieving
10
```

Python使用`@property`修饰符或`property`内建函数，将一个类中特殊定义的访问某个特性的那些方法，包装成的这个类的一个属性。在类中调用`property()`的例子：

```pycon
>>> class C():
...     def __init__(self, *args, **kwargs):
...         self.__x = None
...     def getx(self):
...         return self.__x
...     def setx(self, value):
...         self.__x = value
...     def delx(self):
...         del self.__x
...     x = property(getx, setx, delx, "I'm the 'x' property.")
...     del getx, setx, delx
...     
>>> c = C()
>>> vars(c)
{'_C__x': None}
>>> {*C.__dict__}
{'__init__', '__static_attributes__', 'x', '__weakref__', '__module__', '__doc__', '__firstlineno__', '__dict__'}
```

上述代码可以采用修饰符进一步的书写为：

```pycon
>>> class C():
...     def __init__(self, *args, **kwargs):
...         self.__x = None
...     @property
...     def x(self):
...         """I'm the 'x' property."""
...         return self.__x
...     @x.setter
...     def x(self, value):
...         self.__x = value
...     @x.deleter
...     def x(self):
...         del self.__x
... 
>>> c = C()
>>> vars(c)
{'_C__x': None}
>>> {*C.__dict__}
{'__init__', '__static_attributes__', 'x', '__weakref__', '__module__', '__doc__', '__firstlineno__', '__dict__'}
```

## 标准库

Python拥有一个强大的标准库。Python标准库包括了如下功能：

- 内建函数
- 内建常量
- 内建类型
- 内建例外
- Python运行时服务
- 定制Python解释器
- 导入模块
- Python语言服务
- 文本处理服务
- 二进制数据服务
- 数据类型
- 数值和数学模块
- 函数式编程模块
- 文件和目录访问
- 数据持久化
- 数据压缩和存档
- 文件格式
- 加密服务
- 通用操作系统服务
- MS Windows专有服务
- Unix专有服务
- 命令行界面库
- 并发执行
- 网络和进程间通信
- 互联网数据处理
- 结构式文档标记处理工具
- 互联网协议及其支持
- 多媒体服务
- 国际化
- 程序框架
- Tk图形用户界面
- 开发工具
- 调试和分析
- 软件打包和软件发布

## 程序代码实例

一个在标准输出设备上输出Hello World的简单程式通常被作为开始学习程式语言时的第一个程式。可将如下代码录入纯文本文件并命名（如`program01.py`），然后执行这个命令`python3 program01.py`以执行该程序：

```Python
print("Hello, world!")
```

Python也可以单步直译执行。执行Python直译器进入互动式命令列的环境后，你可以在提示符号`>>>`旁输入`print("Hello, world!")`，按Enter键输出结果：

```Pycon
>>> print('Hello, world!')
Hello, world!
```

计算非负整数的阶乘的程序代码：

```python
n = int(input('輸入一個數，就會印出其階乘: '))
if n < 0:
    raise ValueError('錯誤，請輸入一個非負整數')
fact = 1
for i in range(2, n + 1):
    fact *= i
print(fact)
```

注意：在Python 3.0及以上版本中，`print`是个函数，需要在要打印的参数前后加上圆括号；在Python 2.x版本中，`print`是一个关键字而可以不加圆括号。

## 实现

Python是一门跨平台的脚本语言，Python规定了一个Python语法规则，根据该规则可编写Python直译器。Python属于动态语言，其官方实现CPython将Python程序编译成中间形式的字节码，并接着在它的虚拟机上执行，运行速度缓慢于C/C++所编译出的机器码和在HotSpot JVM上运行的java字节码。

活跃开发的实现

- CPython：官方的Python直译器，需要区别于其他直译器的时候才以CPython称呼。CPython默认采用全局解释器锁（GIL），以确保在任何时刻只有一个线程执行Python字节码；一些扩展模块被设计为在进行计算密集任务时释放GIL，还有在进行I/O时总是释放GIL。
- MicroPython：为微控制器而优化的Python 3变体，它实现了完整的Python 3.4语法，和补充自版本3.5的`async/await`关键字，以及后来版本的一些选定特征；它提供了实现Python标准库模块功能子集的内建模块，和特定于微控制器的一些模块。CircuitPython是Adafruit工业公司开发的MicroPython分叉。
- PyPy：采用了跟踪即时编译的Python实现，缺省支持stackless模态，它是用RPython编写的，当前支持Python版本3.11和2.7。
- Numba：使用LLVM JIT的Python优化编译器，它将包括很多NumPy函数的聚焦数值计算的Python子集，转译成快速的机器码，它为在CPU和GPU上并行化Python代码提供了大量选项。
- Codon：高性能且无运行时开销的Python编译器，它将Python代码编译成本机机器代码，并且支持本机多线程和GPU并行运算，还包括了特征齐全的完全编译的内建NumPy实现。它由MIT CSAIL的研究人员开发，其语义在数据类型等方面上与CPython有所不同。
- Pyodide：基于WebAssembly/Emscripten的用于浏览器和Node.js的Python发布，支持任何在PyPI上`wheel`形式的纯Python包，并且已经移植了很多具有C语言扩展的包。
- RustPython：用Rust编写的Python解释器，它可以嵌入到Rust应用程序中从而将Python用作脚本语言，还可以被编译成WebAssembly从而在浏览器中运行Python代码。
- Brython：用JavaScript编写的在浏览器中运行的Python实现，具有到DOM元素和事件的接口。
- GraalPy：针对JVM的基于GraalVM的Python高性能实现。

转译成其他语言的编译器

- Cython：将增加了静态类型声明的Python超集编译成C或C++的编译器。Cython补充支持调用C语言函数并且在变量和类特性上声明C语言类型，还支持以OpenMP为后端的本机多线程并行。
- mypyc：将Python模块编译成C扩展的编译器，它使用标准的Python类型提示生成快速代码。mypyc是mypy发行的可选依赖，它使用mypy进行类型检查和类型推论。
- Nuitka：用Python编写的到C11（或替补为C++03）的编译器，它将Python模块转译成使用CPython的`libpython`共享库和自己的静态C文件的C层级程序，接着将其编译成本机机器代码。
- Shed Skin：将纯粹但隐含为静态类型的Python有限子集代码转译成优化的C++代码的编译器，它可以生成独立程序或者能导入其他Python程序的扩展模块。
- Pythran：将聚焦于科学计算的Python子集编译成C++11的提前编译，它依赖于Boost和xsimd库，将标注了接口描述的Python模块编译为本机共享库模块，能利用上多核和SIMD指令单元。
- Transcrypt：用Python编写的Python 3.9到JavaScript编译器，用于在浏览器中运行Python代码，它被预先编译为高可读性且高效的JavaScript代码。
- MyHDL：将Python编译成Verilog或VHDL。

其他实现举例：Cinder，它是Meta孵化器发布的面向性能的CPython分叉。Jython，它是用Java实现的Python 2.7。IronPython，它基于DLR之上的Python 2.7和Python 3.4实现。Stackless Python，它是实现微线程的CPython 3.8分叉。Pyston，它是具有JIT等性能优化的CPython 3.8.12的分叉。Pyjion，将Python代码编译成本机CIL的CPython 3.10的JIT扩展。Grumpy，它是Python 2.7到Go的转译器和运行时系统。py2many，将Python转译成多种语言如C++17、Rust、Go和Julia等的转译器。

## 开发环境

### 通用文本编辑器

很多并非集成开发环境软件的文本编辑器，也对Python有不同程度的支持，并且加上专门为Python设计的编辑器插件也会有很高的可用性。

- VS Code
- Atom
- Eclipse
- emacs
- SlickEdit
- TextMate
- Vim
- Sublime Text
- EditPlus
- UltraEdit
- PSPad
- Notepad++

### 专用开发环境

适用于Python的集成开发环境（IDE）软件，除了标准二进制发布包所附的IDLE之外，还有许多其他选择。其中有些软件设计有语法着色、语法检查、运行调试、自动补全、智能感知等便利功能。由于Python的跨平台出身，这些软件往往也具备各种操作系统的版本或一定的移植性。

- IDLE：Python“标准”IDE，一般随Python而安装，支持较少的编辑功能，调试功能也比较弱。
- Eric：基于PyQt的自由的IDE，支持自动补全、智能感知、自动语法检查、工程管理、svn/mercurial集成、自动单元测试等功能，具有可扩展的插件系统，通过可选插件支持Git集成。调试功能与Visual Studio和Eclipse类似。
- Spyder：开源的跨平台科学计算IDE。
- PyCharm：由JetBrains公司出品，具备一般IDE的功能，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制等等，另外，它还提供了一些功能用于Django开发，还支持IronPython。它是商业软件，但也具有社区版和教育版。

## 第三方扩展包

<image>

Python社群提供了大量的功能覆盖众多领域的第三方模组，其使用方式与标准库类似。第三方模块可以使用Python/Cython或者C语言编写。软件工具比如SWIG，通过定义接口文件或规定文件的方式，可以将C/C++编写的程序库包装为Python模块。Python解释器本身也可以被集成到其它需要脚本语言的程式内。

Python包索引是公开的软件包在线仓库。pip是官网推荐的以安全方式安装Python应用及其依赖软件包的工具。要安装在整个操作系统范围内共享的Python包，现在需要通过操作系统的软件包管理系统。为了将特定于应用的依赖包隔离于共享的Python安装，需要创建虚拟环境，这可以使用标准库的venv，或第三方工具比如virtualenv和pipenv。

### 网络编程

Python标准库对于各种网络协定的支援很完善，因此适用于编写服务器软件、网络爬虫等Web开发。Python定义了WSGI标准应用接口，来协调HTTP服务器与基于Python的Web程式之间的沟通。比如，通过mod_wsgi模组，Apache HTTP Server可以运行用Python编写的Web程式。

用Python编写的一些Web框架，有助于轻松地开发和管理复杂的Web程式。重要的第三方计算机网络编程库和Web框架有：

- Zope：著名的开源Web应用服务器。
- Beautiful Soup：用作HTML/XML解析器的一个简单易用Python包。
- Twisted：事件驱动的网络编程框架，它支持很多常见的网络协议并包括了很多不同用途的模块，它支持所有主要的系统事件循环和各种GUI事件循环。
- Django：MTV架构的Web框架，它注重组件的重用性和“可插拔性”、快速开发和DRY法则。
- Tornado：使用单线程事件循环的异步非阻塞式web服务器，也是轻量级的Web框架。
- Flask：微Web框架，不要求特定的工具或库。
- Requests：适合于常人使用的HTTP库，封装了许多繁琐的HTTP功能，极大地简化了HTTP请求所需要的代码量。
- aiohttp：基于`asyncio`的HTTP客户端和服务器二者。
- uvloop：对内建`asyncio`事件循环的快速的、直截了当的替代者，它用Cython实现并在底层使用了libuv。
- FastAPI：用于实现基于HTTP的网络服务API的现代高性能web框架。
- PyScript：创建在浏览器内的Python应用的框架，可采用MicroPython、WebAssembly、Pyodide，和当代Web技术比如通过wgpy利用上WebGL或WebGPU。

### 图形用户界面

Python本身包含了Tkinter库，它是Python的业界标准GUI并被集成进入了IDLE。Tkinter基于了Tcl命令工具，能够支持简单的GUI开发。但是为了让所开发的软件运行速度更快，并与用户的桌面环境更契合，人们一般会选择采用第三方GUI库或框架。主要的第三方GUI库有：

- PyQt：Qt的Python绑定库，由Riverbank Computing公司自从1998年发行，采用GPL许可证或商业许可证。
- PySide：Qt的Python绑定库，由Qt公司自从2009年发行，采用LGPL许可证。
- PyGObject：替代了PyGTK，它是为Python程序访问基于GObject的库而提供的包装库，GObject是GTK、GIO (软件)和GStreamer等库使用的对象系统。
- Kivy：用于开发多点触控应用软件的开源Python库，采用了自然用户界面（NUI）。
- WxPython：GUI编程框架wxWidgets的Python包装库。
- Gooey：将几乎所有Python 3控制台程序用一行代码转变成GUI应用。
- Dear PyGui：快速而强力的具有极小依赖性的GUI工具箱。
- pywebview：轻量级跨平台的对WebView构件的包装器，允许在其本地GUI窗口中显示HTML内容。

### 数据科学

重要的数据科学用第三方软件库有：

- NumPy：Python的基础性的科学计算软件库，它提供了强力的多维阵列对象，广播式阵列运算，集成C/C++和Fortran代码的工具，较为有用的线性代数、傅里叶变换和随机数功能。
- SciPy：用于数学、科学和工程的Python软件库，它以NumPy的多维阵列作为基本数据结构，所包含的模块针对了：统计、最优化、数值积分、常微分方程求解、插值、线性代数、傅里叶变换、信号处理、图像处理等。
- CuPy：NumPy/SciPy兼容的GPU加速的阵列库，它可在NVIDIA CUDA或AMD ROCm平台上充当其直截了当的替代者，来运行现存的NumPy/SciPy代码。
- matplotlib：基于NumPy的综合性绘图库，用于创建静态的、动画的和交互式的数据可视化。地图绘制库Cartopy提供了接口使得可以使用matplotlib来创建地图。
- pandas：用于数据分析和数据操纵的软件库，它在NumPy基础上，提供了加标签数据结构“数据帧”，和统计函数等。它的缺省绘图后端是matplotlib，还可以扩展上第三方绘图后端。
- Modin：直截了当替代pandas并将其工作流程缩放至Ray、Dask (软件)或通过Unidist缩放至MPI。

#### 数据可视化

主要的数据可视化软件库及仪表板框架有：

- VisPy：高性能交互式2D/3D数据可视化库，它通过OpenGL库利用GPU的计算能力来显示非常大的数据集。
- Datoviz：通过Vulkan库利用GPU的用于数据可视化的高性能渲染库。
- seaborn：基于matplotlib的数据可视化库，它提供了绘制统计图形的高层接口。
- Vega-Altair：基于Vega-Lite JSON规定设计的声明式统计可视化库。
- Bokeh：针对现代Web浏览器的交互式数据可视化库，它在大型或流数据的数据集上提供高效的交互性。
- plotly：交互式开源的基于浏览器的图形绘制库，它是基于plotly.js实现的声明式图表库。
- Dash：数据应用和仪表板框架，它可将现代用户界面元素如下拉选单、滑动条和图形，直接连结至分析型Python代码，它由Plotly公司公司出品，基于了React、Flask和plotly.js。
- Panel：数据探索和Web应用框架，它能无缝的集成于PyData生态系统，提供交互式数据表格和可视化等功能，它可用在Pyodide和PyScript之中。Panel是HoloViz生态系统的成员，这个工具组还包括了：hvPlot、HoloViews、GeoViews、Datashader、Lumen、Param和Colorcet。
- Streamlit：迅速将Python脚本转变为Web应用的框架，所生成的应用可共享于Streamlit社区云平台。
- Voilà：将Jupyter Notebook转变为独立的Web应用的框架。

#### 机器学习

基础性的机器学习软件库及框架有：

- scikit-learn：机器学习软件库，它提供的功能包括：监督学习中的分类和回归，无监督学习中的聚类和降维，还有模型选择和数据预处理。它基于了NumPy、SciPy、数据帧库兼容层Narwhals、轻量级管道库Joblib和线程池控制库threadpoolctl，其绘图功能依赖于matplotlib，还可用到sklearn-onnx、scikit-image、seaborn和plotly。
- PyMC：基于从Theano分叉出的PyTensor的概率编程库，它用于建立贝叶斯统计模型，并使用马尔可夫链蒙特卡洛（MCMC）方法进行模型拟合。
- TensorFlow：Google开发的“端到端”开源机器学习平台，它提供了Python API，其中实现了Keras API。Keras现在是在TensorFlow 2上建立的深度学习高层API。
- PyTorch：Meta在Torch (机器学习)基础上开发的开源的Python软件包，提供了具有强大的GPU加速的张量计算，和建立在基于tape的自动微分系统上的深度神经网络。
- JAX：Google开发的开源机器学习框架，其核心是可任意组合的对数值纯函数的变换，它结合了修改版本的针对NumPy的自动微分库Autograd，和TensorFlow中的加速线性代数库XLA，它使用XLA来在GPU和TPU上编译和运行NumPy程序。

### 其它种类

- Pegen：Python的PEG文法解析器的生成器。
- llvmlite：轻量级的LLVM的Python绑定，用于编写即时编译器。
- xDSL：围绕静态单赋值（SSA）中间表示（IR）构建的Python原生的编辑器框架，它的设计受到了MLIR编译器框架的影响。
- NumKong：曾名为SimSIMD，采用SIMD加速的距离、点积、矩阵、地理空间与几何运算的内核库的Python绑定，它跨越指令集架构并支持多种数值类型。
- wgpu-py：WebGPU本地实现的Python包装器。Pygfx，是基于wgpu-py的强力且多用途的渲染引擎。fastplotlib，是建立在Pygfx之上的快速绘图库。tinygrad，是可以利用wgpu-py作为加速器的深度学习框架。
- PyCUDA：不同于Nvidia的cuda-python，PyCUDA提供对CUDA API的Python风格访问。
- PyOpenCL：PyOpenCL提供对OpenCL API的Python风格访问，例如光滑粒子流体动力学框架PySPH的性能关键部分用Cython和PyOpenCL实现。
- Kompute：基于Vulkan的通用计算框架，它是高速的、支持移动设备、异步的并且针对高级GPU数据处理用例做了优化。
- Dask (软件)：伸缩范围从笔记本电脑至计算机集群的并行计算库，它提供的用户接口镜像了PyData生态系统中pandas、scikit-learn和NumPy的API。
- Ray：对人工智能及Python应用的运行规模进行伸缩的统一框架，由Anyscale公司开发。它构成自一个核心的分布式运行时系统，和加速机器学习工作负载的AI软件库。
- SQLAlchemy：Python的SQL工具包和采用数据映射器模式的对象关系映射器（ORM）。
- Graphene：GraphQL框架，支持各种数据源如SQLAlchemy、Mongo、Django和定制Python对象等。GQL是常用来与之配合的GraphQL客户端Python库。
- Python图像库：基于Python的图像处理软件库，它支持广泛的图形文件格式，分叉于已终止的PIL。
- Fabric：经由SSH远程执行shell命令的高层库，它产生有用的Python对象作为回馈。
- Prefect：现代工作流程编排框架，它易于搭建、调度和监控健壮的数据流水线。
- pygame：开发视频游戏的Python软件库，基于了SDL软件库。如视觉小说引擎Ren'Py就基于pygame。
- pyglet：Python编写的面向对象的游戏和多媒体库，利用了FFmpeg软件库并需要OpenGL 3.3+。2D街机游戏开发库Arcade基于了pyglet，它还利用了基于2D物理引擎Chipmunk (软件)构建的Pymunk。
- Panda3D：开源游戏引擎，包括了图形、音频、I/O、碰撞侦测和其他与3D游戏有关的功能，使用Python作为游戏开发语言。
- SymPy：支持数学符号运算的软件库，用于提供计算机代数系统。
- SimPy：基于由Python生成器函数定义的进程的离散事件模拟框架。

## 应用

在很多操作系统里，Python是标准的系统元件，它被列入了ISO/IEC 23360-1-4:2021 Linux标准规范（LSB）之语言规定。大多数Linux发行版和macOS都集成了Python，可以在终端模拟器或虚拟控制台下直接执行Python。第三方工具pyenv可以在多个Python版本间轻易切换，pipx可以将Python应用安装于隔离的环境中并在其中运行它。

虽然Python可被粗略地分类为脚本语言，Python的支持者较喜欢称它为一种高阶动态语言，常像“胶水”一样被用来连接软件组件，已经显著的区别于Unix shell、Windows PowerShell这样的语言。基于Python的xonsh，是跨平台的、青睐Unix的shell语言和命令行界面。

### 应用程序

一些Linux发行版，使用Python语言编写安装器，比如Ubuntu的Ubiquity和Fedora的Anaconda；或使用它编写软件包管理系统，比如Gentoo的Portage。下面举例使用Python编写的一些应用程序：

- IPython：以多种编程语言进行交互式计算的命令shell和Jupyter的内核，最初为Python开发，它提供了内省、富媒体、shell语法、命令行补全和历史。
- Conda：跨平台的、语言无关的二进制包管理器，它被Python的Anaconda发行版采用。
- Orange (软件)：基于scikit-learn和pandas的开源机器学习和数据可视化软件，利用了PyQt6和PyQt6-WebEngine，通过广大多样的工具箱来搭建数据分析工作流程，由卢布尔雅那大学开发。
- SageMath：涵盖许多数学功能的应用软件，基于NumPy、SciPy、matplotlib、SymPy、Maxima、GAP (计算机代数系统)、FLINT、R等开源软件包进行实现。
- MayaVi：基于VTK的应用程序和库，用于交互式科学数据可视化和采用Python的3D绘图。
- Pitivi：用Python开发的基于GStreamer的视频编辑软件。

Blender、Inkscape、QGIS和LibreOffice等软件将Python作为嵌入式脚本语言。

### 人工智能

经由Python开发了众多的人工智能模型和作为其支撑的软件库：

- Kornia：基于PyTorch的可微分计算机视觉软件库。
- spaCy：用Python和Cython开发的工业级实力的自然语言处理软件库。
- ComfyUI：开源的节点图架构的程序，它允许用户从一系列的文本提示生成图像。ComfyUI使用自由的扩散模型比如Stable Diffusion作为其图像功能的基础模型，还合并了其它工具比如ControlNet和LCM低秩适应，这里每个工具都表示为程序中的一个节点。
- Transformers：为下载和训练前沿的预训练模型提供API和工具，由Hugging Face开发，支持在PyTorch、TensorFlow和JAX之间的框架互操作性。
- Gradio：它是一个Python库，允许快速创建和分享用于机器学习模型、API或任何任意Python函数的Web应用程序。使用Gradio，可以构建交互式用户界面，与各种机器学习框架兼容。还可以使用Gradio以交互方式调试模型、从用户获取反馈，并通过自动生成的可共享链接轻松部署模型。
- LangChain：它是一个应用框架，旨在简化使用大型语言模型的应用程序。作为一个语言模型集成框架，LangChain的用例包括文档分析和总结摘要, 代码分析和聊天机器人。LangChain提供了一个标准接口，用于将不同的语言模型（LLM）连接在一起，以及与其他工具和数据源的集成。
- Netron：神经网络、深度学习和机器学习的模型的查看器。

## 影响的语言

Python的设计和哲学已经影响了很多其他编程语言，例如：

- ECMAScript/JavaScript：从Python借鉴了迭代器和生成器。
- Genie：基于Vala编译器的具有近似Python语法的语言。
- Go：其设计原则受到了Python的可读性与易用性的启发，享有相同风格的数组分片语法。
- Groovy：受到Python等动态类型语言的影响。
- Julia：在表达高级数值计算的方式和支持通用编程上借鉴了Python等语言。
- Kotlin：融合了Python和Java特征，极小化了样板代码而增加了开发效率。
- Nim：使用缩进和类似的语法。
- Ruby：主要从Python等语言中借鉴了特征。
- Swift：有受Python启发的语法。

此外还有：Boo、Cobra语言、CoffeeScript、GDScript、Starlark和V语言等等。

在Python基础上开发的编程语言有：

- Taichi Lang：采用同Python几乎一样语法的指令式并行编程语言，源出自MIT CSAIL实验室，它嵌入在Python之中并使用即时编译器框架如LLVM，将计算密集的Python代码转变成本机GPU或CPU指令，它支持多数主流GPU API比如CUDA和Vulkan。
- Coconut：在Python语法之上增加了用于函数式编程的新特征的Python变体。
- Snek：受Python启发的微小的可嵌入式语言，其目标处理器仅有数以kB计的闪存和静态内存。
- Pycopy：极简主义 (计算)的、轻量级且可扩展的MicroPython兼容语言实现。
- Mojo：基于MLIR编译器框架并设计为Python超集的语言。
- Hy：嵌入到Python中的Lisp方言，它将Lisp代码变换成Python抽象语法树对象，从而以Lisp形式操控全部Python库。

## 参阅

- 编程语言列表
- Python语法及语义
- Python的历史
- Python软件列表

## 外部连接

- Awesome Python
- Real Python Tutorials
- programingz － Learn Python Programming
- w3schools － Python Tutorial
- ItsMyCode－ Learn Python Programming
- Codecary － Learn Python Programming
- dainikchorcha － Learn Python Programming
- Tutlane - Learn Python Online
- Brmgha - Learn & Challenges Python Online
- AlmaBetter- Python Tutorial

## 基本资料

- 编程范型：多范型：过程式、结构化、模块化、反射式、面向对象、函数式
- 发行时间：1991年
- 设计者：吉多·范罗苏姆
- 开发者：Python软件基金会
- 类型系统：鸭子类型、动态、强类型、渐进类型（自从3.5）
- 软件实现：CPython、PyPy、Stackless Python、MicroPython、CircuitPython、IronPython、Jython
- dialects：Cython、RPython
- 受影响于：ABC、ALGOL 68、APL、C、C++、CLU、Dylan、Haskell、Icon、Java、Lisp、Modula-3、Perl、Standard ML
- 施影响于：Boo、Cobra、CoffeeScript、D、F#、GDScript、Genie、Go、Groovy、JavaScript、Julia、Kotlin、Mojo、Nim、Ruby、Starlark、Swift、V语言
- 操作系统：跨平台
- 许可证：Python软件基金会许可证
- 文件扩展名：.py、.pyi、.pyc、.pyd、.pyo（3.5之前）、.pyw、.pyz（自从3.5）
- wikibooks：zh:Python