本页使用了标题或全文手工转换

Python

维基百科，自由的百科全书
跳到导航 跳到搜索
Disambig gray.svg  关于与“Python”名称相近或相同的条目，请见“Python (消歧义)”。
Python
Python logo and wordmark.svg
编程范型多范型：函数式、指令式、结构化、面向对象、反射式
设计者吉多·范罗苏姆
实现者Python软件基金会
发行时间1991年，​30年前​（1991）[1]
稳定版本
3.9.4[2]在维基数据编辑
（2021年4月4日，18天前 ）
预览版本
3.10.0a7[3]在维基数据编辑
（2021年4月6日，16天前 ）
类型系统鸭子类型, 动态, 强类型[4], 渐进（英语：gradual typing）（自从3.5）[5]
操作系统跨平台
许可证Python软件基金会许可证
文件扩展名.py、.pyi、.pyc、.pyd、.pyo（3.5之前）[6]、.pyw、.pyz（自从3.5）[7]
网站www.python.org 编辑维基数据链接
主要实现产品
CPython、PyPy、IronPython、Jython、Stackless Python、MicroPython、CircuitPython（英语：CircuitPython）、RustPython
派生副语言
Cython、RPython、Starlark（英语：Bazel (software)）[8]
启发语言
ABC[9]、Ada[10]、ALGOL 68[11]、APL[12]、C[13]、C++[14]、CLU[15]、Dylan[16]、Haskell[17]、Icon[18]、Java[19]、Lisp[20]、Modula-3[14]、Perl、Standard ML[12]
影响语言
Boo、Cobra（英语：Cobra (programming language)）、CoffeeScript[21]、D、F#、Falcon、Genie[22]、Go、Groovy、JavaScript[23][24]、Julia[25]、Nim、Ring[26]、Ruby[27]、Swift[28]

Python（英国发音：/ˈpaɪθən/ 美国发音：/ˈpaɪθɑːn/）是一种广泛使用的解释型、高级和通用的编程语言。Python支持多种编程范型，包括函数式、指令式、结构化、面向对象和反射式编程。它拥有动态类型系统和垃圾回收功能，能够自动管理内存使用，并且其本身拥有一个巨大而广泛的标准库。

Python由吉多·范罗苏姆创造，第一版发布于1991年，它是ABC语言的后继者，也可以视之为一种使用传统中缀表达式（英语：M-expression）的LISP方言[29]。

Python的设计哲学强调代码的可读性和简洁的语法，尤其是使用空格缩进划分代码块。相比于C或Java，Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明了。

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

历史[编辑]

主条目：Python语言历史（英语：History of Python）
Python的创始人为吉多·范罗苏姆（Guido van Rossum）。

Python的创始人为吉多·范罗苏姆，当时他在阿姆斯特丹的荷兰数学和计算机科学研究学会工作。1989年的圣诞节期间，吉多·范罗苏姆为了在打发时间，决心开发一个新的脚本解释编程，作为ABC语言的一种继承，替代使用Unix shell和C语言进行系统管理，担负同Amoeba操作系统（英语：Amoeba (operating system)）的交互和异常处理[9]。之所以选中Python作为编程的名字，是因为他是BBC电视剧——《蒙提·派森的飞行马戏团》（Monty Python's Flying Circus）的爱好者[30]。范罗苏姆作为Python的主要开发者独自担负这个项目的职责，直到2018年7月12日，他宣布从作为终身仁慈独裁者（BDFL）的职责上“永久休假”，Python社区向他授予这个头衔反映了他长期担任整个Python语言的发展方向的决策者[31][32]。他在2019年1月至11月于参与了一个五人掌控委员会继续领导项目发展[33][34]。

在1991年2月，范罗苏姆发布了最初代码（标记为版本0.9.0）于alt.sources[35]，这时就已经存在了带继承的类、异常处理、函数和核心数据类型list、dict、str等。在这个最初发行中就有了从Modula-3引进的模块系统[36]，它的异常模型也类似于Modula-3，但增加了else子句[9]。在1994年1月Python达到了版本1.0。这个发行版主要新特征是包括了函数式编程工具lambda、map、filter和reduce[37]。Python 1.4增加了受Modula-3启发的关键字参数（英语：Named parameter）和对复数的内建支持，还包含采取名字修饰的一种基本形式的数据隐藏（英语：Information hiding）[38]。

Python 2.0于2000年10月16日发布，介入了列表推导式，这是从函数式编程语言SETL和Haskell中引入的。它还向垃圾收集系统增加了环检测算法，并且支持Unicode[39]。Python 2.1支持了嵌套作用域，就像其他静态作用域语言一样[40]。Python 2.2的重大革新是将Python的类型（用C写成）和类（用Python写成）统一入一个层级，使得Python的对象模型成为纯粹和一致的面向对象的模型[41]；还增加了迭代器[42]，受CLU和Icon启发的生成器[43]，和描述器协议[44]。Python 2.4加入了集合（英语：Set (abstract data type)）数据类型，和函数修饰器[45]。Python 2.5加入了with语句[46]。

Python 3.0于2008年12月3日发布，它对语言做了较大修订而不能完全后向兼容[47]。Python 3发行包括了2to3实用工具，它（至少部分的）自动将Python 2代码转换成Python 3代码[48]。Python 3的很多新特性后来也被移植到旧的Python 2.6/2.7版本中[49]。

Python 2.7的产品寿命结束日期最初设定为2015年，出于对大量的现存代码不能前向移植到Python 3的关切而延期至2020年[50][51]。随着Python 2的产品寿命结束，只有Python 3.8[52]和后续版本仍被完全支持。

在2020年12月，活跃的Python核心开发者选举Barry Warsaw、Brett Cannon、Carol Willing、Pablo Galindo Salgado和Thomas Wouters为2021年度“掌控委员会”的五位成员来领导这个项目[53]。

特征与设计哲学[编辑]

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

Python使用动态类型，在内存管理上采用引用计数和环检测相结合的垃圾收集器[59]。它的特征还有动态名字解析（后期绑定（英语：late binding）），即在程序执行期间绑定方法和变量的名字。

Python对遵循LISP传统的函数式编程提供了有限的支持[60]，它提供了 map、filter和reduce函数；列表推导式、字典、集合和生成器表达式[61]。标准库中有两个模块（functools和itertools）实现了从Haskell和Standard ML取来的函数式工具[62]。

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

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

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

范罗苏姆认为ABC语言非常优美和强大，并没有成功的原因是非开放造成的[63]，故而将Python本身设计为可扩展的。Python并不把所有的特性和功能都集成到语言核心，而是提供了丰富的API和工具，以便程序员能够轻松地使用C、Cython来编写扩展模块，因此很多人使用Python将其他语言编写的编程进行集成和封装。Python编译器本身也可以被集成到其它需要脚本语言的编程内。

Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python的官方实现CPython中。在某些对运行速度要求很高的情况，Python设计师可以使用JIT技术的PyPy，或者是将Python脚本翻译成C的Cython，还可以将时间关键的函数迁移至用C语言编写的扩展模块中。

语法[编辑]

主条目：Python语法和语义（英语：Python_syntax_and_semantics）

Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。Python语句之后的分号是可选的，作为动态语言不需要书写“声明”语句，不同于其他的静态语言如C、Pascal。

缩进[编辑]

Python语言利用缩进表示语句块的开始和结束（越位规则），而非使用大括号或者某种关键字。增加缩进表示语句块的开始，而减少缩进则表示语句块的结束。根据PEP 8的规定[64]，使用4个空格来表示每级缩进。[a]

使用Tab字符和其它数目的空格虽然都可以被解释器识别，但不符合编码规范，偏向使用Tab字符的程序员可以设置文本编辑器将Tab键转换为4个空格。缩进成为了语法的一部分，并且Python开发者有意让违反了“缩进规则”的程序不能通过解释。

关键字[编辑]

Python有如下35个关键字或“保留字”；它们不能用作标识符[65][66]：

  • and
  • as
  • assert
  • async[注 1]
  • await[注 1]
  • break
  • class
  • continue
  • def
  • del
  • elif
  • else
  • except
  • False[注 2]
  • finally
  • for
  • from
  • global
  • if
  • import
  • in
  • is
  • lambda
  • None
  • nonlocal[注 2]
  • not
  • or
  • pass
  • raise
  • return
  • True[注 2]
  • try
  • while
  • with
  • yield
注释
  1. ^ 1.0 1.1 从Python 3.5开始，介入了async和await[67]。
  2. ^ 2.0 2.1 2.2 从Python 3开始，介入了关键字True、False和nonlocal。

标识符[编辑]

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

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

在Python文献中经常使用的元语法变量（英语：metasyntactic variable）是spam和eggs（英语：Spam (Monty Python)）而非传统的foo和bar[69]。

语句和控制流[编辑]

Python的语句包括：

  • 赋值语句，记号为等号=。Python支持并行赋值，可以同时给多个变量赋值，还可以交换两个变量的值。[b]
  • del语句，递归的进行删除。
  • pass语句，充当NOP，表示此行为空，不运行任何操作。
  • assert语句，用于编程调适阶段时测试运行条件是否满足。
  • if语句，当条件成立时运行语句块。经常与elif、else配合使用。
  • for语句，遍历列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
  • while语句，当条件为真时，循环运行语句块。
  • break语句，从循环中退出。
  • continue语句，越过这次迭代并继续进行下个项目。
  • try（英语：Exception handling syntax）语句，与except、else、finally配合使用，处理在编程运行中出现的异常情况。
  • raise语句，抛出一个异常。
  • class语句，用于定义类，它执行一块代码并将它的局部名字空间附属至一个类。
  • def语句，用于定义函数和方法。
  • return语句，用来从函数返回值。
  • yield语句，使用它从一个生成器中返回一个值。[c]在版本2.5之前，生成器是惰性迭代器，信息是单向的从生成器传递出来的。自从版本2.5，yield也是一个有返回值的运算符，能够将信息传递回到生成器函数中[70]。自从版本3.3，信息可以传递通过多个堆栈层级[71]。
  • with语句，把一块代码包裹在一个上下文管理器之内。例如，在一块代码执行之前获取一个锁并且在此后释放这个锁，或打开一个文件并且在此后关闭它。它允许了资源获取即初始化（RAII）式行为并可替代常见的try/finally惯用法[72]。
  • import语句，导入一个模块或包。有三种用法：import <模块名字> [as <别名>]，from <模块名字> import *，from <模块名字> import <定义1> [as <别名1>], <定义2> [as <别名2>], ...。

