Python 内置类型

本文简介了 Python 内置标准类型的常用运算和方法。
如需更详细的信息,请参见 Python 官方网站

真值测试

任何对象都可以测试真值。一般来说,以下的内置对象为被认为是非真的:

  • 定义为非真的常量:NoneFalse
  • 任何数字类型的零:00.00jDecimal(0), Fraction(0, 1)
  • 空序列和集合:''()[]{}set()range(0)

除非另有说明,否则始终返回 0False 表示为非真,1True 表示为真。 (例外:布尔运算 orand 总是返回它们的一个操作数。)

布尔运算

下表为布尔运算,按优先级从低到高排列:

运算 结果
x or y 如果 x 为非真,则返回 y;否则返回 x $^{(1)}$
x and y 如果 x 为非真,则返回 x;否则返回 y $^{(2)}$
not x 如果 x 为非真,则返回 True;否则返回 False $^{(3)}$

备注:

  1. 短路求值,仅当 x 为非真时,才计算 y
  2. 短路求值,仅当 x 为真时,才计算 y
  3. not 具有比非布尔运算符更低的优先级,not a == b 等同于 not (a == b),而 a == not b 会抛出 SyntaxError 异常。

比较运算

运算 含义
< 小于
<= 小于或等于
> 大于
>= 小于或等于
== 等于
!= 不等于
is 身份标识相同
is not 身份标识不同
  • <<=>>= 用于比较不同类型的对象时,抛出 TypeError 异常。
  • ==!= 用于比较不同类型的对象时,分别返回 FalseTrue
  • <<=>>===!= 若要作用于实例,必须在类中定义对应的方法名(__lt/le/gt/ge/eq/ne__(),一般来说定义__lt__()__eq__() 就足够)。
  • isis 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. 也被称为整数除法。 返回为整数的值,但其类型不一定是整数类型。结果总是向负无穷方向取整:1//20, (-1)//2-1, 1//(-2)-1, (-1)//(-2)0
  2. 不适用于复数。
  3. 从浮点到整数的转换,可能会舍入或截断;更好的转换方式请参阅函数 math.floor()math.ceil()
  4. float 还接受带有可选前缀 “+” 或 “-” 的字符串 “nan” 和 “inf”,来表示非数字、正无穷或负无穷。
  5. 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、元组 tuplerange,另外还有二进制数据序列类型bytesbytearraymemoryview和文本字符串序列类型 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 中第一次出现的总次数

备注:

  1. 一些特殊的序列(strbytesbytearray)可以作为子序列测试,如 "gg" in "eggs"
  2. 小于 0 的 n 被视为 0(产生与 s 相同类型的空序列)。请注意其中元素是重复引用而非复制。例如 s = [[]] * 3, 那么 s[0].append(1) 也会在 s[1]s[2] 后加上 1;要避免这种情况,请使用 s = [[] for i in range(3)]
  3. 如果 i 或 j 是负数,则代表倒数第 |i| 位或倒数第 |j| 位,可用 len(s) + ilen(s) + j 替换。请注意, 位置 -0 仍然是 0
  4. 下标范围为 i <= k < j,如未指定则 i0jlen(s)。如果 i 不小于 j,则切片为空序列。
  5. 参与迭代运算的元素索引为 x = i + n*k,其中 0 <= n < (j-i)/k。步长 k 可以为负数。
  6. 对不可变序列的连接,会产生新的对象,需要二次时间运行成本。要获得线性运行时成本,建议对 strbytes 对象使用 join()方法,或者将 tuple 转换为 list
  7. range 仅遵循特定模式,不支持连接和重复。
  8. 如果未找到元素,则抛出 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)}$

备注:

  1. t 必须和需要替换的切片具有相同长度。
  2. 若 i 未指定,则使用默认值 -1,即删除最后一个元素并返回此元素的值。
  3. 若未找到,抛出 ValueError 异常。
  4. 对较长的序列进行原地反转,不会产生新的序列,可以节约空间。
  5. Python 3.3 引入,和不支持切片运算的数据类型(如 dictset)共用接口。
  6. 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)}$

备注:

  1. 如果 width 小于 s 的长度,返回 s 本身
  2. 略微有点区别,如字符 ²(’\u00B2’)仅为 digit 和 numeric;字符 ½(’\u00BD’)为仅为 numeric

集合类型

class set([iterable])
class frozenset([iterable])

setfrozenset 都是无序集合。set 是可变的, frozenset 是不可变的。
均支持 x in setlen(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)}$

备注:

  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