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