在Python中赋值语句所进行的操作是将一个名字绑定为到一个分立的、动态分配的对象的一个引用。因为名字的存储位置不“包含”这个指示的值，称它为“变量”是不准确的。这个名字可以随后在任何时候重新绑定到极大不同的各种类型的对象上，包括字符串、过程、具有数据和方法的复杂对象等等。因为名字是通用的引用持有者，给它关联一个固定的数据类型是不合理的。但是在给定时间一个名字总是被绑定到有一个类型的某个对象上，因此这是动态类型。接连的把一个共同的值赋值给多个名字，比如x = 2; y = 2; z = 2，导致给3个名字和1个数对象分配存储，这3个名字都绑定到这1个数对象上。Python赋值语句的这种基础机制，不同于传统指令式编程语言比如C中的赋值，在这里右手侧的值被复制到给这个变量分配的存储位置之中，等号左手侧的变量名字是其符号地址，对为它声明的类型而言分配给它的内存是足够大的。

Python支持并广泛使用异常处理作为检测错误状况和程序中其他“异常”事件的方式。Python风格提倡在可能出现错误状况的任何时候都使用异常。在Python中习惯上不在使用之前对访问一个文件或资源进行测试，而是先行尝试使用它，再捕获访问被拒绝引发的异常。[d] 经常为此援引的格言是葛丽丝·霍普贡献的EAFP[73]：“请求原谅比许可更容易”[74][75]。Python使用with语句处理资源[76]，在进入一个作用域的时候调用一个函数而在离开它的时候调用另一个函数。这能防止忘记移除资源并且还可处理更复杂的状况比如异常。[e]

Python不支持尾调用优化或第一类续体，并且根据吉多·范罗苏姆，永远都不会加以支持[77][78]。但是，在版本2.5中通过扩展Python的生成器，提供对协程式功能的更好的支持[70]。[f]版本3.4介入了综合性的异步I/O框架标准化，在其中扩展了利用子生成器委托的协程[79]，这个扩展自从Python 3.8被弃用[80]。Python 3.5通过async/await语法介入了对协程的显式支持[81]。从版本3.7开始async/await成为保留关键字[82]。[g]

模块是定义可以被导入并重用于其他Python程序中的函数和类的Python正规.py文件[83]。import语句找到一个模块，装载它，如果有需要的话初始化它，并且定义用来引用这个模块中代码的一个名字或一些名字[84]。from...import语句，找到、装载、必需时初始化一个模块，接着增加模块引用到局部名字空间，允许访问其中的函数和类而不用到模块引用[84]。from ... import支持*选项来导入所有引用而非指名的特定函数或类[83]。当模块被导入的时候，__name__变量被设置成这个模块的名字。在Python解释器直接运行一个模块的时候，__name__变量被设置为"__main__"。这允许被设计用于导入的模块增加只在模块被直接运行时候执行的代码[83][85]。dir()函数返回在当前局部作用域中或参数指定的对象中的名字的列表[86]。

表达式[编辑]

Python中很多表达式与C和java类似，而另一些则与之不同。

  • 在Python中，算术运算的加法+、减法-、乘法*和取模%是与C和java相同的，但是除法的行为不同。在Python中有两种除法，它们是下取整除法（或整数除法）//和浮点除法/[87] 。Python增加了指数算符**。Python有如下必须用于整数的位运算：&与（AND），|或（OR），~非（NOT），^异或（XOR），>>右移, <<左移。自从Python 3.5，介入了新的@中缀算符。它意图用于库比如NumPy中的矩阵乘法[88][89]。
  • 在Python中，有如下比较运算：大于>，小于<，等于==，不等于!=，小于等于<=，大于等于 >=。==按值比较，对比于Java，它按值比较数[90]而按引用比较对象[91]（在Java中比较对象的值可以采用equals()方法）。Python的is、is not算符可以用来比较对象的同一性（按引用比较），也就是比较两个变量是否引用了同一个对象。而in、not in用于判断一个对象是否属于另外一个对象。在Python中，比较是可以链接起来的，比如a <= b <= c。
  • Python使用and、or、not表示逻辑运算与、或、非，不采用Java和C中所用的符号&&、||、!。
  • 自从Python 3.8，介入了“指定表达式”语法:=。它也叫做“命名表达式”或“海象”，它将一个表达式指定给一个标识符，同时还返回这个表达式的值，常用作更大的表达式的一部分[92]。
  • Python的匿名函数实现为lambda表达式。匿名函数体只能是一个表达式。[k]
  • Python的条件表达式表示为x if c else y。意思是当c为真时，表达式的值为x，否则表达式的值为y。 在运算数的次序上不同于很多其他语言中常见的c ? x : y。
  • Python区分列表（list）和元组（tuple）两种类型。列表的写法是[1,2,3]，而元组的写法是(1,2,3)。在没有歧义的情况下，元组的圆括号是可选的，一个元素的元组向这个元素尾随一个逗号例如(1,)[93]。列表是可变的，并且不能用作字典的键（Python中字典的键必须是不可变的）。元组是不可变的，因而可以用作字典的键，假定这个元组的所有元素都是不可变的话。可以使用+算符来串接二个元组，这不会直接修改它们的内容，而是产生包含给定元组二者的元素的一个新元组。因此，给定变量t初始时等于(1, 2, 3)，执行t = t + (4, 5)时，首先求值t + (4, 5)，它产生(1, 2, 3, 4, 5)，接着赋值回到t，这在效果上“修改了”t的内容，尽管这还是遵守了元组对象的不可变本性。
  • Python有“序列解包”特征，多个表达式，其中每个都可求值成能被赋值的东西（变量、可写的属性等），以与形成元组文字（literal）相同的方式，关联起来作为一个整体，放置在赋值语句等号的左手侧。这个语句预期在等号的右手侧有一个“可迭代”对象，在迭代它的时候产生同左手侧给出的可写表达式相同数目的值，这个语句对它进行迭代并把每个产生的值赋值给左手侧对应的表达式[94]。这个特征允许从一个单一函数返回多个值。自从Python 3.5，增加了在表达式列表中的“可迭代解包”*和在字典显示中的“字典解包”**。[l]
  • Python拥有“字符串格式”算符%。这个功能类同于C中的printf格式化字符串，比如"spam=%s eggs=%d" % ("blah", 2)求值成"spam=blah eggs=2"。在Python 3和2.6+中，这通过str类的format()方法来提供，比如"spam={0} eggs={1}".format("blah", 2)。Python 3.6增加了“f-字符串”[95]：blah = "blah"; eggs = 2; f'spam={blah} eggs={eggs}'。[m]
  • Python拥有各种字符串文字（英语：string literal）:
    • 由单引号'或双引号"界定的字符串。不同于Unix shell、Perl和受Perl影响的语言，单引号和双引号功能相同。这二种字符串都使用反斜杠\作为转义字符。在Python 3.6中字符串插值（英语：String interpolation）可作为“格式化字符串”而获得到[95]。
    • 三引号字符串，开始和结束于三个单引号或双引号的序列。它们可以跨越多行，其功能就像shell、Perl和Ruby中的here文档。[n]
    • 原始字符串（英语：String literal#Raw strings）变体，用给字符串文字前导一个r来指示。转义序列不被解释，因此在文字反斜杠常见的地方很有用，比如正则表达式和Windows风格的路径。[o]可比较于C#中的“@-引用”。
  • Python允许连续出现和只用空白分隔（包括换行）的字符串文字（可能使用了不同的引用约定），它们被聚合成一个单一的更长的字符串[96]。[p]
  • Python拥有在列表上的数组索引和数组分片（英语：array slicing）表达式，表示为a[key]、a[start:stop]或a[start:stop:step]。索引是基于零的，负数是相对于结尾的。分片从“开始”（start）索引直到但不包括“停止”（stop）索引。分片的第三个参数叫做“步长”（step）或“间隔”（stride），允许元素被跳过和用负数指示反向。分片索引可以省略，例如a[:]，这返回整个列表的一个复本。[q]分片的每个元素都是浅层复制（英语：Object copying）的。

在Python中，在表达式和语句之间的区别是严格强制性的，对比于语言如Common Lisp、Scheme或Ruby。这导致重复了某些功能。比如：列表推导式对当for循环。条件表达式对当if块。eval()对当exec()内建函数（在Python 2中，exec是语句）；前者用于表达式，后者用于语句。

语句不能成为表达式的一部分，所以列表和其他推导式或lambda表达式，都是表达式，不能包含语句。这个限制的一个特定情况是赋值语句比如a = 1，不能形成条件语句的条件表达式的一部分。这能够避免一个经典的C错误，即在条件中把等于算符==误写为赋值算符=，if (c = 1) { ... }在语法上是有效（但可能非预期）的C代码，而if c = 1: ...在Python中导致一个语法错误。

函数[编辑]

Python的函数支持递归和闭包[r]及其他头等函数特征，但不支持函数重载。Python的函数作为第一类对象，具有和普通对象平等的地位。Python的函数实际参数与形式参数之间的结合是传递“对象的引用”，就是把形式参数名字绑定到实际参数名字所引用的对象上。如果形式参数绑定到一个可变的对象，则通过形式参数对此对象内容的修改，在函数外也是可见的。如果形式参数绑定到一个不可变的对象，则通过形式参数是不能修改此对象内容，但可以把形式参数重新绑定到其它对象上，这并不影响函数外的对象的值。[s]

Python的变量有函数作用域、模块作用域和全局作用域。简单访问（不赋值）一个变量的时候，名字解析服从窄到宽的LEGB（局部、包围、全局、内建）顺位规则。在函数中赋值一个变量将导致它成为这个函数的局部变量，就是说它的作用域在整个函数中，而不是在这个赋值之后至这个函数结束，因此在这个赋值之前引用它，不再于这个函数之外查找同名变量而是引发一个错误。缺省的名字解析规则可以用global或nonlocal关键字来覆盖。global声明的变量是全局变量。[t] global可以用于嵌套的函数中。嵌套函数中还可以使用nonlocal声明，用于赋值到给非局部变量（英语：Non-local variable）。[u]

Python可以指定形式参数的缺省值，在函数定义时于形式参数序列中以param=value样式进行一次性初始化。形式参数在初始化之后保持既有绑定，函数的后续调用可继续对它进行访问或变更。[v]在函数调用时为有缺省值的形式参数提供实际参数是可选的。Python支持位置实际参数和关键字实际参数。函数调用时，实际参数可以如同C语言那样按照位置与形式参数匹配；也可以采用命名参数（英语：Named parameter）（或称为关键字实际参数），即kwarg=value样式的实际参数。使用不对应实际参数的特殊形式参数/和*，可以将参数序列分为唯位置参数、可位置可关键字参数和唯关键字参数三部分。有缺省值的形式参数之后不能跟随无缺省值的可位置形式参数。[w]在一个函数调用的实际参数序列中，关键字实际参数必须出现在位置实际参数之后。

