python基础---内置类型

内置类型

基于python3.9.6

官方文档：https://docs.python.org/zh-cn/3/library/stdtypes.html

笔记中只是个人认为的重点，官方文档中还有更多细节。

*逻辑值检测

任何对象都可以进行逻辑值的检测。

一个对象在默认情况下均被视为真值，除非当该对象被调用时其所属类定义了__bool__() 方法且返回 False 或是定义了__len__() 方法且返回零。

下面基本完整地列出了会被视为假值的内置对象:

• 被定义为假值的常量: None 和 False。
• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• 空的序列和多项集: '', (), [], {}, set(), range(0)

布尔运算

优先级由低到高，not的优先级比非布尔运算符低，因此 not a == b 会被解读为 not (a == b) 而 a == not b 会引发语法错误。

• x or y
• x and y
• not x

比较

比较运算可以任意串连。

例如，x < y <= z 等价于 x < y and y <= z，前者的不同之处在于 y 只被求值一次（但在两种情况下当 x < y 结果为假值时 z 都不会被求值）。

• 具有不同标识的类的实例比较结果通常为不相等，除非类定义了eq() 方法。
• is 和 is not 运算符无法自定义；并且它们可以被应用于任意两个对象而不会引发异常。
• in 和 not in，它们被 iterable 或实现了 contains() 方法的类型所支持。

数字类型（int，float，complex）

存在三种不同的数字类型: 整数, 浮点数 和 复数。

标准库包含附加的数字类型，如表示有理数的 fractions.Fraction 以及以用户定制精度表示浮点数的 decimal.Decimal。

混合运算：较窄"类型的操作数会拓宽到另一个操作数的类型，其中整数比浮点数窄，浮点数比复数窄。

