本文简介了 Python 内置标准类型的常用运算和方法。
如需更详细的信息,请参见 Python 官方网站 。
真值测试
任何对象都可以测试真值。一般来说,以下的内置对象为被认为是非真的:
- 定义为非真的常量:
None
和False
。 - 任何数字类型的零:
0
,0.0
,0j
,Decimal(0)
,Fraction(0, 1)
- 空序列和集合:
''
,()
,[]
,{}
,set()
,range(0)
除非另有说明,否则始终返回 0
或 False
表示为非真,1
或 True
表示为真。 (例外:布尔运算 or
和 and
总是返回它们的一个操作数。)
布尔运算
下表为布尔运算,按优先级从低到高排列:
运算 | 结果 |
---|---|
x or y |
如果 x 为非真,则返回 y;否则返回 x $^{(1)}$ |
x and y |
如果 x 为非真,则返回 x;否则返回 y $^{(2)}$ |
not x |
如果 x 为非真,则返回 True ;否则返回 False $^{(3)}$ |
备注:
- 短路求值,仅当 x 为非真时,才计算 y
- 短路求值,仅当 x 为真时,才计算 y
not
具有比非布尔运算符更低的优先级,not a == b
等同于not (a == b)
,而a == not b
会抛出SyntaxError
异常。
比较运算
运算 | 含义 |
---|---|
< |
小于 |
<= |
小于或等于 |
> |
大于 |
>= |
小于或等于 |
== |
等于 |
!= |
不等于 |
is |
身份标识相同 |
is not |
身份标识不同 |
<
、<=
、>
、>=
用于比较不同类型的对象时,抛出TypeError
异常。==
和!=
用于比较不同类型的对象时,分别返回False
和True
。<
、<=
、>
、>=
、==
、!=
若要作用于实例,必须在类中定义对应的方法名(__lt/le/gt/ge/eq/ne__()
,一般来说定义__lt__()
和__eq__()
就足够)。is
和is not
不可自定义,可以用于任何两个对象,不会引发异常。
数字类型
Python 有三种不同的数字类型:整数 int
,浮点数 float
和复数 complex
。布尔是整数的子类型。
数字类型(复数部分除外)均支持以下操作,按优先级从低到高排列:
运算 | 结果 |
---|---|
x + y |
x 加上 y |
x - y |
x 减去 y |
x * y |
x 乘以 y |
x / y |
x 除以 y |
x // y |
floor 除法,x 除以 y 的商 $^{(1)}$ |
x % y |
x 除以 y 的余数 $^{(2)}$ |
-x |
x 的相反数 |
+x |
x 不变 |
abs(x) |
x 的绝对值 |
int(x) |
x 转换为整数 $^{(3)}$ |
float(x) |
x 转换为浮点数 $^{(4)}$ |
complex(re, im) |
实部为 re,虚部为 im 的复数(im 默认为 0) $^{(6)}$ |
c.conjugate() |
c 的共轭复数 |
divmod(x, y) |
商与余数的元祖 (x // y, x % y) $^{(2)}$ |
pow(x, y) |
x 的 y 次幂 $^{(5)}$ |
x ** y |
x 的 y 次幂 (5) |
备注:
- 也被称为整数除法。 返回为整数的值,但其类型不一定是整数类型。结果总是向负无穷方向取整:
1//2
为0
,(-1)//2
为-1
,1//(-2)
为-1
,(-1)//(-2)
为0
。 - 不适用于复数。
- 从浮点到整数的转换,可能会舍入或截断;更好的转换方式请参阅函数
math.floor()
和math.ceil()
。 float
还接受带有可选前缀 “+” 或 “-” 的字符串 “nan” 和 “inf”,来表示非数字、正无穷或负无穷。pow(0, 0)
和0 ** 0
的值为1
。
整数和浮点数还支持以下运算:
运算 | 结果 |
---|---|
math.trunc(x) |
返回 x 截断后的整数 |
round(x[, n]) |
返回 x 取到小数点后第 n 位的精度(n 默认为 0,表示取整) |
math.floor(x) |
返回 x 向下(负无穷方向)最近的整数 |
math.ceil(x) |
返回 x 向上(正无穷方向)最近的整数 |
整数类型的按位运算
按位运算只对整数有意义,负数被视为二进制补码值。下表按优先级从低到高排列:
运算 | 结果 |
---|---|
x | y |
按位或 |
x ^ y |
按位异或 |
x & y |
按位与 |
x << n |
x 左移 n 位 |
x >> n |
x 右移 n 位 |
~x |
x 按位反转 |
序列类型
Python 有三种基本的序列类型:列表 list
、元组 tuple
、range
,另外还有二进制数据序列类型bytes
、bytearray
、memoryview
和文本字符串序列类型 str
。
共性的序列运算
大多数序列类型(包括可变类型和不可变类型)都支持下表中的操作,按优先级从低到高排列:
运算 | 结果 |
---|---|
x in s |
如果 s 中存在 x,则返回 True ;否则返回 False $^{(1)}$ |
x not in s |
如果 s 中存在 x,则返回 False ;否则返回 True $^{(1)}$ |
s + t |
连接 s 和 t $^{(6)(7)}$ |
s * n or n * s |
将 s 重复 n 次,等同于 s 和自己相加 n 次 $^{(2)(7)}$ |
s[i] |
s 的第 i 个元素,i 从 0 开始 $^{(3)}$ |
s[i:j] |
s 从 i 到 j 的切片 $^{(3)(4)}$ |
s[i:j:k] |
s 从 i 到 j 的切片,步长为 k $^{(3)(5)}$ |
len(s) |
s 的长度 |
min(s) |
s 中最小的元素 |
max(s) |
s 中最大的元素 |
s.index(x[, i[, j]]) |
x 在 s 中第一次出现的位置(位置 i 开始及之后,位置 j 之前) $^{(8)}$ |
s.count(x) |
x 在 s 中第一次出现的总次数 |
备注:
- 一些特殊的序列(
str
,bytes
和bytearray
)可以作为子序列测试,如"gg" in "eggs"
。 - 小于 0 的 n 被视为 0(产生与 s 相同类型的空序列)。请注意其中元素是重复引用而非复制。例如
s = [[]] * 3
, 那么s[0].append(1)
也会在s[1]
和s[2]
后加上1
;要避免这种情况,请使用s = [[] for i in range(3)]
。 - 如果 i 或 j 是负数,则代表倒数第
|i|
位或倒数第|j|
位,可用len(s) + i
或len(s) + j
替换。请注意, 位置-0
仍然是0
。 - 下标范围为
i <= k < j
,如未指定则i
为0
,j
为len(s)
。如果i
不小于j
,则切片为空序列。 - 参与迭代运算的元素索引为
x = i + n*k
,其中0 <= n < (j-i)/k
。步长 k 可以为负数。 - 对不可变序列的连接,会产生新的对象,需要二次时间运行成本。要获得线性运行时成本,建议对
str
和bytes
对象使用join()
方法,或者将tuple
转换为list
。 range
仅遵循特定模式,不支持连接和重复。- 如果未找到元素,则抛出
ValueError
异常。参数传递大概相当于返回s[i:j].index(x) + i
,只是并没有真正的切片行为。
不可变的序列类型
不可变的序列类型包括 tuple
str
等。尝试对其中的元素进行更改,会引发 TypeError
异常。
可变的序列类型
运算 | 结果 |
---|---|
s[i] = x |
s 的第 i 个元素赋值为 x |
s[i:j] = t |
s 的第 i 到 j 个元素替换为 t |
del s[i:j] |
同 s[i:j] = [] |
s[i:j:k] = t |
s 的第 i 到 j 个元素,按步长 k 替换为 t $^{(1)}$ |
del s[i:j:k] |
s 的第 i 到 j 个元素,按步长 k 进行删除 |
s.append(x) |
在 s 末尾加上 x(同 s[len(s):len(s)] = [x]) |
s.clear() |
删除 s 的所有元素(同 del s[:]) $^{(5)}$ |
s.copy() |
s 的浅拷贝(same as s[:]) $^{(5)}$ |
s.extend(t) 或 s += t |
在 s 末尾加上 t 的元素 (大多数情况下同 s[len(s):len(s)] = t) |
s *= n |
s 重复 n 次并更新 $^{(6)}$ |
s.insert(i, x) |
在 s 的第 i 位加上 x(同 s[i:i] = [x]) |
s.pop([i]) |
返回第 i 位的元素,并从 s 中删除 $^{(2)}$ |
s.remove(x) |
在 s 中删除第一次出现的 x $^{(3)}$ |
s.reverse() |
将 s 反转 $^{(4)}$ |
备注:
t
必须和需要替换的切片具有相同长度。- 若 i 未指定,则使用默认值
-1
,即删除最后一个元素并返回此元素的值。 - 若未找到,抛出
ValueError
异常。 - 对较长的序列进行原地反转,不会产生新的序列,可以节约空间。
- Python 3.3 引入,和不支持切片运算的数据类型(如
dict
和set
)共用接口。 - 同
s = s* n
,小于 0 的 n 被视为 0(产生与 s 相同类型的空序列),其中元素是重复引用而非复制。
列表
列表是可变序列,通常用于存储同类数据的集合。
class list([iterable])
列表可以通过以下几种方式构建:
- 用一对方括号表示空列表:
[]
- 使用方括号,用逗号分隔项目:
[a]
,[a,b,c]
- 使用列表推导式:
[x for iterable]
- 使用构造函数:
list()
或者list(iterable)
方法 | 结果 |
---|---|
s.sort(**, key=None, reverse=False) |
对 s 进行排序,key为排序规则的函数(如key = str.lower) |
元组
元组是不可变的序列,通常用于存储异构数据的集合。
class tuple([iterable])
- 用一对括号来表示空元组:
()
- 对于单例元组,需要在元素后尾随逗号:
a,
或(a,)
- 用逗号分隔项目:
a, b, c
或(a, b, c)
- 使用构造函数::
tuple()
或tuple(iterable)
range
range
是不可变的数字序列,通常用于 for
循环。
class range(stop)
class range(start, stop[, step])
- start:起始参数的值(默认为 0)
- stop:停止参数的值
- step:步长参数的值(默认为 1),可为负数
字符串
Python 中的文本数据由 str
字符串对象处理。字符串是使用 Unicode 编码的不可变序列,表示方法如下:
- 单引号:
'allows embedded "double" quotes'
- 双引号:
"allows embedded 'single' quotes"
- 三引号:
'''Three single quotes'''
,"""Three double quotes"""
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
方法 | 结果 |
---|---|
s.capitalize() |
返回将 s 首字符大写、其余字符小写的形式 |
s.lower/upper/swapcase() |
返回将 s 全小写/全大写/大小写反转的形式 |
s.center/ljust/rjust(width[, fillchar]) |
返回以 s 居中/靠左/靠右 的字符串,其余以 fillchar 填充 $^{(1)}$ |
s.count(sub[, start[, end]]) |
返回子串 sub 在 s[start:end] 中出现的次数 |
s.endswith/startswith[(sub[, start[, end]])] |
判断 s 是否以 sub 结尾/起始 |
s.find(sub[, start[, end]]) |
返回子串 sub 在 s 中第一次出现的起始索引;若未包含则返回 -1 |
s.format(*args, **kwargs) |
字符串格式化 |
s.index(sub[, start[, end]]) |
类似于 find() ;区别是若未包含则抛出 ValueError 异常 |
s.isalnum() |
s.isalpha/isdecimal/isdigit/isnumeric() 其中一个为真则返回 True ,否则返回 False |
s.isdecimal/isdigit/isnumeric() |
判断是否是数字 (2) |
s.isalpha/islower/isupper() |
判断是否以 英文字母/大写字母/小写字母 结尾 |
s.isspace() |
判断是否是空白字符 |
s.join(iterable) |
使用 s 串联字符串 |
s.replace(old, new[, count]) |
将字符串的 old 子串替换成 new 子串 |
s.split/rsplit(sep=None, maxsplit=-1) |
对 s 使用 sep 在起始/末尾位置分割,返回列表 |
s.splitlines([keepends]) |
对 s 在任何换行符出现位置进行分割,返回列表 |
s.strip/lstrip/rstrip([chars]) |
删除两端/起始/末尾的 chars 集合内的任意字符,返回删除后的字符串 |
s.translate(table) |
对 s 进行翻译转换,只能处理单个字符 |
s.zfill(width) |
在 s 起始位置的 “+” “-” 之后、其他字符前置 0 $^{(1)}$ |
备注:
- 如果 width 小于 s 的长度,返回 s 本身
- 略微有点区别,如字符
²
(’\u00B2’)仅为 digit 和 numeric;字符½
(’\u00BD’)为仅为 numeric
集合类型
class set([iterable])
class frozenset([iterable])
set
和 frozenset
都是无序集合。set
是可变的, frozenset
是不可变的。
均支持 x in set
,len(set)
,for x in set
通用的集合操作,不支持索引,切片或其他类似序列的行为。
运算 | 结果 |
---|---|
x in s |
如果 s 中存在 x,则返回 True ;否则返回 False |
x not in s |
如果 s 中存在 x,则返回 False ;否则返回 True |
s.isdisjoint(other) |
如果交集为空,则返回 True ;否则返回 False |
s <= other /s.issubset(other) |
判断 s 是否是 other 的子集 $^{(1)}$ |
s >= other /s.issuperset(other) |
判断 other 是否是 s 的子集 $^{(1)}$ |
s | other | ... /s.union/update(*others) |
返回并集(并赋值给 s) $^{(1)}$ |
s & other & ... /s.intersection/intersection_update(*others) |
返回交集(并赋值给 s) $^{(1)}$ |
set - other - ... /s.difference/difference_update(*others) |
返回在 s 中、同时不在 other 中的元素的集合(并赋值给 s) $^{(1)}$ |
set ^ other /s.symmetric_difference/symmetric_difference_update(other) |
返回仅在 s 中或仅在 other 中的元素的集合(并赋值给 s) $^{(1)}$ |
s.copy() |
返回 s 的浅拷贝 |
s.add(elem) |
添加元素 $^{(1)}$ |
s.remove(elem) |
删除元素,若不包含则抛出 KeyError $^{(1)}$ |
s.discard(elem) |
删除元素,不抛出异常 $^{(1)}$ |
s.pop(elem) |
随机删除一个元素并返回该元素的值,若 s 为空则抛出 KeyError $^{(1)}$ |
s.clear(elem) |
清空 s $^{(1)}$ |
备注:
frozenset
是不可变的,不可使用
映射类型
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
mapping
将可散列值映射到任意对象,映射对象是可变的。目前 Python 只有一种标准的映射类型,即字典 dict
。
标准字典的形式如:{"one": 1, "two": 2, "three": 3}
,冒号前为键 key
,映射到对应的值 value
。
运算 | 结果 |
---|---|
len(d) |
d 的长度(即 key 的个数) |
d[key] |
返回键 key 对应的值 |
d[key] = value |
将 value 赋值给键 key |
del d[key] |
将 value 赋值给键 key |
key in d |
在 d 的键中包含 key,则返回 True ,否则返回 False |
key not in d |
在 d 的键中包含 key,则返回 False ,否则返回 True |
iter(d) |
返回 d 的键的迭代器 |
d.clear() |
清空 d |
d.copy() |
返回 d 的浅拷贝 |
d.fromkeys(seq[, value]) |
以 seq 为键值,创建新的词典 |
d.get(key[, default]) |
查找键并返回键值;若不在则返回 default,default 未指定则返回 None |
d.items/keys/values() |
以 (key, value) /value /key 的形式返回 view 对象 |
d.pop(key[, default]) |
查找、删除键并返回键值;若不在则返回 default,未指定则抛出 KeyError |
d.popitem() |
随机删除一组键值并返回,若 d 为空则抛出 KeyError |
d.setdefault(key[, default]) |
如果 key 在 d 中,返回其值;否则则设置其值为 default 并返回,默认为 None |
d.update([other]) |
使用其他键值对 d 进行更新,d 中已有的 key 会被覆盖;返回 None |