在位置和关键字形式参数序列末尾可以分别有*args或**kwargs这样的形式参数，它们对应于在函数调用时提供的，超出形式参数序列规定而无所对应的多个实际参数；在形式参数名字前加一个*号，该形式参数args是tuple类型，对应可变量目的位置实际参数；在形式参数名字前加**号，该形式参数kwargs是dict类型，对应可变量目的关键字实际参数。[x]在位置实际参数已经在一个序列类型如列表或元组的对象中的情况下，在引用它的变量前加一个*号传递给函数，则其中所有元素解包为多个位置实际参数，关键字实际参数在字典中则加**号来传递给函数。

修饰器（decorator）是用来修改一个函数、方法或类定义的任何可调用Python对象。将正被定义的最初对象传递给修饰器，它返回一个修改后的对象，接着把它绑定到在定义中那个名字。Python修饰器部分受到Java注解的影响，而有类似的语法；修饰器语法是纯粹的语法糖，使用@作为关键字形成修饰符。修饰器是一种形式的元编程，它们增强它们所修饰的函数或方法的行动。[y] 多个修饰器可以链接起来，通过在毗连的行上放置多个修饰符，或者使用中间变量。[z] 函数修饰器的正规用法包括：用来创建类方法或静态方法[97]，实现多方法，增加函数特性，跟踪（英语：Tracing (software)），设置先决条件和后置条件，同步[98]；此外更远大的用法包括：尾调用消除[99]，记忆化甚至改进修饰器的写作[100]。

为了增强代码的可读性，可以在函数后书写“文档字符串”（简称docstrings），用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。[aa]自从Python 3.5，开始支持类型提示[101]，可以标注函数的参数与返回值[102]。此特性可方便IDE对源代码进行更深入的分析。[ab]

对象及其方法[编辑]

Python支持大多数面向对象编程技术。在Python中所有东西都是对象，包括类、函数、数和模块。它允许多态性，不只是在类层级（英语：Class hierarchy）之内而且通过采用鸭子类型的方式。任何对象可以用于任何类型，只要它有适当的方法和特性（attribute）就能工作。Python天然支持类的继承包括多重继承，为此采用C3线性化或方法解析次序（MRO）算法，还支持mixin。Python支持元类，它是增进类的功能的高级工具。

Python使用名字修饰有限的支持私有变量。对象的特性可以被提取为一个字典[103]。在Python中不强制使用访问器和增变器方法（英语：Mutator method）来访问数据成员（英语：Field (computer science)）的面向对象编程信条。就像Python提供函数式编程构造但不尝试要求参照透明性（英语：referential transparency）（无副作用）一样，它提供对象系统但不要求面向对象编程行为。

对象的方法是附属于这个对象的类的函数。对于正常的方法和函数，语法instance.method(arguments)，是Class.method(instance, arguments)的语法糖。Python的方法有显式的self（英语：this (computer programming)）形式参数用来访问实例数据（英语：Field (computer science)），对比于在其他一些面向对象编程语言（比如C++、Java、Objective-C或Ruby）中隐式的self或this（英语：this (computer programming)）关键字[104]。在Python中，self可以被看作是一个习惯用法，它可以被换为任何其它合法的参数名。[ac]

Python支持一些以__开始和结束的特殊方法名，它们用于实现运算符重载和实现多种特殊功能[55]。在Python中，可以通过定义特殊方法来重载运算符，比如在一个类上定义__add__()将允许在这个类的实例上使用+算符。在Python中，当一个子类的方法覆盖（英语：Method overriding）了超类方法的时候，通过调用super().method来调用与子类的self.method方法同名超类方法[105]。[ad]

Python允许通过使用@classmethod和@staticmethod修饰符来分别创建类方法和静态方法。给类方法的第一个实际参数是类对象而非对实例的self引用。静态方法没有特定的第一个实际参数，实例或类对象都不固定的传递给静态方法。[ae]

在Python中定义了一个或多个特殊方法__get__()、__set__()、__delete__()的类可以用作描述器（descriptor）[106]。如此创建一个描述器的实例作为另一个类的一个类成员，使得这个实例成为此另一个类的属性（property）。使用与特性（attribute）访问相同的语法，访问一个实例对象中的这个成员属性。[af] Python的property内建函数，将一个类中特殊定义的访问一个特性的那些方法包装成的这个类的一个属性[107]。[ag]

类型[编辑]

Python 3中的标准类型层次结构

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

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

Python的一个非常有用方面就是搜集（或称容器）类型的概念。一般的说，搜集是以一种易于引用或索引的方式包含其他对象的对象。Python对创建容器类型的对象有着语法上的支持。[ah]搜集有二种基本形式：序列和映射。有次序的序列类型是列表（动态数组（英语：array data type））、元组和字符串。所有序列类型都是位置索引的（从0到长度−1），并且除了字符串，都可以包含任意类型的对象，在同一个序列中包括多种类型的对象。字符串和元组是不可变的，使得它们成为字典的键的完美候选者。在另一方面，列表是可变的，元素可以被插入、删除、修改、添加或就地排序。

在另一方面，映射是以“字典”形式实现的无次序的类型，它将一组不可变的键映射到相应的元素上（非常像数学函数）。在字典中的键必须是不可变的Python类型，比如整数或字符串，因为在底层它们是通过散列函数实现的。字典还是语言内部的中心，因为它们居于所有Python对象和类的核心：在变量名字（字符串）和这个名字所引用的值之间的映射就存储为字典，而这些字典可以通过对象的__dict__特性直接访问。

集合（英语：Set (abstract data type)）搜集类型是在版本2.4中增加入语言核心的。集合是不包含重复项的无索引、无次序的搜集，并且实现了集合论运算比如并集、交集、补集、对称差和子集测试。有二种类型的集合：可变的set和不可变的frozenset。集合中元素必须是可散列的，比如说，frozenset可以是正规set的元素而反之不行。Python还提供了广泛的搜集操纵能力比如内建的包含元素检查和通用迭代协议。

Python允许编程者使用类定义自己的类型[41]，类在面向对象编程中是最经常使用的。类的新实例是通过调用这个类的构造器而创建的，而类都是元类type的实例，type是type元类自身的实例，[ai]这允许了元编程和反射。

在版本3.0之前，Python有两种类：旧式的和新式的[108]。二种样式的语法是一样的，不同在于是否直接或间接的继承自类object，所有新式类都从object继承并且是type的实例。在Python 2系列2.2以上，二种类都可以使用[41]。在Python 3.0中淘汰了旧式类。

长期规划是支持渐进类型（英语：gradual typing）[109]，并且自从Python 3.5，语言的语法允许指定静态类型，但在缺省实现CPython中不检查它们。有实验的叫做“mypy”的可选的静态类型检查器支持编译期类型检查[110]。

Python 3内置类型总结
类型 可变性 描述 语法例子
bool 不可变 布尔值 True
False
int 不可变 理论上无限制大小的整数[111] 42
float 不可变 双精度浮点数。精度是机器依赖的但实际上一般实现为64位IEEE 754数而带有53位的精度[112]

1.414

complex 不可变 复数，具有实部和虚部 3+2.7j
range 不可变 通常用在循环中的数的序列，规定在for循环中的次数[113] range(1, 10)
range(10, -5, -2)
str 不可变 字符串，Unicode代码点序列 'Wikipedia'
"Wikipedia"
"""Spanning
multiple
lines"""
bytes 不可变 字节序列 b'Some ASCII'
b"Some ASCII"
bytes([119, 105, 107, 105])
bytearray 可变 字节序列 bytearray(b'Some ASCII')
bytearray(b"Some ASCII")
bytearray([119, 105, 107, 105])
list 可变 列表，可以包含混合的类型 [4.0, 'string', True]
[]
tuple 不可变 元组，可以包含混合的类型 (4.0, 'string', True)
('single element',)
()
dict 可变 键-值对的关联数组（或称字典）；可以包含混合的类型（键和值），键必须是可散列的类型 {'key1': 1.0, 3: False}
{}
set 可变 无序集合（英语：Set (abstract data type)），不包含重复项；可以包含混合的类型，如果可散列的话 {4.0, 'string', True}
set()
frozenset 不可变 无序集合（英语：Set (abstract data type)），不包含重复项；可以包含混合的类型，如果可散列的话 frozenset([4.0, 'string', True])
ellipsisa 不可变 省略号（英语：Ellipsis (programming operator)）占位符，用作NumPy数组的索引 ...
Ellipsis
NoneTypea 不可变 表示值缺席的对象，在其他语言中经常叫做null None
NotImplementedTypea 不可变 可从重载运算符返回的用来指示未支持的运算数（operand）类型的占位符。 NotImplemented

^a 不能用名字直接访问

除了各种数据类型，Python解释器内建了还有很多其他类型，比如上下文管理器类型，模块、方法、代码对象、类型对象、内部对象等类型。

数学[编辑]

Python的算术运算使用平常的符号+、-、*、/，下取整除法算符//和模除%（这里的余数可以是负数，比如4 % -3 == -2）。它还有指数算符**，比如5**3 == 125及9**0.5 == 3.0，和矩阵乘法算符@[114]。这些算符就像在传统数学中一样运算，具有同样的优先级规则，中缀算符+、-还可以分别表示取原数和取相反数的一元算符。

在整数之间的除法/产生浮点数结果。除法/的表现随着版本不同而有着显著变化[115]。

Python提供了round()函数用于把一个浮点数修约成最近的整数[116]。

Python允许由比较运算链接起来的布尔表达式表现得如在数学中常用的一样。比如，表达式a < b < c测试a小于b并且b小于c[117]。C派生语言不一样的解释这个表达式：在C中，这个表达式将首先求值a < b，结果为0或1，接着把这个结果比较于c[118]。

Python对所有整数运算使用任意精度算术。在decimal模块中的Decimal类型/类提供十进制浮点数到预定义的任意精度并有多种修约模式[119]。在fractions模块中的Fraction类提供任意精度的有理数[120]。

由于Python有着广泛的数学库，除了求绝对值函数abs()列入内建函数之外，大多数数学函数处于math和cmath模块内。前者用于实数运算，而后者用于复数运算。[aj]特别是，第三方库NumPy进一步扩展了固有能力，Python经常被用作科学脚本语言来处理如数值数据处理和操纵等问题[121][122]。

标准库[编辑]

Python拥有一个强大的标准库[123]。Python语言的核心只包含数值、字符串、列表、字典、文件等常见类型和函数，而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能。

Python标准库的主要功能有：

  • 文本处理（英语：Text processing），包含文本格式化、正则表达式、文本差异计算与合并、Unicode支持，二进制数据处理等功能。
  • 文件系统功能，包含文件和目录操作、创建临时文件、文件压缩与归档、操作配置文件等功能。
  • 操作系统功能，包含线程与进程支持、IO复用、日期与时间处理、调用系统函数、日志（logging）等功能。
  • 网络通信，包含网络套接字，SSL加密通信、异步网络通信等功能。支持HTTP，FTP，SMTP，POP，IMAP，NNTP，XMLRPC等多种网络协议，并提供了编写网络服务器的框架。
  • W3C格式支持，包含HTML，SGML，XML的处理。
  • 其它功能，包括国际化支持、数学运算、HASH、Tkinter等。