divmod(x,y)：返回(x // y, x % y)，即商和余数。

整数的按位运算

• x | y：x 和 y 按位 或
• x ^ y：x 和 y 按位 异或
• x & y：x 和 y 按位 与
• x << n：x 左移 n 位
• x >> n：x 右移 n 位
• ~x：x 逐位取反

注意点：

1. 负的位移数会导致报错
2. 右移 n 位等价于除以 pow(2, n) ，作向下取整除法。

数字类型的哈希运算

为了保证不同类型的同一数字的哈希值是一样的，哈希运算统一使用有理数进行计算。

本质上：此函数通过一个固定质数\(P\)进行\(P\)降模得出哈希值，\(P\)值可以通过sys.hash_info来访问。具体计算细节可以参考官方文档。

迭代器类型

容器对象要提供迭代支持，必须定义container.__iter__()方法，方法返回一个符合迭代协议的迭代器对象。

迭代器协议

迭代器对象需要有下面两个方法：

• iterator.iter()：带回迭代器对象本身，允许迭代器配合for和in使用
• iterator.next()：从容器中返回下一项，如果没有可返回项会报错。

一旦迭代器的 __next__() 方法引发了 StopIteration，它必须一直对后续调用引发同样的异常。 不遵循此行为特性的实现将无法正常使用。

生成器类型

generator提供一种实现迭代器协议的便捷方式。具体可以参考yield表达式。

序列类型（list，tuple，range）

通用序列操作

• x in s
• x not in s
• s + t：s 与 t 相拼接。拼接不可变对象会产生新对象，类似Java中的String。
• s * n 或 n * s：相当于 s 与自身进行 n 次拼接（浅拷贝）
• s[i]
• s[i:j]
• s[i:j:k]：s 从 i 到 j 步长为 k 的切片
• len(s)
• min(s)
• max(s)
• s.index(x[, i[, j]])：x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前），当找不到x时，会报错。
• s.count(x)：x 在 s 中出现的总次数

collections.abc.Sequence ABC被提供用来更容易地在自定义序列类型上正确地实现这些操作。

不可变序列类型

不可变序列一般会实现，可变序列不实现的唯一操作就是hash()内置函数。这允许不可变序列作为dict的key。

如果将不可hash的类型进行哈希运算，将会报错TypeError。

可变序列类型

以下是可变序列特有的操作：

• s[i] = x
• s[i:j] = t
• del s[i:j]：等同于 s[i:j] = []
• s[i:j:k] = t：将 s[i:j:k] 的元素替换为 t 的元素
• del s[i:j:k]
• s.append(x)：将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
• s.clear()：从 s 中移除所有项 (等同于 del s[:])
• s.copy()：创建 s 的浅拷贝 (等同于 s[:])
• s.extend(t) 或 s += t：用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
• s *= n：使用 s 的内容重复 n 次来对其进行更新
• s.insert(i, x)：在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
• s.pop() or s.pop(i)：提取在 i 位置上的项，并将其从 s 中移除
• s.remove(x)：删除 s 中第一个 s[i] 等于 x 的项目。
• s.reverse()：就地将列表中的元素逆序。

列表

list有多种构造器：

• 使用一对方括号来表示空列表: []
• 使用方括号，其中的项以逗号分隔: [a], [a, b, c]
• 使用列表推导式: [x for x in iterable]
• 使用类型的构造器: list() 或 list(iterable)，其中的项与 iterable 中的项具有相同的的值与顺序。如果 iterable 已经是一个列表，将创建并返回其副本（空间占用）。

列表排序方法sort(*, key=None, reverse=False)

对列表进行原地排序，如果过程中出现异常，列表会处于部分排序状态。

sort方法是稳定的，即key值相等的多个对象，它们的相对位置在多次排序中不会被改变。

元组

元祖类似于列表，只是不可变。

range对象

range类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。

range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值）。

构造器：

class range(stop)

class range(start, stop[, step])

构造器的参数必须是整数，可以是int或实现了__index__的对象。

注意点：

• 如果step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。
• 如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop。
• range对象可以用==进行比较，如果表示相同值，则认为两者相等。如range(0) == range(2, 1)都表示空

文本序列类型（str）

字符串是由Unicode码位构成的不可变序列。

• 之间只由空格分隔的多个字符串字面值会被隐式地转换为单个字符串字面值，如print("spam " "eggs" == "spam eggs")
• 使用 r ("raw") 前缀来禁用大多数转义序列的处理，如r'^(.*denselayer\d+)$'
• str.join() 或 io.StringIO 可以被被用来根据多个片段高效率地构建字符串（避免生成过多中间变量，类似Java的StringBuilder）。

字符串的方法

字符串实现了所有一般序列的操作，还额外提供了以下列出的一些附加方法。

• capitalize()：返回原字符串的副本，其首个字符大写，其余为小写。
• casefold()：返回原字符串消除大小写的副本。和lower()不同的是，casefold会移除字符串中的所有大小写变化形式。例如，将德语小写字母 'ß' 转换为 "ss"。
• center(width[, fillchar])：将字符串填充到指定长度，如果 width 小于等于 len(s) 则返回原字符串的副本。
• count(sub[, start[, end]])：返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。
• expandtabs(tabsize=8)：返回字符串的副本，其中所有的制表符会由一个或多个空格替换。
• istitle()：大写字符之后只能带非大写字符而小写字符必须有大写字符打头，两个单词间还必须有空白分割（不同于驼峰），title()可以进行这种类似的转换。
• ljust(width[, fillchar])：填充到指定长度，原字符串在其中靠左对齐。
• lstrip([chars])：移除由chars字母组合的任何前缀，对比removeprefix
• partition(sep)：在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
• rfind(sub[, start[, end]])：返回子字符串 sub 在字符串内被找到的最大（最右）索引
• swapcase()：返回原字符串的副本，其中大写字符转换为小写，反之亦然。
• translate(table)：返回原字符串的副本，其中每个字符按给定的转换表进行映射（类似多次replace）。

isdigit、isdecimal、isnumeric的区别

isdigit()

• True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字（"Ⅷ"）
• False: 汉字数字（“零”）

isdecimal()

• True: Unicode数字，，全角数字（双字节）
• False: 罗马数字，汉字数字

isnumeric()

• True: Unicode数字，全角数字（双字节），罗马数字，汉字数字

二进制序列类型（暂跳过）

集合类型（set，frozenset）

set 对象是由具有唯一性的hashable对象所组成的无序多项集，集合并不记录元素位置或插入顺序。 相应地，集合不支持索引、切片或其他序列类的操作。

set是可变的，frozenset是不可变的。set可以通过花括号来创建，如：{'jack', 'sjoerd'}

集合方法

• isdisjoint(other)：和other没有交集返回True
• issubset(other)：相当于set <= other，包含other的所有元素
• set < other：检测集合是否为 other 的真子集，即 set <= other and set != other。
• union(*others)：并集
• intersection(*others)：交集，相当于set & other & ...
• difference(*others)：差集，相当于set - other - ...
• symmetric_difference(other)：并集-交集，相当于set ^ other

推荐使用可读性更强的方法调用，而不是运算符版本。

set方法

• update(*others)：更新集合，添加来自 others 中的所有元素。相当于set |= other | ...
• intersection_update(*others)：更新集合，只保留其中在所有 others 中也存在的元素。相当于set &= other & ...
• difference_update(*others)：更新集合，移除其中也存在于 others 中的元素。相当于set -= other | ...
• symmetric_difference_update(other)：更新集合，只保留存在于集合的一方而非共同存在的元素。相当于set ^= other
• remove(elem)：从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发 KeyError。
• discard(elem)：如果元素 elem 存在于集合中则将其移除。
• pop()：从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError。

映射类型（dict）

字典的key几乎可以是任何值。 非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键。

用等号比较字典会比较其中的键值对

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

字典的方法

• list(d)：返回字典 d 中使用的所有键的列表
• d[key]：key不存在会报错
• get(key[, default])：如果 key 存在于字典中则返回 key 的值，否则返回 default，默认为None。
• classmethod fromkeys(iterable[, value])：使用来自 iterable 的键创建一个新字典，并将键值设为value。
• items()：返回由字典项 ((键, 值) 对) 组成的一个新视图。
• pop(key[, default])：如果 key 存在于字典中则将其移除并返回其值
• popitem()：从字典中移除并返回一个 (键, 值) 对，会按照LIFO（后进先出）顺序返回（3.7之后）。
• reversed(d):逆序迭代器
• setdefault(key[, default])：如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default。
• update([other])：将其他字典更新进当前字典
• d | other：合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。
• d |= other：用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。

字典视图对象

由 dict.keys(), dict.values() 和 dict.items()所返回的对象是 视图对象。

在添加或删除字典中的条目期间对视图进行迭代可能引发 RuntimeError 或者无法完全迭代所有条目。

上下文管理器类型

Python 的with语句支持通过上下文管理器所定义的运行时上下文这一概念。

在语句体被执行前进入该上下文，并在语句执行完毕时退出该上下文。

Python 的 generator 和 contextlib.contextmanager 装饰器提供了实现上下文管理器协议的便捷方式。

contextmanager.**enter**()

进入运行时上下文并返回此对象或关联到该运行时上下文的其他对象。下面是两个例子：

• 当前对象上下文管理器：file.open()
• 关联对象上下文管理器：decimal.localcontext()

返回上下文对象，会赋值到as子句的标识符。

contextmanager.**exit**(exc_type, exc_val, exc_tb)

如果在执行 with 语句的语句体期间发生了异常，则参数会包含异常的类型、值以及回溯信息。

自此方法返回True时，将忽略异常继续执行with之后的代码。否则将抛出异常。

注意点：

• 不能在此方法中再次抛出异常，应该返回True和False来决定发生异常时的行为

其他内置类型

模块

每个模块都有一个特殊属性 dict。 这是包含模块的符号表的字典，修改此字典将实际改变模块的符号表（不能修改其引用）。

函数

函数对象是通过函数定义创建的。 对函数对象的唯一操作是调用它: func(argument-list)。

类型分为内置函数和用户自定义函数

方法

方法是使用属性表示法来调用的函数。 存在两种形式：内置方法和类实例方法。

如果通过实例访问方法，会得到一个绑定方法对象，这个对象有两个特殊的只读属性：m.__self__操作该方法的对象，m.__func__实现该方法的函数。

c.method.__func__.properties，可以这样给方法添加新的属性properties。

感觉可以理解为封装了__self__和函数的一个对象。

代码对象

代码对象由内置的 compile() 函数返回，并可通过从函数对象的 __code__属性从中提取。

可以通过将代码对象（而非源码字符串）传给 exec() 或 eval() 内置函数来执行或求值。

类型对象

对象的类型可通过内置函数 type() 来获取。 类型没有特殊的操作。类似Java的Class对象。

空对象

空对象只有一种值 None (这是个内置名称)。 type(None)() 会生成同一个单例。

省略号对象

此对象常被用于切片 (参见 切片)。 它不支持任何特殊的操作。

省略符对象只有一种值 Ellipsis (这是个内置名称)。 type(Ellipsis)() 会生成 Ellipsis 单例。

该对象的写法为 Ellipsis 或 ...。

未实现对象

未实现对象只有一种值 NotImplemented。 type(NotImplemented)() 会生成这个单例。

该对象的写法为 NotImplemented。

布尔值

布尔值是两个常量对象 False 和 True。

内部对象

栈帧对象、回溯对象以及切片对象等等。