查看“Python”的源代码

Python是一种广泛使用的解释型、高级编程、通用型编程语言。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或者关键词）。相比于[[C++]]或[[Java]]，Python让开发者能够用更少的代码表达想法。

==简介==
===时间轴===
* 1991年，荷兰程序员吉多·范罗苏姆（Guido van Rossum），在alt.sources上发布Python 0.9.0。
* 1994年，Python 1.0 发布。
* 2000年5月，Guido 和 Python 核心开发团队转到 BeOpen.com 并组建了 BeOpen PythonLabs 团队。 
* 2000年10月，PythonLabs 团队转到 Digital Creations (现为 [https://www.zope.org/ Zope Corporation])。
* 2000年10月16日，Python 2.0 发布，增加了实现完整的垃圾回收，并且支持Unicode。同时，整个开发过程更加透明，社区对开发进度的影响逐渐扩大。
* 2001年，Python 软件基金会 ([https://www.python.org/psf/ PSF]) 成立，这是一个专为拥有 Python 相关知识产权而创建的非营利组织。
* 2008年12月3日，Python 3.0 发布，此版不完全兼容之前的Python源代码。

{{了解更多
|[https://zh.wikipedia.org/wiki/Python#历史 维基百科：Python - 历史]
|[https://docs.python.org/zh-cn/3/license.html Python文档：历史和许可证]
}}
===安装===
{{了解更多
|[https://docs.python.org/zh-cn/3/using/index.html Python3 文档：安装和使用]
}}
====在Windows上使用====
与大多数Linux系统不同，Windows系统没有预安装Python。Windows提供了许多不同的安装程序：
* 完整安装程序，内含所有组件，对于使用Python 进行任何类型项目的开发人员而言，它是最佳选择。
* 可嵌入的包，是Python的最小安装包，适合嵌入到更大的应用程序中。
* Microsoft Store包，是一个简单的Python 安装，适用于运行脚本和包，以及使用IDLE或其他开发环境。 在Windows 10的Microsoft Store里搜索安装
* nuget.org 安装包，是用于持续集成系统的轻量级安装。它可用于构建Python包或运行脚本，但不可更新且没有用户界面工具。

下面介绍完整安装程序安装：
* 下载[https://www.python.org/downloads/windows/ Python 安装程序]，完整包提供4种选择，32位或64位，在线安装（web-based installer）或 离线安装（executable installer）。
* 运行安装程序，注意勾上Add Python x.xx to PATH，否则需要手动添加到PATH中。
* 安装成功后，打开命令提示符窗口（cmd），输入python后会显示Python版本号。

{{了解更多
|[https://docs.python.org/zh-cn/3/using/windows.html Python文档：在Windows上使用 Python]
}}

==基础==
===基本语法===

===变量===

==数据类型==
===数字===
====数字类型====
Python内置3种[[数字]]类型：[[整数]]（int）, [[浮点数]]（float） 和 [[复数]]（complex）。[[布尔值]]（bool）属于整数的子类型，True用1表示，False用0表示。 浮点数通常使用 C语言 中的 double 来实现；有关你的程序运行所在机器上浮点数的精度和内部表示法可在 sys.float_info 中查看。 复数包含实部和虚部，分别以一个浮点数表示。 要从一个复数 z 中提取这两个部分，可使用 z.real 和 z.imag。（标准库包含附加的数字类型，如表示有理数的 fractions.Fraction 以及以用户定制精度表示浮点数的 decimal.Decimal。）

数字是由数字字面值或内置函数与运算符的结果来创建的。 不带修饰的整数字面值（包括十六[[进制]]、八进制和二进制数）会生成整数。 包含小数点或幂运算符的数字字面值会生成浮点数。 在数字字面值末尾加上 'j' 或 'J' 会生成虚数（实部为零的复数），你可以将其与整数或浮点数相加来得到具有实部和虚部的复数。

{| class="wikitable"  style="width: 100%;
! 数字类型
! 描述
|-
| int
| 整数，整数字面值的长度没有限制，能一直大到占满可用内存。数值间可以添加下划线<code>_</code>，提高可读性。不同进制整数字面值写法如下：<br \>*十进制数，用0-9数字表示，并且非0数字开头，如<code>71</code>，<code>10_000_000</code>。 <br \>*二进制数，0b或0B开头，用0和1表示，如<code>0b01</code>, <code>0b_1110_0101</code>。 <br \>  *八进制数，0o或0O开头，用0-7表示，如<code>0o12</code>。 <br \>  *十六进制数，0x或0X开头，用0-9和A-F表示，如<code>0x3F</code>。
|-
| float
| 浮点数，
|-
| complex
| 复数，
|-
| fractions.Fraction
| 分数，属于标准库fractions，使用前导入即可：<code>from fractions import Fraction</code>。创建如：<code>Fraction('3/7')</code>，<code>Fraction(16, -10)</code>
|-
| decimal.Decimal
| 用户定制精度表示浮点数，属于标准库decimal，使用前导入即可：<code>from decimal import Decimal</code>。创建如：<code>Decimal(-7)</code>，<code>Decimal((0, (1, 4, 1, 4), -3))</code>
|}
{{了解更多
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#numeric-types-int-float-complex Python 3 标准库：内置类型 - 数字类型 --- int, float, complex]
|[https://docs.python.org/zh-cn/3/reference/lexical_analysis.html#numeric-literals  Python 3 参考：词法分析 - 数字字面值]
}}
====数字运算====
Python 完全支持混合运算：当一个二元算术运算符的操作数有不同数值类型时，"较窄"类型的操作数会拓宽到另一个操作数的类型，其中整数比浮点数窄，浮点数比复数窄。不同类型的数字之间的比较，同比较这些数字的精确值一样。

所有数字类型（复数除外）都支持下列运算（有关运算优先级，请参阅：[https://docs.python.org/zh-cn/3/reference/expressions.html#operator-summary 运算符优先级]）:
{| class="wikitable"  style="width: 100%;
! 运算
! 描述
! 示例
|-
| x + y
| x 和 y 的和
|
|-
| x - y
| x 和 y 的差
|
|-
| x * y
| x 和 y 的乘积
|
|-
| x / y
| x 和 y 的商
|
|-
| x // y
| x 和 y 的商数
|
|-
| x % y
| x / y 的余数
|
|-
| -x
| x 取反
|
|-
| +x
| x 不变
|
|-
| abs(x)
| x 的绝对值或大小
|
|-
| int(x)
| 将 x 转换为整数
|
|-
| float(x)
| 将 x 转换为浮点数
|
|-
| complex(re, im)
| 一个带有实部 re 和虚部 im 的复数。im 默认为0。
|
|-
| c.conjugate()
| 复数 c 的共轭
|
|-
| divmod(x, y)
| (x // y, x % y)
|
|-
| pow(x, y)
| x 的 y 次幂
|
|-
| x ** y
| x 的 y 次幂
|
|}


===字符串===
在 Python 中处理文本数据是使用 str 对象，也称为字符串。 字符串是由 [[Unicode]] 码位构成的不可变序列。 字符串字面值有多种不同的写法：
{| class="wikitable"  style="width: 100%;
! 写法
! 描述
! 示例
|-
| 单引号<code>'</code>
| 不能够换行，中间允许包含双引号<code>"</code>，
| <code>'Hello'</code>  <br \><code>'Hello "the" world '</code> <br \><code>'It\'s world '</code>
|- 
| 双引号<code>"</code>
| 不能够换行，中间允许包含单引号<code>'</code>
| <code>"Hello"</code>   <br \><code>"Hello 'the' world "</code>
|- 
| 三重引号<code><nowiki>'''</nowiki></code>或<code><nowiki>"""</nowiki></code>
| 字符串可以跨越多行，其中所有的空白字符都将包含在该字符串字面值中。在行尾添加一个<code>\</code>可以去掉该行的换行符。
| <code><nowiki>'''测试'''</nowiki></code> <br \><code> <nowiki>"""test  </nowiki><br \><nowiki> hello </nowiki><br \><nowiki> world """</nowiki></code> 
|- 
|}

可以用反斜杠<code>\</code>来转义，如要在单引号<code>'</code>表示的字符串中使用<code>'</code>，可以使用<code>\'</code>来表示普通的<code>'</code>，而不会被解释器读作字符串的结束一个字符串结束。print() 函数会生成可读性更强的输出，即略去两边的引号，并且打印出经过转义的特殊字符。如<code>\n</code>会被转义为换行符。如果你不希望前置了<code>\</code>的字符转义成特殊字符，可以使用 原始字符串 方式，在引号前添加r即可，如：<code>r'C:\some\name'</code>。

字符串也可以通过使用 str 构造器从其他对象创建。



====字符串操作====
在Python中字符串是一种不可变序列，所以它支持所有一般序列的操作。下表中s 和 s2 是具有相同类型的序列：
{| class="wikitable"  style="width: 100%;
! 操作
! 描述
! 示例
|-
|s + s2
|拼接
|<code>'he' + 'llo'</code>返回'hello'
|-
| s * n 或 n * s
| 重复n次，n为整数
| <code>'a'*3</code>返回'aaa'<br \><code>2*'hi'</code>返回'hihi'
|-
| s[i]
| s 的第 i 项，i为整数，起始为 0
|<code>a='abcde'<br \>a[1]</code>返回'b'
|-
| s[i:j]
| s 从 i 到 j 的切片，i和j为整数
|
|-
| s[i:j:k]
| s 从 i 到 j 步长为 k 的切片，i、j和k为整数
|
|-
| len(s)
| s 的长度
|
|-
| min(s)
| s 的最小项
|
|-
| max(s)
| s 的最大项
|
|-
| s.index(x[, i[, j]])
| x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
|
|-
| s.count(x)
| x 在 s 中出现的总次数
|
|-
| x in s
| 如果 s 中的某项等于 x 则结果为 True，否则为 False
|
|-
| x not in s
| 如果 s 中的某项等于 x 则结果为 False，否则为 True
|
|-
|}
{{了解更多
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#common-sequence-operations Python 3 标准库：内置类型 - 通用序列操作]
}}

====字符串方法====
字符串实现了所有一般序列的操作，还额外提供了以下列出的一些附加方法。
{| class="wikitable"  style="width: 100%;
! 方法
! 描述
! 示例
|-
| str.capitalize()
| 返回原字符串的副本，其首个字符大写，其余为小写。在 3.8 版更改: 第一个字符现在被放入了 titlecase 而不是 uppercase。 这意味着复合字母类字符将只有首个字母改为大写，而再不是全部字符大写。
|
|-
| str.casefold()
| 返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 'ß' 相当于 &quot;ss&quot;。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 &quot;ss&quot;。消除大小写算法的描述请参见 Unicode 标准的 3.13 节。3.3 新版功能.
|
|-
| str.center(width[, fillchar])
| 返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。
|
|-
| str.count(sub[, start[, end]])
| 反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
|
|-
| str.encode(encoding=&quot;utf-8&quot;, errors=&quot;strict&quot;)
| 返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过 codecs.register_error() 注册的值，请参阅 错误处理方案 小节。 要查看可用的编码列表，请参阅 标准编码 小节。errors 参数默认不会被检查，以获得最佳性能，而只在第一次编码错误时使用。启用 Python 开发模式 ，或者使用调试构建来检查 errors 。在 3.1 版更改: 加入了对关键字参数的支持。在 3.9 版更改: errors 现在在开发模式和调试模式下都会被检查。
|
|-
| str.endswith(suffix[, start[, end]])
| 如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
|
|-
| str.expandtabs(tabsize=8)
| 返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。
|<code>'01\t012\t0123'.expandtabs()</code>返回'01 012 0123 
|-
| str.find(sub[, start[, end]])
| 返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。注解find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:<code> 'Py' in 'Python'</code>返回True
|
|-
| str.format(*args, **kwargs)
| 执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。注解当使用 n 类型 (例如: '{:n}'.format(1234)) 来格式化数字 (int, float, complex, decimal.Decimal 及其子类) 的时候，该函数会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域以解码 localeconv() 的 decimal_point 和 thousands_sep 字段，如果它们是非 ASCII 字符或长度超过 1 字节的话，并且 LC_NUMERIC 区域会与 LC_CTYPE 区域不一致。 这个临时更改会影响其他线程。在 3.7 版更改: 当使用 n 类型格式化数字时，该函数在某些情况下会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域。
|<code>The sum of 1 + 2 is {0}.format(1+2)</code> 返回'The sum of 1 + 2 is 3'
|-
| str.format_map(mapping)
| 类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况：&gt;&gt;&gt; class Default(dict):... def __missing__(self, key):... return key...&gt;&gt;&gt; '{name} was born in {country}'.format_map(Default(name='Guido'))'Guido was born in country'3.2 新版功能.
|
|-
| str.index(sub[, start[, end]])
| 类似于 find()，但在找不到子类时会引发 ValueError。
|
|-
| str.isalnum()
| 如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符``c``是字母或数字。
|
|-
| str.isalpha()
| 如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。字母字符是指那些在 Unicode 字符数据库中定义为 &quot;Letter&quot; 的字符，即那些具有 &quot;Lm&quot;、&quot;Lt&quot;、&quot;Lu&quot;、&quot;Ll&quot; 或 &quot;Lo&quot; 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的&quot;字母&quot;属性不同。
|
|-
| str.isascii()
| 如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。3.7 新版功能.
|
|-
| str.isdecimal()
| 如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。 严格地讲，十进制字符是 Unicode 通用类别 &quot;Nd&quot; 中的一个字符。
|
|-
| str.isdigit()
| 如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成 10 进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。
|
|-
| str.isidentifier()
| 如果字符串是有效的标识符，返回 True ，依据语言定义， 标识符和关键字 节。调用 keyword.iskeyword() 来检测字符串 s 是否为保留标识符，例如 def 和 class。
|
|-
| str.islower()
| 如果字符串中至少有一个区分大小写的字符 4 且此类字符均为小写则返回 True ，否则返回 False 。
|
|-
| str.isnumeric()
| 如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
|
|-
| str.isprintable()
| 如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。 不可打印字符是在 Unicode 字符数据库中被定义为 &quot;Other&quot; 或 &quot;Separator&quot; 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）
|
|-
| str.isspace()
| 如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。空白 字符是指在 Unicode 字符数据库 (参见 unicodedata) 中主要类别为 Zs (&quot;Separator, space&quot;) 或所属双向类为 WS, B 或 S 的字符。
|
|-
| str.istitle()
| 如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。
|
|-
| str.isupper()
| 如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。
|<code> 'BANANA'.isupper()</code> 返回True <br \><code> 'banana'.isupper()</code>返回False
|-
| str.join(iterable)
| 返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。
|
|-
| str.ljust(width[, fillchar])
| 返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
|
|-
| str.lower()
| 返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。所用转换小写算法的描述请参见 Unicode 标准的 3.13 节。
|
|-
| str.lstrip([chars])
| 返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:&gt;&gt;&gt; ' spacious '.lstrip()'spacious '&gt;&gt;&gt; 'www.example.com'.lstrip('cmowz.')'example.com'参见 str.removeprefix() ，该方法将删除单个前缀字符串，而不是全部给定集合中的字符。 例如:&gt;&gt;&gt; 'Arthur: three!'.lstrip('Arthur: ')'ee!'&gt;&gt;&gt; 'Arthur: three!'.removeprefix('Arthur: ')'three!'
|
|-
| static str.maketrans(x[, y[, z]])
| 此静态方法返回一个可供 str.translate() 使用的转换对照表。如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。
|
|-
| str.partition(sep)
| 在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。
|
|-
| str.removeprefix(prefix, /)
| 如果字符串以 前缀 字符串开头，返回 string[len(prefix):] 。否则，返回原始字符串的副本：&gt;&gt;&gt; 'TestHook'.removeprefix('Test')'Hook'&gt;&gt;&gt; 'BaseTestCase'.removeprefix('Test')'BaseTestCase'3.9 新版功能.
|
|-
| str.removesuffix(suffix, /)
| 如果字符串以 后缀 字符串结尾，并且 后缀 非空，返回 string[:-len(suffix)] 。否则，返回原始字符串的副本：&gt;&gt;&gt; 'MiscTests'.removesuffix('Tests')'Misc'&gt;&gt;&gt; 'TmpDirMixin'.removesuffix('Tests')'TmpDirMixin'3.9 新版功能.
|
|-
| str.replace(old, new[, count])
| 返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
|
|-
| str.rfind(sub[, start[, end]])
| 返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。
|
|-
| str.rindex(sub[, start[, end]])
| 类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
|
|-
| str.rjust(width[, fillchar])
| 返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
|
|-
| str.rpartition(sep)
| 在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
|
|-
| str.rsplit(sep=None, maxsplit=-1)
| 返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。
|
|-
| str.rstrip([chars])
| 返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:&gt;&gt;&gt; ' spacious '.rstrip()' spacious'&gt;&gt;&gt; 'mississippi'.rstrip('ipz')'mississ'要删除单个后缀字符串，而不是全部给定集合中的字符，请参见 str.removesuffix() 方法。 例如:&gt;&gt;&gt; 'Monty Python'.rstrip(' Python')'M'&gt;&gt;&gt; 'Monty Python'.removesuffix(' Python')'Monty'
|
|-
| str.split(sep=None, maxsplit=-1)
| 返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1&lt;&gt;2&lt;&gt;3'.split('&lt;&gt;') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。例如:&gt;&gt;&gt; '1,2,3'.split(',')['1', '2', '3']&gt;&gt;&gt; '1,2,3'.split(',', maxsplit=1)['1', '2,3']&gt;&gt;&gt; '1,2,,3,'.split(',')['1', '2', '', '3', '']如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。例如:&gt;&gt;&gt; '1 2 3'.split()['1', '2', '3']&gt;&gt;&gt; '1 2 3'.split(maxsplit=1)['1', '2 3']&gt;&gt;&gt; ' 1 2 3 '.split()['1', '2', '3']
|
|-
| str.splitlines([keepends])
| 返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。表示符描述\n换行\r回车\r\n回车 + 换行\v 或 \x0b行制表符\f 或 \x0c换表单\x1c文件分隔符\x1d组分隔符\x1e记录分隔符\x85下一行 (C1 控制码)\u2028行分隔符\u2029段分隔符在 3.2 版更改: \v 和 \f 被添加到行边界列表例如:&gt;&gt;&gt; 'ab c\n\nde fg\rkl\r\n'.splitlines()['ab c', '', 'de fg', 'kl']&gt;&gt;&gt; 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)['ab c\n', '\n', 'de fg\r', 'kl\r\n']不同于 split()，当给出了分隔字符串 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增加额外的行:&gt;&gt;&gt; &quot;&quot;.splitlines()[]&gt;&gt;&gt; &quot;One line\n&quot;.splitlines()['One line']作为比较，split('\n') 的结果为:&gt;&gt;&gt; ''.split('\n')['']&gt;&gt;&gt; 'Two lines\n'.split('\n')['Two lines', '']
|
|-
| str.startswith(prefix[, start[, end]])
| 如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
|
|-
| str.strip([chars])
| 返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:&gt;&gt;&gt; ' spacious '.strip()'spacious'&gt;&gt;&gt; 'www.example.com'.strip('cmowz.')'example'最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。 例如:&gt;&gt;&gt; comment_string = '#....... Section 3.2.1 Issue #32 .......'&gt;&gt;&gt; comment_string.strip('.#! ')'Section 3.2.1 Issue #32'
|
|-
| str.swapcase()
| 返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
|
|-
| str.title()
| 返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。例如:&gt;&gt;&gt; 'Hello world'.title()'Hello World'该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果:&gt;&gt;&gt; &quot;they're bill's friends from the UK&quot;.title()&quot;They'Re Bill'S Friends From The Uk&quot;可以使用正则表达式来构建针对撇号的特别处理:&gt;&gt;&gt; import re&gt;&gt;&gt; def titlecase(s):... return re.sub(r&quot;[A-Za-z]+('[A-Za-z]+)?&quot;,... lambda mo: mo.group(0).capitalize(),... s)...&gt;&gt;&gt; titlecase(&quot;they're bill's friends.&quot;)&quot;They're Bill's Friends.&quot;
|
|-
| str.translate(table)
| 返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。另请参阅 codecs 模块以了解定制字符映射的更灵活方式。
|
|-
| str.upper()
| 返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 &quot;Lu&quot; (Letter, uppercase) 而是 &quot;Lt&quot; (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。
|
|-
| str.zfill(width)
| 返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。例如:&gt;&gt;&gt; &quot;42&quot;.zfill(5)'00042'&gt;&gt;&gt; &quot;-42&quot;.zfill(5)'-0042'
|
|}


{{了解更多
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#text-sequence-type-str Python 3 标准库：内置类型 - 文本序列类型 str]
|[https://docs.python.org/zh-cn/3/tutorial/introduction.html#strings Python 3 教程：字符串]
}}

===列表===
列表（list）是可变序列，通常用于存放同类项目的集合。其中最常用的列表，可以通过方括号括起、逗号分隔的一组值得到，如<code>[1, 4, 9, 16, 25]</code>。列表也可以嵌套列表。

虽然元组可能看起来与列表很像，但它们通常是在不同的场景被使用，并且有着不同的用途。元组是 immutable （不可变的），其序列通常包含不同种类的元素，并且通过解包（这一节下面会解释）或者索引来访问（如果是 namedtuples 的话甚至还可以通过属性访问）。列表是 mutable （可变的），并且列表中的元素一般是同种类型的，并且通过迭代访问。

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/introduction.html#lists Python 3 教程：列表]
|[https://docs.python.org/zh-cn/3/tutorial/datastructures.html#more-on-lists Python 3 教程：列表的更多特性]
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#lists Python 3 标准库 ： 内置类型 - 列表]
}}
====列表构建====
{| class="wikitable"  style="width: 100%;
! 构建方式
! 描述
! 示例
|-
| 方括号，其中的项以逗号分隔
| 一般为相同类型元素。
| <code>[1,2,5]</code>，<code>['a','b','c']</code>，<code>[a,b,c]</code>
|-
| 一对方括号
| 空列表
| <code>[ ]</code>
|-
| 列表推导式
| <code>[x for x in iterable]</code>
| <code>[x for x in 'abc']</code>返回列表['a', 'b', 'c']， <code>[x for x in range(3)]</code>返回[0, 1, 2]
|-
| 类型的构造器
| <code>list()</code> 或 <code>list(iterable)</code>
| <code>list()</code>创建空列表，<code>list('abc')</code>返回列表['a', 'b', 'c']
|}

====列表操作====
列表实现了所有 一般 和 可变 序列的操作。列表还额外提供了特别的方法。



===元组===
元组（tuples ）是不可变序列，通常用于储存异构数据的多项集，也被用于需要同构数据。给元组中的一个单独的元素赋值是不允许的，当然你可以创建包含可变对象的元组，例如包含列表的元组。

虽然元组可能看起来与列表很像，但它们通常是在不同的场景被使用，并且有着不同的用途。元组是 immutable （不可变的），其序列通常包含不同种类的元素，并且通过解包（这一节下面会解释）或者索引来访问（如果是 namedtuples 的话甚至还可以通过属性访问）。列表是 mutable （可变的），并且列表中的元素一般是同种类型的，并且通过迭代访问。

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/datastructures.html#tuples-and-sequences Python 3 教程：元组和序列]
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#tuples Python 3 标准库 ： 内置类型 - 元组]
}}

====元组构建====
可以用多种方式构建元组：
{| class="wikitable"  style="width: 100%;
! 构建方式
! 描述
! 示例
|-
| 以逗号分隔的多个项
| <code>a, b, c</code> 或 <code>(a, b, c)</code>
| <code>(1, 2, 3)</code>，<code>('a',180,85)</code>
|-
| 一对圆括号
| 空元组
| <code>()</code>
|-
| 一个后缀的逗号来表示单元组
| <code>a,</code>或<code>(a,)</code>
| <code>1,</code>返回(1,)， <code>('abc',)</code>返回('abc',)
|-
| 类型的构造器
| <code>tuple()</code> 或 <code>tuple(iterable)</code>
| <code>tuple()</code>创建空元组，<code>tuple('abc')</code>返回元组('a', 'b', 'c') <code>tuple( [1, 2, 3] )</code>返回元组(1, 2, 3) 
|}

元组在输出时总是被圆括号包围的，以便正确表示嵌套元组。但决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。 例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时附带一个三元组。

====元组操作====
元组实现了所有 一般 序列的操作。


===集合===
集合是由不重复元素组成的无序的集。常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。

目前有两种内置集合类型，set 和 frozenset。 set 类型是可变的 --- 其内容可以使用 add() 和 remove() 这样的方法来改变。 由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。 frozenset 类型是不可变并且为 hashable --- 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/datastructures.html#sets Python 3 教程：集合]
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#set-types-set-frozenset Python 3 标准库 ： 内置类型 - 集合类型 --- set, frozenset]
}}

====集合构建====
可以用多种方式构建集合：
{| class="wikitable"  style="width: 100%;
! 构建方式
! 描述
! 示例
|-
| 花括号内以逗号分隔元素
| 返回set对象
| <code>{'a', 'b'}</code>
|-
| 集合推导式
| 返回set对象
| <code>{c for c in 'abracadabra' if c not in 'abc'}</code>返回{'d', 'r'}
|-
| set类型构造器
| <code>set()</code> 或 <code>set(iterable)</code>，返回set对象
| <code>set()</code>返回空集合set() <code>set('foobar')</code>返回{'a', 'b', 'f', 'o', 'r'}
|-
| frozenset类型构造器
| <code>frozenset()</code> 或 <code>frozenset(iterable)</code>，返回frozenset对象
| <code>frozenset()</code>返回空集合frozenset()，<code>frozenset('aabc')</code>返回frozenset({'a', 'b', 'c'})
|}

====集合操作====


===字典===
字典（dict）是一个非常有用的 Python 內置数据类型，是一种映射类型。可以将字典看作一个<code>键:值</code>对的集合，键必须是唯一的。

字典是以 关键字 为索引的，关键字可以是任意不可变类型，通常是字符串或数字。 数字类型用作键时遵循数字比较的一般规则：如果两个数值相等 (例如 1 和 1.0) 则两者可以被用来索引同一字典条目。 （但是请注意，由于计算机对于浮点数存储的只是近似值，因此将其用作字典键是不明智的。）

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/datastructures.html#dictionaries Python 3 教程：字典]
|[https://docs.python.org/zh-cn/3/library/stdtypes.html#mapping-types-dict Python 3 标准库 ： 内置类型 - 映射类型 --- dict]
}}

====字典构建====
字典可用多种方式来创建：
{| class="wikitable"  style="width: 100%;
! 构建方式
! 描述
! 示例
|-
| 花括号内以逗号分隔 键: 值 对
| 
| <code>{'a': 1, 'c': 22}</code>，<code>{'name': 'foo', 'ID': 22}</code>，<code>{1: 'a', '2': d}</code>
|-
| 花括号
| 空字典
| <code>{}</code>
|-
| 字典推导式
| 
| <code>{x: x ** 2 for x in range(3)}</code>返回{0: 0, 1: 1, 2: 4}
|-
| 类型构造器
|  <code>dict(**kwarg)</code><br \><code>dict(mapping, **kwarg) </code><br \><code>dict(iterable, **kwarg) </code>
| <code>dict()</code>返回空字典{} <br \><code>dict([('foo', 100), ('bar', 200)])</code> 返回{'foo': 100, 'bar': 200}<br \><code>dict(foo=100, bar=200)</code> 返回{'foo': 100, 'bar': 200}
|-
|}

====字典操作====

{| class="wikitable"  style="width: 100%;
! 方法
! 描述
! 示例
|-
| list(d)
| 返回字典 d 中使用的所有键的列表。
| <code>list(d)</code>
|-
| len(d)
| 返回字典 d 中的项数。
| <code>len(d)</code>
|-
| d[key]
| 返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError。如果字典的子类定义了方法 __missing__() 并且 key 不存在，则 d[key] 操作将调用该方法并附带键 key 作为参数。 d[key] 随后将返回或引发 __missing__(key) 调用所返回或引发的任何对象或异常。 没有其他操作或方法会发起调用 __missing__()。 如果未定义 __missing__()，则会引发 KeyError。 __missing__() 必须是一个方法；它不能是一个实例变量。还有另一个不同的 __missing__ 方法是由 collections.defaultdict 所使用的。
| <code>d['age']</code>
|-
| d[key] = value
| 将 d[key] 设为 value。
| <code>d['age'] = 200</code>
|-
| del d[key]
| 将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。
| <code>del d['age']</code>
|-
| key in d
| 如果 d 中存在键 key 则返回 True，否则返回 False。
| <code>'car' in d</code>返回False，字典d中没有'car'键。
|-
| key not in d
| 等价于 not key in d。
| <code>'car' not in d</code>返回True。
|-
| iter(d)
| 返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。
|
|-
| clear()
| 移除字典中的所有元素。
|
|-
| copy()
| 返回原字典的浅拷贝。
|
|-
| fromkeys(iterable[, value])
| 使用来自 iterable 的键创建一个新字典，并将键值设为 value。fromkeys() 是一个返回新字典的类方法。 value 默认为 None。 所有值都只引用一个单独的实例，因此让 value 成为一个可变对象例如空列表通常是没有意义的。 要获取不同的值，请改用 字典推导式。
|
|-
| get(key[, default])
| 如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。
|
|-
| items()
| 返回由字典项 ((键, 值) 对) 组成的一个新视图。 参见 视图对象文档。
|
|-
| keys()
| 返回由字典键组成的一个新视图。 参见 视图对象文档。
|
|-
| pop(key[, default])
| 如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。
|
|-
| popitem()
| 从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回。popitem() 适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。 如果字典为空，调用 popitem() 将引发 KeyError。在 3.7 版更改: 现在会确保采用 LIFO 顺序。 在之前的版本中，popitem() 会返回一个任意的键/值对。
|
|-
| reversed(d)
| 返回一个逆序获取字典键的迭代器。 这是 reversed(d.keys()) 的快捷方式。3.8 新版功能.
|
|-
| setdefault(key[, default])
| 如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。
|
|-
| update([other])
| 使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None。update() 接受另一个字典对象，或者一个包含键/值对（以长度为二的元组或其他可迭代对象表示）的可迭代对象。 如果给出了关键字参数，则会以其所指定的键/值对更新字典。
| <code>d.update(d2)</code>用d2字典更新  <br \><code>d.update(red=1, blue=2)</code>用关键字参数更新
|-
| values()
| 返回由字典值组成的一个新视图。 参见 视图对象文档。两个 dict.values() 视图之间的相等性比较将总是返回 False。 这在 dict.values() 与其自身比较时也同样适用如：<code>d = {'a': 1} ;d.values() == d.values()</code>返回False
| <code>d.values()</code>
|-
| <nowiki>d | other</nowiki>
| 合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。3.9 新版功能.
|
|-
| <nowiki>d |= other</nowiki>
| 用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。3.9 新版功能.
|
|}


==函数==

==类==
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础，将数据与功能绑定在一起。类是创建对象的模板，定义了所创建对象共同属性和方法。类的实例化即创建一个对象，如定义人类，它有出生日期、性别和姓名属性，也有吃饭和说话等方法，根据该类创建一个对象即创建一个人（如张三，男）。

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/classes.html Python 3 文档：类]
}}
===创建类===
类名一般大写字母开头，驼峰命名风格，如<code>Dog</code>，<code>MyClass</code>。
{| class="wikitable"  style="width: 100%;
! 格式
! 描述
|-
| <syntaxhighlight lang="python">
class 类名:
    语句1
    ...
    语句n
</syntaxhighlight>
|'''简单类定义'''
<br />示例：<br /><syntaxhighlight lang="python">
class Animal:
    
    def __init__(self, name):
        self.name = name

    def sound(self):
        pass

</syntaxhighlight>
|- 
| <syntaxhighlight lang="python">
class 类名(基类名):
    语句1
    ...
    语句n
</syntaxhighlight>
|'''继承'''<br />继承是基于基类派生，称为派生类。派生类具有基类的基类的属性和方法，还可以定义自己独特的属性和方法。如可以定义一个动物类，再定义一个狗类继承自动物类。<br />如果基类名不在该类的作用域中，则使用 <code>模块.基类名</code> 引用。
<br />示例：<br />
|- 
| <syntaxhighlight lang="python">
class 类名(基类名1, 基类名2, 基类名3):
    语句1
    ...
    语句n
</syntaxhighlight>
|''' 多重继承'''
<br />示例：<br />
|}

==模块和包==
===概览===

===标准库===

{{了解更多
|[https://docs.python.org/zh-cn/3/library/index.html Python 3 文档：标准库]
|[https://docs.python.org/zh-cn/3/tutorial/stdlib.html Python 3 文档：教程 - 标准库简介]
|[https://docs.python.org/zh-cn/3/tutorial/stdlib2.html Python 3 文档：教程 - 标准库简介2]
}}

===第三方包===

== 多线程与多进程 ==
=== 概览 ===

{{了解更多
|[https://docs.python.org/zh-cn/3/library/concurrency.html Python 3 文档：并发执行] 
}}
=== 多线程 ===

{{了解更多
|[https://docs.python.org/zh-cn/3/tutorial/stdlib2.html#multi-threading  Python 3 文档：多线程]
|[https://docs.python.org/zh-cn/3/library/threading.html Python 3 文档：threading --- 基于线程的并行]
}}
=== 多进程 ===
{{了解更多
|[https://docs.python.org/zh-cn/3/library/multiprocessing.html Python 3 文档：threading --- 基于线程的并行] 
}}

==资源==
===官网===
* Python 官网：https://www.python.org/
* Python 3 文档：https://docs.python.org/zh-cn/3/ 
* Python 3 教程：https://docs.python.org/zh-cn/3/tutorial/   
* Python 3 标准库：https://docs.python.org/zh-cn/3/library/index.html

===教程===

===相关网站===

===相关文章===
* [https://zh.wikipedia.org/wiki/Python 维基百科：Python]
* [https://zh.wikibooks.org/wiki/Python 维基教科书：Python]

[[分类:编程语言]]