程序代码实例[编辑]

一个在标准输出设备上输出Hello World的简单编程，这种编程通常作为开始学习编程语言时的第一个编程，可将如下代码录入纯文本文件并随意命名比如program01.py，然后执行这个程序python3 program01.py： 

print("Hello, world!")

Python也可以单步解释运行。运行Python解释器进入交互式命令行的环境，你可以在提示符号>>>旁输入print("Hello, world!")，按Enter键输出结果： 

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

计算正数的阶乘的程序代码： 

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.6以下版本中，print是一个关键字和命令而不加圆括号。

实现[编辑]

Python是一门跨平台的脚本语言，Python规定了一个Python语法规则，根据该规则可编写Python解释器。Python属于动态语言，将Python程序编译成中间形式的字节码[124]，并接着在它的虚拟机上执行[125]，相较于C/C++等编译成机器码的编译语言而言运行速度较慢[126]。

  • CPython[127]，官方的解释器，需要区别于其他解释器的时候才以CPython称呼。这是最常用的Python版本。
  • MicroPython和CircuitPython（英语：CircuitPython），是为微控制器而优化的Python 3变体。
  • PyPy，RPython实现的Python，是快速的规矩的Python 2.7和3.7解释器[128]。它的即时编译器带来了超过CPython的显著速度提升，但是它不能使用一些用C写的库[129][130]。
  • Stackless Python， 是实现微线程（英语：microthread）的CPython的重要分叉；它不使用C内存堆栈，因而允许大规模并发程序。PyPy也有无堆栈版本[131]。
  • Jython，Java实现的Python。Jython可以直接调用Java的各种函数库。
  • IronPython，面向.NET和ECMA CLI的Python实现。IronPython能够直接调用.net平台的各种函数库。可以将Python程序编译成.net程序。

到其他语言的交叉编译器[编辑]

开发环境[编辑]

通用IDE / 文本编辑器[编辑]

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

专用Python开发环境[编辑]

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

  • IDLE（英语：IDLE）：Python“标准”IDE。一般随Python而安装，支持较少的编辑功能。调试功能也比较弱。
  • Eric：基于PyQt的自由软件。支持自动补全、智能感知、自动语法检查、工程管理、svn/mercurial集成、自动单元测试等功能，具有可扩展的插件系统，通过可选插件支持Git集成。调试功能与Visual Studio和Eclipse类似。当前版本可同时支持Python2.x和Python3.x，以及PyQt4和PyQt5。
  • PyCharm：由JetBrains打造，PyCharm具备一般IDE的功能，比如，调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制等等，同时另外，PyCharm还提供了一些很好的功能用于Django开发，同时支持Google App Engine，PyCharm也支持IronPython。PyCharm是商业软件，但也具有社区版和教育版。
  • Spyder：开源的跨平台科学计算IDE。
  • Komodo（英语：Komodo IDE）和Komodo Edit（英语：Komodo Edit）：后者是前者的免费精简版。也可以用于PHP，Ruby，Javascript，Perl，Web和云开发。
  • PyScripter（英语：PyScripter）：功能较全的开源IDE，使用Delphi开发。
  • WingIDE（英语：WingIDE）：商业软件，有免费的功能有限的Wing IDE 101，适用于入门者教学。

应用[编辑]

主条目：Python软件列表（英语：List of Python software）

在很多操作系统里，Python是标准的系统组件。大多数Linux发行版和Mac OS X都集成了Python，可以在终端下直接运行Python。虽然Python可被粗略地分类为脚本语言，Python的支持者较喜欢称它为一种高端动态语言，常像“胶水”一样被用来连接软件组件，已经显著的区别于其他仅作简单程序设计任务的语言，如Unix shell、Windows PowerShell等。

Python社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能覆盖科学计算、Web开发、数据库接口、图形系统多个领域。第三方模块可以使用Python或者C语言编写。SWIG和SIP（英语：SIP (software)）常用于将C语言编写的程序库转化为Python模块。

网络应用程序[编辑]

参见：网络应用编程

Python定义了WSGI标准应用接口来协调Http服务器与基于Python的Web编程之间的沟通。比如，通过mod_wsgi（英语：mod_wsgi）模块，Apache可以运行用Python编写的Web编程。Zope是著名的用Python编写的开源的Web应用服务器。Tornado是用Python语言写成的非阻塞式web服务器，也是轻量级的Web框架。

Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫等Web开发。用Python编写的一些Web框架，可以让程序员轻松地开发和管理复杂的Web编程。著名的第三方Web框架和函数库：

  • Django：开源Web开发框架，它鼓励快速开发，并遵循MVT设计，开发周期短。
  • web2py：MVC架构的全栈Web框架，虽然简单但是功能强大。
  • TurboGears：MVC架构的Web应用程序框架。
  • Pyramid：轻量同时也可以规模化的Web框架，是Pylons计划的一部分。
  • CherryPy：Web应用程序开发框架。
  • Quixote：简单的Web开发框架。
  • Flask：微Web框架。
  • Bottle：微Web框架。
  • aiohttp：轻量级的Web框架，采用的是Python3的asyncio异步特性[136]。
  • Twisted：事件驱动的网络编程框架。它支持多数标准的网络协议（包含客户端和服务器），并且提供了多种工具，被广泛用于编写高性能的服务器软件。
  • Requests：适合于常人使用的HTTP库，封装了许多繁琐的HTTP功能，极大地简化了HTTP请求所需要的代码量。
  • Beautiful Soup：用来解析HTML/XML的一个简单易用Python包。
  • gevent：是基于协程的高性能并发网络编程库，使用greenlet在libev或libuv之上提供了高层的同步式API[137]。

GUI开发[编辑]

参见：GUI

Python本身包含了Tkinter（英语：Tkinter）库，它是Python的业界标准GUI并被集成进入了IDLE（英语：IDLE）。Tkinter基于了Tcl命令工具，能够支持简单的GUI开发。但是越来越多的Python程序员选择第三方GUI包来开发跨平台的桌面软件，使用它们开发的桌面软件运行速度快，与用户的桌面环境相契合。著名的第三方GUI库：

  • PyGObject：替代了PyGTK，为Python程序访问基于GObject的库提供了包装库，GObject是GTK、GIO（英语：GIO (software)）和GStreamer等库使用的对象系统。
  • PyQt：用于Python的QT包装库，在GPL许可证或商业许可证下发行。
  • PySide：针对PyQt的替代库，在LGPL许可证下发行。
  • appJar（英语：appJar）：跨平台开源的Python的GUI库。提供对多数Tkinter内容的易用包装函数并带有额外的内建功能。
  • Kivy：用于开发多点触控应用软件的开源Python库，采用了自然用户界面（NUI）。
  • WxPython：Python下的GUI编程框架wxWidgets的包装库，它与MFC的架构相似。

科学计算[编辑]

通过第三方科学计算库可以让Python程序员编写科学计算编程。著名的第三方科学计算库：

  • NumPy：基于Python的科学计算第三方库，提供了矩阵，线性代数，傅立叶变换等等的解决方案。
  • SciPy：基于Python的matlab实现，旨在实现matlab的所有功能。
  • matplotlib：用Python实现的类matlab的第三方库，用以绘制一些高质量的数学二维图形。
  • SymPy：支持数学符号运算。
  • pandas：用于数据分析、数据建模、数据可视化的第三方库。
  • scikit-learn：机器学习第三方库，实现许多知名的机器学习算法。
  • PyMC3：用于贝叶斯统计建模和概率机器学习，它聚焦于高级马尔可夫链蒙特卡洛法和变分拟合算法。
  • TensorFlow：Google开发维护的开源机器学习库。
  • Keras：基于TensorFlow、Theano与CNTK的高端神经网络API。
  • PyTorch：基于Torch（英语：Torch (machine_learning)）的开源的机器学习库。

其它著名的第三方库[编辑]

  • Boost.Python：Boost C++ Libraries包含了一组库，使得以Python或C++编写的编程能互相调用。
  • SQLAlchemy：关系型数据库的对象关系映射（ORM）工具。
  • PIL（英语：Python Imaging Library）：基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，目前已无维护。另一个第三方库Pillow分叉了PIL库并进行持续的支持和维护[138] 。
  • pygame：基于Python的多媒体开发和游戏软件开发模块。
  • PyInstaller：能将程序发布为独立的安装程序包[139]。
  • pywin32：通过这个第三方软件包，Python能够访问Windows的COM服务及其它Windows API[140]。
  • py2exe（英语：py2exe）：将python脚本转换为windows上可以独立运行的可执行程序。

普及流行[编辑]

自从2003年，Python始终排行于TIOBE编程社区索引（英语：TIOBE Programming Community Index）前十最流行编程语言，在2020年11月，它达到了第二名最流行语言（居于C和Java之间），现为第三名[141]。它被选为2007年、2010年、2018年和2020年的年度编程语言[142]。

有一些Linux发行版的安装器使用Python语言编写。在RPM系列Linux发行版中，有一些系统组件就是用Python编写的。一些著名的互联网公司比如Google等[143]，都在内部大量地使用Python。很多游戏比如EVE，使用Python编写游戏的逻辑、服务器。使用Python编写了如下著名应用：

形成了如下社区：

  • PyCon：各地社区举办的会议，通常每年举办。各社区在会议中讨论Python相关的议题。
  • Python Discord：参与者众多的Python社区[145]。
  • PyLadies（英语：PyLadies）：由女性社区发起的社区，主要注重于发展Python的女性程序设计社区。
  • Django Girls（英语：Django Girls）：使用Django网页设计框架，推广使用Python进行网页设计的技术。

影响的语言[编辑]

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

  • Boo，使用了缩进、类似的语法和类似的对象模型[146]。
  • Cobra（英语：Cobra (programming language)），使用了缩进和类似的语言，而且它的致谢文档将Python列为影响它的首要语言[147]。
  • CoffeeScript，是交叉编译至JavaScript的编程语言，有受Python启发的语法。
  • ECMAScript/JavaScript，从Python借鉴了迭代器和生成器[148]。
  • GDScript，是非常类似Python的脚本语言，内置入了Godot游戏引擎[149]。
  • Go，设计为“有动态语言如Python的工作速度”[150]，并共享了相同的分片数组的语法。
  • Groovy，动机是将Python的设计哲学带到Java[151]。
  • Julia，设计为“像Python一样可用于通用编程”[25]。
  • Nim，使用缩进和类似的语法[152]。
  • Ruby，创建者松本行弘曾说过：“我想要一种脚本语言比Perl更加强力而且比Python更加面向对象。因此我决定设计自己的语言”[153]。
  • Swift，是Apple开发的编程语言，有受Python启发的语法[154]。

代码示例[编辑]

  1. ^ 缩进示例： 
    def print_something(age):
    if age < 21:
        print("你不能買酒")  #美國法律規定21歲以下的人不能購買酒
    else:
        print("你能買酒")
    print("你能買口香糖")

# 参数比后续部份多一层缩进
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,
}
  2. ^ 采用了并行赋值的斐波那契数列函数示例： 
    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()
  3. ^ 产生素数的惰性生成器的示例： 
    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

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

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

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

    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))
  4. ^ 遵循EAFP风格的异常处理示例： 
    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()
  5. ^ 使用with将文件作为资源来管理的示例： 
    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("文件写入完全成功")
  6. ^ 用生成器模拟协程示例： 
    def produce(n):
    try:
        for item in range(n):
            print('producing item {} ->'.format(item)) 
            yield item
    except GeneratorExit:
        return

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

t1 = produce(10)
t2 = consume()
next(t2)
try:
    while True:
        a = t1.send(None)
        b = t2.send(a)
except StopIteration:
    pass
  7. ^ 本地的协程示例： 
    import asyncio
import random

async def produce(queue, n):
    for item in range(n):
        # 生产一个项目，使用sleep模拟I/O操作
        print('producing item {} ->'.format(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('consuming item {} <-'.format(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())
  8. ^ 列表的推导式示例。比如： 
    >>> [x + 3 for x in range(4)]
[3, 4, 5, 6]

    快速排序算法可以优雅的（尽管不高效的）使用列表推导式表达为： 

    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]))
  9. ^ 生成器表达式示例。比如： 
    >>> 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}
  10. ^ 字典推导式{expr1: expr2 for k, v in d}，等价于： 
    result={}
for k, v in d.items():
    result[expr1]=expr2
return result

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

    集合推导式{expr1 for x in stuff}，等价于： 

    result = set()
for x in stuff:
    result.add(expr1)
return result

    >>> {x + 3 for x in range(4)}
{3, 4, 5, 6}
  11. ^ 匿名函数示例： 
    >>> 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]

    不动点组合子示例： 

    >>> Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))
>>> fac = lambda f: lambda n: (1 if n<2 else n*f(n-1))
>>> Y(fac)(5)
120
>>> fib = lambda f: lambda n: 0 if n == 0 else (1 if n == 1 else f(n-1) + f(n-2))
>>> Y(fib)(6)
8
>>> [*map((lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args))))(lambda f: lambda n: (1 if n<2 else n*f(n-1))), [1, 2, 3, 4, 5])]
[1, 2, 6, 24, 120]

    上述Y组合子代码源出自Rosetta Code. [2020-10-21]. （原始内容存档于2021-01-11）. 其原理可参见Equational derivations of the Y combinator and Church encodings in Python. [2020-10-21]. （原始内容存档于2020-11-12）. 

  12. ^ 序列解包、可迭代解包和字典解包示例： 
    >>> a = [1, 2, 3]; b = [4, 5]
>>> i, j, k = a
>>> print(i, j, k)
1 2 3
>>> 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}
  13. ^ 格式化字符串的示例，例如下列命令行echo命令： 
    num="3"; printer="HP Laserjet"
echo "I just printed ${num} pages to the printer ${printer}"

    等价于如下Python中的任何一种print函数调用： 

    num = 3; printer="HP Laserjet"
print(f"I just printed {num} pages to the printer {printer}")

print("I just printed {} pages to the printer {}".format(num, printer))
print("I just printed {0} pages to the printer {1}".format(num, printer))
print("I just printed {num} pages to the printer {printer}".format(num=num, printer=printer))

print("I just printed %s pages to the printer %s" % (num, printer))
print("I just printed %(num)s pages to the printer %(printer)s" % {"num": num, "printer": printer})
  14. ^ 多行字符串文字带有字符串插值（英语：String interpolation）（使用了format方法）的示例： 
    print("""亲爱的{recipient},

我希望你离开Sunnydale并永不返回.

不是很爱你的,
{sender}
""".format(sender="吸血鬼猎人Buffy", recipient="Spike"))
  15. ^ 原始字符串的示例： 
    >>> # Windows路径，即使是原始字符串也不能结束于反斜杠
>>> r"C:\Spam\Eggs\Ham\"
  File "<stdin>", line 1
    r"C:\Spam\Eggs\Ham\"
                       ^
SyntaxError: EOL while scanning string literal
>>> dos_path = r"C:\Spam\Eggs\Ham\ " # 通过增加尾随的空格
>>> dos_path.rstrip()              # 并接着移除它来避免错误
'C:\\Spam\\Eggs\\Ham\\'
>>> quoted_dos_path = r'"{}"'.format(dos_path)
>>> quoted_dos_path
'"C:\\Spam\\Eggs\\Ham\\ "'
>>> # 匹配具有可能的反斜杠引用的引用字符串的正则表达式
>>> import re
>>> re.match(r'"(([^"\\]|\\.)*)"', quoted_dos_path).group(1).rstrip()
'C:\\Spam\\Eggs\\Ham\\'
>>> code = 'spam(2, eggs)'
>>> # 反转有二个参数的函数调用的两个实际参数
>>> re.sub(r'\(([^,]*),\s*([^,]*)\)', r'(\2, \1)', code)
'spam(eggs, 2)'
>>> # 注意如果实际参数中有圆括号或逗号则上例无效。
  16. ^ 字符串文字符串接示例： 
    >>> title = "SICP in Python"" － " \
...         'CS61A: Online Textbook'

    等价于： 

    >>> title = "SICP in Python － CS61A: Online Textbook"
  17. ^ 下面几个判断语句为真，表示列表分片结果符合预期： 
    >>> nums = [1, 3, 5, 7, 8, 13, 20]
>>> nums[2:5] == [5, 7, 8] #从下标为2的元素切割到下标为5的元素，但不包含下标为5的元素。
True
>>> nums[1:] == [3, 5, 7, 8, 13, 20] #切割到最后一个元素。
True
>>> nums[:-3] == [1, 3, 5, 7] #从最开始的元素一直切割到倒数第3个元素。
True
>>> nums[:] == [1, 3, 5, 7, 8, 13, 20] #返回所有元素。改变新的列表不会影响到nums。
True
>>> nums[1:5:2] == [3, 7] #从下标为1的元素切割到下标为5的元素，但不包含下标为5的元素，且步长为2。
True
  18. ^ 词法闭包的例子： 
    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)是个闭包。
  19. ^ 函数的形实参数二者结合示例。例如： 
    >>> 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
  20. ^ 局部变量和全局变量示例： 
    >>> def spam():
...     print(b)
...
>>> b=10
>>> spam()
10
>>> def spam():
...     print(b)
...     b=100 
...
>>> b=10
>>> spam()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in spam
UnboundLocalError: local variable 'b' referenced before assignment
>>> def spam():
...     print(b)
...     global b
...     b=100
... 
  File "<stdin>", line 3
SyntaxError: name 'b' is used prior to global declaration
>>> def spam():
...     global b
...     print(b)
...     b=100
... 
>>> b=10
>>> spam()
10
>>> b
100
  21. ^ 非局部变量示例： 
    >>> def spam():
...     def eggs():
...         global b
...         print(b)
...         b=1000
...     b=100 # 对eggs()而言是非局部变量
...     eggs()
...
>>> b=10
>>> spam()
10
>>> b
1000
>>> def spam():
...     def eggs():
...         nonlocal b 
...         b=1000
...     b=100 # 对eggs()而言是非局部变量
...     eggs()
...     print(b)
...
>>> b=10
>>> spam()
1000
>>> b
10
  22. ^ 函数的形式参数缺省值的持久性示例： 
    >>> def f(a, L=[]):
...     L.append(a)
...     return L
... 
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
  23. ^ 函数的形式参数缺省值的定义示例： 
    >>> 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={})
  24. ^ 函数的可变参数的定义示例： 
    >>> 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={})
  25. ^ 定义修饰器的示例： 
    def viking_chorus(myfunc):
    def inner_func(*args, **kwargs):
        for i in range(3):
            myfunc(*args, **kwargs)
    return inner_func

    调用修饰器的示例： 

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

    等价于： 

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

menu_item = viking_chorus(menu_item)

    viking_chorus修饰后的menu_item将原来定义运行3次： 

    >>> menu_item("egg","bacon")
egg, bacon, and spam
egg, bacon, and spam
egg, bacon, and spam
  26. ^ 修饰器工厂示例，这里的favourite_colour接受一个实际参数，并返回一个修饰器： 
    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

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

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

    使用中间变量链接修饰器示例： 

    blue_decorator = favourite_colour("blue")
decorated_by_blue = blue_decorator(black_knight)
black_knight = invincible(decorated_by_blue)

    它们等价于： 

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

    black_knight（英语：Black Knight (Monty Python)）()结果为： 

    >>> black_knight()
I'm invincible!
My favourite colour is blue.
None shall pass.
  27. ^ 调用函数使用帮助信息示例。比如： 
    >>> def randint(a, b):
...     "Return random integer in range [a, b], including both end points."
...
>>> help(randint)
Help on function randint in module __main__:   

randint(a, b)
    Return random integer in range [a, b], including both end points.
  28. ^ 如下这样给参数增加类型标注的提示信息： 
    def send_mail(from: str, to: str, title: str, body: str) -> bool:
    pass
  29. ^ 对象的方法示例： 
    >>> class Fish(object):
...     hungry = True
...     def eat(self, food):
...         if food is not None:
...             self.hungry=False
... 
>>> def status(self):
...     print("Hungray!" if self.hungry else "Not hungray!")
... 
>>> e = Fish()
>>> status(e)
Hungray!
>>> Fish.hungry = False
>>> from types import MethodType
>>> e.status = MethodType(status, e)
>>> e.status()
Not hungray!
>>> Fish.hungry = True
>>> Fish.status = status
>>> f = Fish()
>>> Fish.status(f)
Hungray!
>>> f.eat("earthworm")
>>> f.status()
Not hungray!
  30. ^ 特殊方法和子类调用超类方法的例子： 
    >>> class Thought(object):
...     cls_name = "类型Thought"
...     def __init_subclass__(cls):
...         cls.cls_name = "类型Thought的子类型"
...     def __init__(self, *args, **kwargs):
...         print(f"我是{type(self).cls_name}的新对象!")
...         if len(args) != 0 or len(kwargs) !=0:
...             print(f"init: nargs={len(args)}, nkwargs={len(kwargs)}")
...         self.notion = "我觉得我在平行宇宙中把车停歪了."
...     def message(self, *args):
...         print(self.notion)
...         if len(args) != 0:
...             print("\n".join(args))
... 
>>> class Advice(Thought):
...     def message(self):
...         super(Advice, self).message("警告: 日历里的日期比它们看起来更近!")
... 
>>> t = Thought()   
我是类型Thought的新对象!
>>> t.message()
我觉得我在平行宇宙中把车停歪了.
>>> a = Advice()
我是类型Thought的子类型的新对象!
>>> a.message()
我觉得我在平行宇宙中把车停歪了.
警告: 日历里的日期比它们看起来更近!
>>> # 内省一下:
>>> [*super.__dict__]
['__repr__', '__getattribute__', '__get__', '__init__', '__new__', '__thisclass__', '__self__', '__self_class__', '__doc__']
>>> [*super(Advice).__thisclass__.__dict__]
['__module__', 'message', '__doc__', 'cls_name']
>>> super(Advice).__thisclass__.__dict__['cls_name']
'类型Thought的子类型'
>>> [*super(Advice, a).__self__.__dict__]
['notion']
>>> super(Advice, a).__self_class__.__dict__['cls_name']
'类型Thought的子类型'
>>> super(Advice, a).message()
我觉得我在平行宇宙中把车停歪了.
>>> super(Advice).__get__(a).message()
我觉得我在平行宇宙中把车停歪了.
  31. ^ 特殊方法、类方法和静态方法（__new__()）示例： 
    >>> from weakref import WeakValueDictionary
>>> class D:
...     _template = {}
...     _obj_dict = WeakValueDictionary()
...     def __new__(cls, *args, **kwargs):
...         obj = super(D, cls).__new__(cls)
...         cls._obj_dict[id(obj)] = obj
...         return obj
...     @classmethod
...     def load(cls, dict):
...         cls._template.update(dict)
...     @classmethod
...     def create(cls, *args, **kwargs):
...         return cls(cls._template, *args, **kwargs)
...     @classmethod
...     def count(cls):
...         return len(cls._obj_dict)
...     def __init__(self, dict={}, /, *args, **kwargs):
...         self.__dict__.update(dict)
...         self.__dict__.update(kwargs)
...     def __call__(self, *args, **kwargs):
...         self.__dict__.update(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__ in D._obj_dict.valuerefs()
True
  32. ^ 在类中采用数据描述器的示例： 
    >>> class RevealAccess:
...     """正常的设置和返回值的数据描述器，
...        它还打印记录这次访问的一个消息。
...     """
...     def __init__(self, initval=None, name='var'):
...         self.val = initval
...         self.name = name
...     def __get__(self, obj, objtype):
...         print('Retrieving', self.name)
...         return self.val
...     def __set__(self, obj, val):
...         print('Updating', self.name)
...         self.val = val
... 
>>> class MyClass:
...     x = RevealAccess(10, 'var "x"')
...     y = 5
...
>>> m = MyClass()
>>> m.x
Retrieving var "x"
10
>>> vars(m)
{}
>>> MyClass.__dict__['x'].val
10
>>> m.x = 20
Updating var "x"
>>> vars(m)
{}
>>> MyClass.__dict__['x'].val
20
>>> m.y
5
>>> vars(m)
{}
>>> m.y = 5
>>> vars(m)
{'y': 5}
  33. ^ 在类中调用property()的例子： 
    >>> class C:
...     def __init__(self):
...         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.")
... 
>>> c = C()
>>> vars(c)
{'_C__x': None}
>>> {*C.__dict__}
{'__init__', 'setx', '__weakref__', 'delx', 'x', 'getx', '__doc__', '__module__', '__dict__'}

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

    >>> class C:
...     def __init__(self):
...         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__', '__weakref__', 'x', '__doc__', '__module__', '__dict__'}
  34. ^ 创建列表的特殊语法示例： 
    a_list = [1, 2, 3, "a dog"]

    采用正常的对象创建方式的示例： 

    a_second_list = list()
a_second_list.append(4)
a_second_list.append(5)

    创建元组的特殊语法示例： 

    a_tuple = 1, 2, 3, "four"

    创建集合的特殊语法示例： 

    some_set = {0, (), False}

    创建字典的特殊语法示例： 

    a_dictionary = {"key 1": "value 1", 2: 3, 4: []}
  35. ^ 两个类及元类等的实例关系（蓝色连接）与继承关系（绿色连接）示意图：
      
    r = object
c = type
class M(c): pass

class A(metaclass=M): pass

class B(A): pass

b = B()
    		Eigenclass-model-sample-pr.svg 
    >>> 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'> ()
  36. ^ 数学运算示例。比如： 
    >>> def mean(seq):
...     return sum(seq) / len(seq)
... 
>>> mean([3, 4])
3.5
>>> import math
>>> print(math.sin(math.pi/2))
1.0

版本3相对版本2的主要变化[编辑]

Python3相较于Python2的变化主要在以下几个方面[155]：

  • 除法运算符/在Python 3.x内总是返回浮点数。而在Python 2.6内会判断被除数与除数是否是整数。如果是整数会返回整数值，相当于整除；浮点数则返回浮点数值。要让Python 2.6统一返回浮点数值，可以from __future__ import division。
  • print语句没有了，取而代之的是print()函数。可以使用2to3工具来自动转换。Python 2.6与Python 2.7部分地支持这种形式的print语法。Python 2.6要支持完全新的print()语法，可以from __future__ import print_function。
  • 取消了exec语句，只剩下exec()函数。Python 2.6已经支持exec()函数。
  • 移除Python 2的input函数，并将raw_input函数重命名为input。Python 3的input函数表现得如同Python 2的raw_input函数，在其中输入总是作为字符串返回而非作为表达式求值。
  • 捕获异常的语法由except exc, var改为except exc as var。使用语法except (exc1, exc2) as var可以同时捕获多种类型的异常。Python 2.6已经支持这两种语法。
  • 如果两个对象之间没有定义明确的有意义的顺序。使用<, >, <=, >=比较它们会抛出异常。比如1 < ""在Python 2.6里面会返回True，而在Python 3.0里面会抛出异常。现在cmp(), instance.__cmp__()函数已经被删除。
  • 集合（set）的新写法：{1,2,3,4}。注意{}仍然表示空的字典（dict）。
  • 将long类型重命名为int类型，就是说只有一种整数类型，叫做int而表现得更像老式的long。
  • 新的str类型表示一个Unicode字符串，相当于Python 2.x版本的unicode类型。而字节序列则用类似b"abc"的语法表示，用bytes类表示，相当于Python 2.x的str类型。现在两种类型不能再隐式地自动转换，因此在Python 3.x里"fish" + b"panda"是错误的。正确的写法是"fish" + b"panda".decode("utf-8")。Python 2.6可以自动地将字节序列识别为Unicode字符串，方法是from __future__ import unicode_literals。
  • 八进制数必须写成0o777，原来的形式0777不能用了；二进制必须写成0b111。新增了一个bin()函数用于将一个整数转换成二进制字符串。Python 2.6已经支持这两种语法。
  • dict.keys(), dict.values(), dict.items(), map(), filter(), range(), zip()不再返回列表，而是迭代器。
  • 将reduce（不涉及map或filter）从内建名字空间移动至functools，理由是使用reduce的代码不如使用循环和累加器变量的代码好读[156]。
  • 多个模块被改名（根据PEP8）：winreg → winreg，ConfigParser → configparser，copy_reg → copyreg，Queue → queue，SocketServer → socketserver，repr → reprlib。
  • StringIO模块现在被合并到新的io模块内。new, md5, gopherlib等模块被删除。Python 2.6已经支持新的io模块。
  • httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib被合并到http包内。

参考文献[编辑]

  1. ^ Guttag, John V. Introduction to Computation and Programming Using Python: With Application to Understanding Data. MIT Press. 12 August 2016. ISBN 978-0-262-52962-4. 
  2. ^ Python 3.9.4 hotfix is now available. 2021年4月4日 [2021年4月5日] （英语）. 
  3. ^ Python 3.10.0a7 is now available for testing. 2021年4月6日 [2021年4月6日] （英语）. 
  4. ^ Why is Python a dynamic language and also a strongly typed language - Python Wiki. wiki.python.org. [2021-01-27]. 
  5. ^ PEP 483 -- The Theory of Type Hints. Python.org. [2020-04-22]. （原始内容存档于2020-06-14）. 
  6. ^ File extension .pyo was removed in Python 3.5. See PEP 0488 （页面存档备份，存于互联网档案馆）
  7. ^ Holth, Moore. PEP 0441 -- Improving Python ZIP Application Support. 2014-03-30 [2015-11-12]. （原始内容存档于2018-12-26）. 
  8. ^ Starlark Language. [25 May 2019]. 
  9. ^ 9.0 9.1 9.2 Why was Python created in the first place?. Python FAQ. [2007-03-22]. （原始内容存档于2008-02-23）. 
  10. ^ Ada 83 Reference Manual (raise statement). 
  11. ^ Kuchling, Andrew M. Interview with Guido van Rossum (July 1998). amk.ca. 22 December 2006 [12 March 2012]. （原始内容存档于1 May 2007）. 
  12. ^ 12.0 12.1 itertools — Functions creating iterators for efficient looping — Python 3.7.1 documentation. docs.python.org. 
  13. ^ van Rossum, Guido. An Introduction to Python for UNIX/C Programmers. Proceedings of the NLUUG Najaarsconferentie (Dutch UNIX Users Group). 1993. even though the design of C is far from ideal, its influence on Python is considerable. 
  14. ^ 14.0 14.1 Classes. The Python Tutorial. Python Software Foundation. [20 February 2012]. It is a mixture of the class mechanisms found in C++ and Modula-3 
  15. ^ Lundh, Fredrik. Call By Object. effbot.org. [21 November 2017]. replace "CLU" with "Python", "record" with "instance", and "procedure" with "function or method", and you get a pretty accurate description of Python's object model. 
  16. ^ Simionato, Michele. The Python 2.3 Method Resolution Order. Python Software Foundation. The C3 method itself has nothing to do with Python, since it was invented by people working on Dylan and it is described in a paper intended for lispers 
  17. ^ Kuchling, A. M. Functional Programming HOWTO. Python v2.7.2 documentation. Python Software Foundation. [9 February 2012]. 
  18. ^ Schemenauer, Neil; Peters, Tim; Hetland, Magnus Lie. PEP 255 – Simple Generators. Python Enhancement Proposals. Python Software Foundation. 18 May 2001 [9 February 2012]. 
  19. ^ Smith, Kevin D.; Jewett, Jim J.; Montanaro, Skip; Baxter, Anthony. PEP 318 – Decorators for Functions and Methods. Python Enhancement Proposals. Python Software Foundation. 2 September 2004 [24 February 2012]. 
  20. ^ More Control Flow Tools. Python 3 documentation. Python Software Foundation. [24 July 2015]. 
  21. ^ CoffeeScript. coffeescript.org. 
  22. ^ The Genie Programming Language Tutorial. [28 February 2020]. 
  23. ^ Perl and Python influences in JavaScript. www.2ality.com. 24 February 2013 [15 May 2015]. 
  24. ^ Rauschmayer, Axel. Chapter 3: The Nature of JavaScript; Influences. O'Reilly, Speaking JavaScript. [15 May 2015]. 
  25. ^ 25.0 25.1 Why We Created Julia. Julia website. February 2012 [2014-06-05]. （原始内容存档于2020-05-02）. We want something as usable for general programming as Python [...] 
  26. ^ Ring Team. Ring and other languages. ring-lang.net. ring-lang. 4 December 2017. 
  27. ^ Bini, Ola. Practical JRuby on Rails Web 2.0 Projects: bringing Ruby on Rails to the Java platform. Berkeley: APress. 2007: 3. ISBN 978-1-59059-881-8. 
  28. ^ Lattner, Chris. Chris Lattner's Homepage. Chris Lattner. 3 June 2014 [3 June 2014]. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list. 
  29. ^ 彼德·诺米格. Python for Lisp Programmers. [2020-04-21]. （原始内容存档于2020-06-14）. Python can be seen as a dialect of Lisp with "traditional" syntax (what Lisp people call "infix" or "m-lisp" syntax). 
  30. ^ Whetting Your Appetite. The Python Tutorial. Python Software Foundation. [2012-02-20]. （原始内容存档于2012-10-26）. 
  31. ^ Benevolent dictator for life. Linux Format. 2005-02-01 [2007-11-01]. （原始内容存档于2006-10-01）. 
  32. ^ Transfer of power. [2020-11-29]. （原始内容存档于2018-07-12）. 
  33. ^ PEP 8100. python. Python Software Foundation. [2019-05-04]. （原始内容存档于2020-06-04）. 
  34. ^ Steering Council nomination: Guido van Rossum (2020 term). [2020-10-11]. （原始内容存档于2019-12-29）. 
  35. ^ HISTORY. Python source distribution. Python Foundation. [2017-11-23]. （原始内容存档于2017-12-01）. 
  36. ^ The Making of Python. Artima Developer. [2007-03-22]. （原始内容存档于2016-09-01）. 
  37. ^ van Rossum, Guido. The fate of reduce() in Python 3000. Artima Developer. [2007-03-22]. （原始内容存档于2007-04-07）. 
  38. ^ LJ #37: Python 1.4 Update. [2007-04-29]. （原始内容存档于2007-05-01）. 
  39. ^ Kuchling, A. M.; Zadka, Moshe. What's New in Python 2.0. Python Software Foundation. 2000-10-16 [2012-02-11]. （原始内容存档于2012-10-23）. 
  40. ^ Hylton, Jeremy. PEP 227 -- Statically Nested Scopes. 2000-11-01 [2007-03-22]. （原始内容存档于2007-03-29）. 
  41. ^ 41.0 41.1 41.2 Guido van Rossum. Unifying types and classes in Python 2.2. [2020-09-26]. （原始内容存档于2019-09-28）. 
  42. ^ What’s New in Python 2.2 － PEP 234: Iterators. [2020-10-21]. （原始内容存档于2021-02-07）. 
  43. ^ What’s New in Python 2.2 － PEP 255: Simple Generators. 
  44. ^ What’s New in Python 2.2 － Descriptors. [2020-10-21]. （原始内容存档于2021-02-07）. 
  45. ^ What’s New in Python 2.4 － PEP 318: Decorators for Functions and Methods. [2020-10-21]. （原始内容存档于2021-02-07）. 
  46. ^ What’s New in Python 2.5 － PEP 343: The ‘with’ statement. [2020-10-21]. （原始内容存档于2021-02-07）. 
  47. ^ Python 3.0 Release. Python Software Foundation. [2009-07-08]. （原始内容存档于2020-06-14）. 
  48. ^ Automated Python 2 to 3 code translation — Python Documentation. [2018-02-11]. （原始内容存档于2020-06-04）. 
  49. ^ van Rossum, Guido. PEP 3000 – Python 3000. Python Enhancement Proposals. Python Software Foundation. 2006-04-05 [2009-06-27]. （原始内容存档于2016-03-03）. 
  50. ^ PEP 373 -- Python 2.7 Release Schedule. python.org. [2017-01-09]. （原始内容存档于2020-05-19）. 
  51. ^ PEP 466 -- Network Security Enhancements for Python 2.7.x. python.org. [2017-01-09]. （原始内容存档于2020-06-04）. 
  52. ^ Python Developer's Guide — Python Developer's Guide. devguide.python.org. [17 December 2019]. （原始内容存档于2020-01-20）. 
  53. ^ PEP 8102 -- 2021 Term steering council election. Python Software Foundation. [2020-12-17]. （原始内容存档于2020-12-16）. 
  54. ^ The Cain Gang Ltd. Python Metaclasses: Who? Why? When? (PDF). [2009-06-27]. （原始内容 (PDF)存档于2009-05-30）. 
  55. ^ 55.0 55.1 The Python Language Reference, section 3.3. Special method names, for release 3.8.6. [2020-09-25]. （原始内容存档于2012-10-26）. 
  56. ^ Several:
  57. ^ PEP 316 -- Programming by Contract for Python. [2021-01-17]. （原始内容存档于2021-01-22）. 
  58. ^ PyDatalog. [2012-07-22]. （原始内容存档于2020-06-13）. 
  59. ^ Extending and Embedding the Python Interpreter: Reference Counts. Docs.python.org. [2020-06-05]. （原始内容存档于2012-10-18） （英语）. Since Python makes heavy use of malloc() and free(), it needs a strategy to avoid memory leaks as well as the use of freed memory. The chosen method is called reference counting. 
  60. ^ Functional Programming HOWTO. [2020-09-26]. （原始内容存档于2012-10-24）. 
  61. ^ 61.0 61.1 Hettinger, Raymond. PEP 289 – Generator Expressions. Python Enhancement Proposals. Python Software Foundation. 2002-01-30 [2012-02-19]. （原始内容存档于2020-06-14）. 
  62. ^ Functional Programming Modules. Docs.python.org. [2020-09-26]. （原始内容存档于2020-09-20）. 
  63. ^ Guido van Rossum. Foreword for "Programming Python" (1st ed.). 1996-05-01 [2020-09-12]. （原始内容存档于2014-07-24） （英语）. 
  64. ^ Style Guide for Python Code: indentation. [2020-09-26]. （原始内容存档于2018-07-13）. 
  65. ^ 2. Lexical analysis. Python v3.8.6 documentation. Docs.python.org. [2020-09-26]. （原始内容存档于2018-01-09）. 
  66. ^ 2. Lexical analysis. Python v2.7.18 documentation. Docs.python.org. [2020-09-26]. （原始内容存档于2019-05-08）. 
  67. ^ New Keywords. Python v3.5 documentation. Docs.python.org. [2016-06-01]. （原始内容存档于2016-06-18）. 
  68. ^ Naming Conventions. [2017-10-06]. （原始内容存档于2018-07-13）. 
  69. ^ 69.0 69.1 9.6. Private Variables. [2020-09-27]. （原始内容存档于2012-10-23）. 
  70. ^ 70.0 70.1 PEP 342 -- Coroutines via Enhanced Generators. [2019-11-21]. （原始内容存档于2020-05-29）. 
  71. ^ PEP 380 -- Syntax for Delegating to a Subgenerator. [2019-11-21]. （原始内容存档于2020-06-04）. 
  72. ^ Highlights: Python 2.5. Python.org. [2020-09-21]. （原始内容存档于2019-08-04）. 
  73. ^ Hamblen, Diane. Only the Limits of Our Imagination: An exclusive interview with RADM Grace M. Hopper. Department of the Navy Information Technology Magazine. [2007-01-31]. （原始内容存档于2009-01-14）. 
  74. ^ "It is Easier to Ask for Forgiveness than Permission" EAFP （页面存档备份，存于互联网档案馆）, Python Glossary
  75. ^ Alex Martelli. Python in a nutshell. : 134. 
  76. ^ The "with" Statement. [2020-09-26]. （原始内容存档于2014-12-14）. 
  77. ^ van Rossum, Guido. Tail Recursion Elimination. Neopythonic.blogspot.be. 2009-04-22 [2012-12-03]. （原始内容存档于2018-05-19）. 
  78. ^ van Rossum, Guido. Language Design Is Not Just Solving Puzzles. Artima forums. Artima. 2006-02-09 [2007-03-21]. （原始内容存档于2020-01-17）. 
  79. ^ PEP 3156 -- Asynchronous IO Support Rebooted: the "asyncio" Module. [2019-11-21]. （原始内容存档于2019-11-14）. 
  80. ^ Generator-based Coroutines. [2020-10-29]. （原始内容存档于2018-12-31）. Support for generator-based coroutines is deprecated and is scheduled for removal in Python 3.10. 
  81. ^ PEP 492 -- Coroutines with async and await syntax. [2019-11-21]. （原始内容存档于2019-01-05）. 
  82. ^ What’s New In Python 3.7. [2019-11-21]. （原始内容存档于2019-11-28）. 
  83. ^ 83.0 83.1 83.2 Python.org: Modules. [2020-10-30]. （原始内容存档于2021-02-06）. 
  84. ^ 84.0 84.1 Python.org: The import Statement. [2020-10-30]. （原始内容存档于2021-02-07）. 
  85. ^ Python.org: __main__. [2020-10-30]. （原始内容存档于2021-02-07）. 
  86. ^ Python.org: Dir(). [2020-09-25]. （原始内容存档于2018-10-26）. 
  87. ^ division. python.org. [2014-10-17]. （原始内容存档于2006-07-20）. 
  88. ^ PEP 0465 -- A dedicated infix operator for matrix multiplication. python.org. [2016-01-01]. （原始内容存档于2020-06-04）. 
  89. ^ Python 3.5.1 Release and Changelog. python.org. [2016-01-01]. （原始内容存档于2020-05-14）. 
  90. ^ Chapter 15. Expressions - 15.21.1. Numerical Equality Operators == and !=. Oracle Corporation. [2016-08-28]. （原始内容存档于2020-06-07）. 
  91. ^ Chapter 15. Expressions - 15.21.3. Reference Equality Operators == and !=. Oracle Corporation. [2016-08-28]. （原始内容存档于2020-06-07）. 
  92. ^ What’s New in Python 3.8 － Assignment expressions. [2019-10-14]. （原始内容存档于2020-06-08）. 
  93. ^ 4. Built-in Types — Python 3.6.3rc1 documentation. python.org. [2017-10-01]. （原始内容存档于2020-06-14）. 
  94. ^ 5.3. Tuples and Sequences — Python 3.7.1rc2 documentation. python.org. [2018-10-17]. （原始内容存档于2020-06-10）. 
  95. ^ 95.0 95.1 PEP 498 -- Literal String Interpolation. python.org. [2017-03-08]. （原始内容存档于2020-06-15）. 
  96. ^ 2. Lexical analysis. Python v2.7.5 documentation. Docs.python.org. [2013-08-16]. （原始内容存档于2012-10-23）. 
  97. ^ What’s New in Python 2.2 － Descriptors. [2020-10-21]. （原始内容存档于2021-02-07）. 
  98. ^ Python 2.4 Decorators: Reducing code duplication and consolidating knowledge. Dr. Dobb's. 2005-05-01 [2007-02-08]. （原始内容存档于2007-02-06）. 
  99. ^ New Tail Recursion Decorator. ASPN: Python Cookbook. 2006-11-14 [2007-02-08]. （原始内容存档于2007-02-09）. 
  100. ^ The decorator module. [2007-02-08]. （原始内容存档于2007-02-10）. 
  101. ^ PEP 484 -- Type Hints. 
  102. ^ PEP 3107 -- Function Annotations. 
  103. ^ Special Attributes. [2020-09-12]. （原始内容存档于2020-06-14）. 
  104. ^ Why must 'self' be used explicitly in method definitions and calls?. Design and History FAQ. Python Software Foundation. [2012-02-19]. （原始内容存档于2012-10-24）. 
  105. ^ super().method, in Python 3. [2020-09-25]. （原始内容存档于2018-10-26）. 
  106. ^ Descriptor HowTo Guide. [2020-09-26]. （原始内容存档于2020-09-18）. 
  107. ^ Built-in Functions: property. [2020-09-25]. （原始内容存档于2018-10-26）. 
  108. ^ The Python Language Reference, section 3.3. New-style and classic classes, for release 2.7.18. [2020-09-25]. （原始内容存档于2020-05-05）. 
  109. ^ Type hinting for Python. LWN.net. 2014-12-24 [2015-05-05]. （原始内容存档于2019-06-20）. 
  110. ^ mypy - Optional Static Typing for Python. [2017-01-28]. （原始内容存档于2020-06-06）. 
  111. ^ 。实际受限于机器的内存大小Zadka, Moshe; van Rossum, Guido. PEP 237 – Unifying Long Integers and Integers. Python Enhancement Proposals. Python Software Foundation. 2001-03-11 [2011-09-24]. （原始内容存档于2020-05-28）. 
  112. ^ 15. Floating Point Arithmetic: Issues and Limitations — Python 3.8.3 documentation. docs.python.org. [2020-06-06]. （原始内容存档于2020-06-06）. almost all platforms map Python floats to IEEE-754 double precision 
  113. ^ Built-in Types. [2019-10-03]. （原始内容存档于2020-06-14）. 
  114. ^ PEP 465 -- A dedicated infix operator for matrix multiplication. python.org. [2020-09-24]. （原始内容存档于2020-05-29）. 
  115. ^ Zadka, Moshe; van Rossum, Guido. PEP 238 – Changing the Division Operator. Python Enhancement Proposals. Python Software Foundation. 2001-03-11 [2013-10-23]. （原始内容存档于2020-05-28）. 
  116. ^ round, The Python standard library, release 3.2, §2: Built-in functions, [2011-08-14], （原始内容存档于2012-10-25） 
  117. ^ Beazley, David M. Python Essential Reference 4th. 2009: 66. 
  118. ^ Kernighan, Brian W.; Ritchie, Dennis M. The C Programming Language 2nd. 1988: 206. 
  119. ^ Batista, Facundo. PEP 0327 -- Decimal Data Type. Python.org. [2015-09-26]. （原始内容存档于2020-06-04）. 
  120. ^ What's New in Python 2.6 — Python v2.6.9 documentation. docs.python.org. [2015-09-26]. （原始内容存档于2019-12-23）. 
  121. ^ 10 Reasons Python Rocks for Research (And a Few Reasons it Doesn't) – Hoyt Koepke. www.stat.washington.edu. [2019-02-03]. （原始内容存档于2020-05-31）. 
  122. ^ Shell, Scott. An introduction to Python for scientific computing (PDF). 2014-06-17 [2019-02-03]. （原始内容存档 (PDF)于2019-02-04）. 
  123. ^ Przemyslaw Piotrowski, Build a Rapid Web Development Environment for Python Server Pages and Oracle （页面存档备份，存于互联网档案馆）, Oracle Technology Network, July 2006. Accessed October 21, 2008.
  124. ^ CPython byte code. Docs.python.org. [2016-02-16]. （原始内容存档于2020-06-05）. 
  125. ^ Python 2.5 internals (PDF). [2011-04-19]. （原始内容存档 (PDF)于2012-08-06）. 
  126. ^ The Computer Language Benchmarks Game. [2020-04-30]. （原始内容存档于2020-06-14）. 
  127. ^ http://www.Python.org （页面存档备份，存于互联网档案馆） CPython
  128. ^ PyPy – Python compatibility. pypy.org. [2020-12-15]. 
  129. ^ speed comparison between CPython and Pypy. Speed.pypy.org. [2012-12-03]. （原始内容存档于2020-06-01）. 
  130. ^ Shaw, Anthony. Which is the fastest version of Python?. Hacker Noon. 2018-03-30 [2019-12-20]. （原始内容存档于2020-06-14）. 
  131. ^ Application-level Stackless features — PyPy 2.0.2 documentation. Doc.pypy.org. [2013-07-17]. （原始内容存档于2020-06-04）. 
  132. ^ Nuitka Home. nuitka.net. [2017-08-18]. （原始内容存档于2020-05-30） （英语）. 
  133. ^ Borderies, Olivier. Pythran: Python at C++ speed !. Medium. 2019-01-24 [2020-09-12]. （原始内容存档于2020-03-25）. 
  134. ^ Pythran — Pythran 0.9.5 documentation. pythran.readthedocs.io. [2020-09-12]. （原始内容存档于2020-02-19）. 
  135. ^ google/grumpy. 2020-04-10 [2020-09-12]. （原始内容存档于2020-04-15） –通过GitHub. 
  136. ^ Asynchronous HTTP Client/Server for asyncio and Python. [2021-01-14]. （原始内容存档于2021-01-15）. 
  137. ^ gevent is a coroutine-based Python networking library that uses greenlet to provide a high-level synchronous API on top of the libev or libuv event loop. 
  138. ^ Pillow: a modern fork of PIL. [December 8, 2013]. 
  139. ^ PyInstaller. 
  140. ^ pywin32. 
  141. ^ TIOBE Index. TIOBE - The Software Quality Company. [2021-01-12]. （原始内容存档于2020-06-14）. 
  142. ^ TIOBE Software Index. TIOBE Programming Community Index Python. [2021-02-07]. （原始内容存档于2021-02-06）. 
  143. ^ 《Python技术手册》的作者马特利（Alex Martelli）. Heavy usage of Python at Google. [2012-11-30]. （原始内容存档于2012-10-06）. 这很难讲，不过，2004年，Python已在Google内部使用，Google召募许多Python高手，但在这之前就已决定使用Python。他们的目的是尽量使用Python，在不得已时改用C++；在操控硬件的场合使用C++，在快速开发时候使用Python。 
  144. ^ Fabric: Pythonic remote execution. [2013-04-08]. （原始内容存档于2014-04-11）. 
  145. ^ Python Discord is a large community focused around the Python programming language. [2021-01-13]. （原始内容存档于2021-02-01）. 
  146. ^ Gotchas for Python Users. boo.codehaus.org. Codehaus Foundation. [2008-11-24]. （原始内容存档于2008-12-11）. 
  147. ^ Esterbrook, Charles. Acknowledgements. cobra-language.com. Cobra Language. [2010-04-07]. （原始内容存档于2008-02-08）. 
  148. ^ Proposals: iterators and generators [ES4 Wiki]. wiki.ecmascript.org. [2008-11-24]. （原始内容存档于2007-10-20）. 
  149. ^ FAQ: What is GDScript and why should I use it?. [2020-09-13]. （原始内容存档于2020-05-19）. 
  150. ^ Kincaid, Jason. Google's Go: A New Programming Language That's Python Meets C++. TechCrunch. 2009-11-10 [2010-01-29]. （原始内容存档于2010-01-18）. 
  151. ^ Strachan, James. Groovy – the birth of a new dynamic language for the Java platform. 2003-08-29 [2007-06-11]. （原始内容存档于2007-04-05）. 
  152. ^ Yegulalp, Serdar. Nim language draws from best of Python, Rust, Go, and Lisp. InfoWorld. 2017-01-16 [2020-09-13]. （原始内容存档于2018-10-13）. Nim's syntax is strongly reminiscent of Python's, as it uses indented code blocks and some of the same syntax (such as the way if/elif/then/else blocks are constructed). 
  153. ^ An Interview with the Creator of Ruby. Linuxdevcenter.com. [2012-12-03]. （原始内容存档于2018-04-28）. 
  154. ^ Lattner, Chris. Chris Lattner's Homepage. Chris Lattner. 2014-06-03 [2014-06-03]. （原始内容存档于2015-12-22）. I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013 [...] drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list. 
  155. ^ Guido van Rossum. What’s New in Python 3.0. Python Software Foundation. 2009-02-14 [2011-02-22]. （原始内容存档于2010-12-24） （英语）. 
  156. ^ van Rossum, Guido. Python 3000 FAQ. artima.com. [2016-12-27]. （原始内容存档于2020-11-09）. 

延伸阅读[编辑]

参见[编辑]

外部链接[编辑]

从维基百科的姊妹计划
了解更多有关
“Python”的内容
搜索维基共享资源 维基共享资源上的多媒体资源
搜索维基语录 维基语录上的名言
搜索维基教科书 维基教科书上的教科书和手册
搜索维基学院 维基学院上的学习资源
实现
Python-logo-notext.svg
IDE
专题

按范型
过程式
面向对象
多范型
函数式
逻辑式
脚本语言
ECMA-262
动态语言
Shell语言
特定平台
.NET
JVM
Xcode
特定领域
科学计算
GPU计算
数据查询
可视化
设计语言
其它
常见概念与条目
操作系统（内核）
AROS Research Operating System（英语：AROS） · BSD · Darwin · FreeDOS · GNU Hurd · Haiku ·  Inferno · Linux · Mach · Minix · OpenSolaris · Plan 9 · ReactOS · Symbian
软件列表
历史与运动
组织（英语：List of free and open-source software organizations）与社区
许可证
类型与标准
挑战
其他
取自“https://zh.wikipedia.org/w/index.php?title=Python&oldid=65310327”