关于python:Python基础之Python中的内部对象

57次阅读

共计 13469 个字符,预计需要花费 34 分钟才能阅读完成。

简介

Python 中内置了很多十分有用的对象,本文将会介绍 Python 中的内置函数,内置常量,内置类型和内置异样。

内置函数

Python 解释器内置了很多函数和类型,您能够在任何时候应用它们。

内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()

内置常量

Python 中内置了大量的常量,咱们能够间接在代码中应用他们。

  • False

示意的是 bool 类型的假值。

  • True

示意的是 bool 类型的真值。

  • None

是 NoneType 类型的惟一值。None 示意短少值。

  • NotImplemented

__eq__(), __lt__(), __add__(), __rsub__() 的非凡返回值,示意会在假值的时候返回NotImplemented

  • Ellipsis

等同于字面值 ,次要与用户定义的容器数据类型的扩大切片语法联合应用。

  • __debug__

编译器外部的变量,用来示意是否开启 debug 模式。

内置类型

python 中的次要内置类型有数字、序列、映射、类、实例和异样。

逻辑值检测

在 python 中,任何对象都能够做逻辑值的检测。

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

上面是集中被认为是 false 值的对象:

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

逻辑值的布尔运算

布尔运算次要有 or, not 和 and:

运算 后果
x or y if x is false, then y, else x
x and y if x is false, then x, else y
not x if x is false, then True, else False

比拟运算

运算 含意
< 严格小于
<= 小于或等于
> 严格大于
>= 大于或等于
== 等于
!= 不等于
is 对象标识
is not 否定的对象标识

具备不同标识的类的实例比拟后果通常为不相等,除非类定义了 __eq__()办法。

数字类型

Python 中有三种不同的数据类型:整数 , 浮点数 复数

所有数字类型(复数除外)都反对下列运算:

运算 后果
x + y xy 的和
x - y xy 的差
x * y xy 的乘积
x / y xy 的商
x // y xy 的商数
x % y x / y 的余数
-x x 取反
+x x 不变
abs(x) x 的绝对值或大小

对于 int 和 float 还反对上面的运算:

运算 后果
math.trunc(x) x 截断为 Integral
Round(x[, n]) x 舍入到 n 位小数,半数值会舍入到偶数。如果省略 n,则默认为 0。
math.floor(x) <= x 的最大 Integral
math.ceil(x) >= x 的最小 Integral

整数类型的位运算

对于整数来说,还反对位运算:

运算 后果
`x y` xy 按位
x ^ y xy 按位 异或
x & y xy 按位
x << n x 左移 n
x >> n x 右移 n
~x x 逐位取反

整数类型的附加办法

int 还有一些额定的办法:

int.bit_length()

返回以二进制示意一个整数所须要的位数,不包含符号位和后面的零:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

int.to_bytes(length, byteorder, , signed=False*)

返回示意一个整数的字节数组。

(1024).to_bytes(2, byteorder='big')
b'\x04\x00'
(1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
(-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
x = 1000
x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

byteorder 参数确定用于示意整数的字节程序。如果 byteorder"big",则最高位字节放在字节数组的结尾。如果 byteorder"little",则最高位字节放在字节数组的开端。

signed 参数确定是否应用二的补码来示意整数。

浮点类型的附加办法

float.is_integer()

如果 float 实例可用无限位整数示意则返回 True,否则返回 False:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

float.hex()

以十六进制字符串的模式返回一个浮点数示意。

迭代器

迭代器次要用在容器的遍历中。

如果容器须要提供迭代反对,必须定义上面的办法:

container.__iter__()

这个办法返回一个迭代器对象。这个迭代器对象须要提供上面的两个办法:

iterator.__iter__()

返回迭代器对象自身。

iterator.__next__()

从容器中返回下一项。

序列类型

有三种根本序列类型:list, tuple 和 range 对象。

上面是通用的序列操作:

运算 后果
x in s 如果 s 中的某项等于 x 则后果为 True,否则为 False
x not in s 如果 s 中的某项等于 x 则后果为 False,否则为 True
s + t st 相拼接
s * nn * s 相当于 s 与本身进行 n 次拼接
s[i] s 的第 i 项,起始为 0
s[i:j] sij 的切片
s[i:j:k] sij 步长为 k 的切片
len(s) s 的长度
min(s) s 的最小项
max(s) s 的最大项
s.index(x[, i[, j]]) xs 中首次呈现项的索引号(索引号在 i 或其后且在 j 之前)
s.count(x) xs 中呈现的总次数

可变序列类型的操作:

运算 后果
s[i] = x s 的第 i 项替换为 x
s[i:j] = t sij 的切片替换为可迭代对象 t 的内容
del s[i:j] 等同于 s[i:j] = []
s[i:j:k] = t s[i:j:k] 的元素替换为 t 的元素
del s[i:j:k] 从列表中移除 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([i]) 提取在 i 地位上的项,并将其从 s 中移除
s.remove(x) 删除 s 中第一个 s[i] 等于 x 的我的项目。
s.reverse() 就地将列表中的元素逆序。

序列类型包含列表,元组,range 对象和文本序列 str。

这里重点看下 str 的办法:

运算 后果
str.capitalize() 返回原字符串的正本,其首个字符大写,其余为小写。
str.casefold() 返回原字符串打消大小写的正本。打消大小写的字符串可用于疏忽大小写的匹配。
str.center(width[, fillchar]) 返回长度为 width 的字符串,原字符串在其正中。应用指定的 fillchar 填充两边的空位(默认应用 ASCII 空格符)。如果 width 小于等于 len(s) 则返回原字符串的正本。
str.count(sub[, start[, end]]) 反回子字符串 sub 在 [start, end] 范畴内非重叠呈现的次数。可选参数 startend 会被解读为切片表示法。
str.encode(encoding=”utf-8″, errors=”strict”) 返回原字符串编码为字节串对象的版本。默认编码为 ‘utf-8’。errors 的默认值为 ‘strict’,示意编码谬误会引发 UnicodeError。其余可用的值为 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及任何其余通过 codecs.register_error() 注册的值
str.endswith(suffix[, start[, end]]) 如果字符串以指定的 suffix 完结返回 True,否则返回 Falsesuffix 也能够为由多个供查找的后缀形成的元组。
str.expandtabs(tabsize=8) 返回字符串的正本,其中所有的制表符会由一个或多个空格替换,具体取决于当前列地位和给定的制表符宽度。
str.find(sub[, start[, end]]) 返回子字符串 subs[start:end] 切片内被找到的最小索引。
str.format(args, kwargs*) 执行字符串格式化操作。
str.format_map(mapping) 相似于 str.format(**mapping),不同之处在于 mapping 会被间接应用而不是复制到一个 dict。
str.index(sub[, start[, end]]) 相似于 find(),但在找不到子类时会引发 ValueError。
str.isalnum() 如果字符串中的所有字符都是字母或数字且至多有一个字符,则返回 True,否则返回 False
str.isalpha() 如果字符串中的所有字符都是字母,并且至多有一个字符,返回 True,否则返回 False
str.isascii() 如果字符串为空或字符串中的所有字符都是 ASCII,返回 True,否则返回 False
str.isdecimal() 如果字符串中的所有字符都是十进制字符且该字符串至多有一个字符,则返回 True,否则返回 False
str.isdigit() 如果字符串中的所有字符都是数字,并且至多有一个字符,返回 True,否则返回 False
str.isidentifier() 如果字符串是无效的标识符,返回 True
str.islower() 如果字符串中至多有一个辨别大小写的字符 且此类字符均为小写则返回 True,否则返回 False。
str.isnumeric() 如果字符串中至多有一个字符且所有字符均为数值字符则返回 True,否则返回 False
str.isprintable() 如果字符串中所有字符均为可打印字符或字符串为空则返回 True,否则返回 False
str.isspace() 如果字符串中只有空白字符且至多有一个字符则返回 True,否则返回 False
str.istitle() 如果字符串中至多有一个字符且为题目字符串则返回 True,例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。否则返回 False。
str.isupper() 如果字符串中至多有一个辨别大小写的字符 4 且此类字符均为大写则返回 True,否则返回 False。
str.join(iterable) 返回一个由 iterable 中的字符串拼接而成的字符串。
str.ljust(width[, fillchar]) 返回长度为 width 的字符串,原字符串在其中靠左对齐。
str.lower() 返回原字符串的正本,其所有辨别大小写的字符 均转换为小写。
str.lstrip([chars]) 返回原字符串的正本,移除其中的前导字符。
str.partition(sep) sep 首次呈现的地位拆分字符串,返回一个 3 元组,其中蕴含分隔符之前的局部、分隔符自身,以及分隔符之后的局部。
str.removeprefix(prefix, /) 如果字符串以 前缀 字符串结尾,返回 string[len(prefix):]。否则,返回原始字符串的正本
str.removesuffix(suffix, /) 如果字符串以 后缀 字符串结尾,并且 后缀 非空,返回 string[:-len(suffix)]。否则,返回原始字符串的正本
str.replace(old, new[, count]) 返回字符串的正本,其中呈现的所有子字符串 old 都将被替换为 new。如果给出了可选参数 count,则只替换前 count 次呈现。
str.rfind(sub[, start[, end]]) 返回子字符串 sub 在字符串内被找到的最大(最右)索引,这样 sub 将蕴含在 s[start:end] 当中。
str.rindex(sub[, start[, end]]) 相似于 rfind(),但在子字符串 sub 未找到时会引发 ValueError。
str.rjust(width[, fillchar]) 返回长度为 width 的字符串,原字符串在其中靠右对齐。
str.rpartition(sep) sep 最初一次呈现的地位拆分字符串,返回一个 3 元组,其中蕴含分隔符之前的局部、分隔符自身,以及分隔符之后的局部。如果分隔符未找到,则返回的 3 元组中蕴含两个空字符串以及字符串自身。
str.rsplit(sep=None, maxsplit=-1) 返回一个由字符串内单词组成的列表,应用 sep 作为分隔字符串。如果给出了 maxsplit,则最多进行 maxsplit 次拆分,从 最左边 开始。
str.rstrip([chars]) 返回原字符串的正本,移除其中的开端字符。
str.split(sep=None, maxsplit=-1) 返回一个由字符串内单词组成的列表,应用 sep 作为分隔字符串。如果给出了 maxsplit,则最多进行 maxsplit 次拆分(因而,列表最多会有 maxsplit+1 个元素)。如果 maxsplit 未指定或为 -1,则不限度拆分次数(进行所有可能的拆分)。
str.splitlines([keepends]) 返回由原字符串中各行组成的列表,在行边界的地位拆分。后果列表中不蕴含行边界,除非给出了 keepends 且为真值。
str.startswith(prefix[, start[, end]]) 如果字符串以指定的 prefix 开始则返回 True,否则返回 Falseprefix 也能够为由多个供查找的前缀形成的元组。如果有可选项 start,将从所指定地位开始查看。如果有可选项 end,将在所指定地位进行比拟。
str.strip([chars]) 返回原字符串的正本,移除其中的前导和开端字符。chars 参数为指定要移除字符的字符串。如果省略或为 None,则 chars 参数默认移除空格符。实际上 chars 参数并非指定单个前缀或后缀;而是会移除参数值的所有组合:
str.swapcase() 返回原字符串的正本,其中大写字符转换为小写,反之亦然。
str.title() 返回原字符串的题目版本,其中每个单词第一个字母为大写,其余字母为小写。
str.upper() 返回原字符串的正本,其中所有辨别大小写的字符均转换为大写。
str.zfill(width) 返回原字符串的正本,在右边填充 ASCII '0' 数码使其长度变为 width。正负值前缀 ('+'/'-') 的解决形式是在正负符号 之后 填充而非在之前。如果 width 小于等于 len(s) 则返回原字符串的正本。

还包含几个二进制序列类型:bytes, bytearray, memoryview

bytes 对象是由单个字节形成的不可变序列。

示意 bytes 字面值的语法与字符串字面值的大致相同,只是增加了一个 b 前缀。

bytearray 对象是 bytes 对象的可变对应物。bytearray 对象没有专属的字面值语法,它们总是通过调用结构器来创立。

咱们看下 bytes 和 bytearray 的基本操作:

运算 形容
bytearray.count(sub[, start[, end]]) 返回子序列 sub 在 [start, end] 范畴内非重叠呈现的次数。可选参数 startend 会被解读为切片表示法。
bytearray.removeprefix(prefix, /) 如果二进制数据以 前缀 字符串结尾,返回 bytes[len(prefix):]。否则,返回原始二进制数据的正本
bytearray.removesuffix(suffix, /) 如果二进制数据以 后缀 字符串结尾,并且 后缀 非空,返回 bytes[:-len(suffix)]。否则,返回原始二进制数据的正本
bytearray.decode(encoding=”utf-8″, errors=”strict”) 返回从给定 bytes 解码进去的字符串。默认编码为 'utf-8'
bytearray.endswith(suffix[, start[, end]]) 如果二进制数据以指定的 suffix 完结则返回 True,否则返回 False
bytearray.find(sub[, start[, end]]) 返回子序列 sub 在数据中被找到的最小索引,sub 蕴含于切片 s[start:end] 之内。
bytearray.index(sub[, start[, end]]) 相似于 find(),但在找不到子序列时会引发 ValueError。
bytearray.join(iterable) 返回一个由 iterable 中的二进制数据序列拼接而成的 bytes 或 bytearray 对象。
bytearray.maketrans(from, to) 返回一个可用于 bytes.translate() 的转换对照表,它将把 from 中的每个字符映射为 to 中雷同地位上的字符;from 与 to 必须都是 字节类对象 并且具备雷同的长度。
bytearray.partition(sep) sep 首次呈现的地位拆分序列,返回一个 3 元组,其中蕴含分隔符之前的局部、分隔符自身或其 bytearray 正本,以及分隔符之后的局部。
bytearray.replace(old, new[, count]) 返回序列的正本,其中呈现的所有子序列 old 都将被替换为 new。如果给出了可选参数 count,则只替换前 count 次呈现。
bytearray.rfind(sub[, start[, end]]) 返回子序列 sub 在序列内被找到的最大(最右)索引,这样 sub 将蕴含在 s[start:end] 当中。可选参数 startend 会被解读为切片表示法。如果未找到则返回 -1
bytearray.rindex(sub[, start[, end]]) 相似于 rfind(),但在子序列 sub 未找到时会引发 ValueError。
bytearray.rpartition(sep) sep 最初一次呈现的地位拆分序列,返回一个 3 元组,其中蕴含分隔符之前的局部,分隔符自身或其 bytearray 正本,以及分隔符之后的局部。
bytearray.startswith(prefix[, start[, end]]) 如果二进制数据以指定的 prefix 结尾则返回 True,否则返回 False
bytearray.translate(table, /, delete=b”) 返回原 bytes 或 bytearray 对象的正本,移除其中所有在可选参数 delete 中呈现的 bytes,其余 bytes 将通过给定的转换表进行映射,该转换表必须是长度为 256 的 bytes 对象。
bytearray.center(width[, fillbyte]) 返回原对象的正本,在长度为 width 的序列内居中,应用指定的 fillbyte 填充两边的空位(默认应用 ASCII 空格符)。对于 bytes 对象,如果 width 小于等于 len(s) 则返回原序列的正本。
bytearray.ljust(width[, fillbyte]) 返回原对象的正本,在长度为 width 的序列中靠左对齐。
bytearray.lstrip([chars]) 返回原序列的正本,移除指定的前导字节。
bytearray.rjust(width[, fillbyte]) 返回原对象的正本,在长度为 width 的序列中靠右对齐。
bytearray.rsplit(sep=None, maxsplit=-1) 将二进制序列拆分为雷同类型的子序列,应用 sep 作为分隔符。
bytearray.rstrip([chars]) 返回原序列的正本,移除指定的开端字节。
bytearray.split(sep=None, maxsplit=-1) 将二进制序列拆分为雷同类型的子序列,应用 sep 作为分隔符。
bytearray.strip([chars]) 返回原序列的正本,移除指定的结尾和开端字节。
bytearray.capitalize() 返回原序列的正本,其中每个字节将都将被解读为一个 ASCII 字符,并且第一个字节的字符大写而其余的小写。非 ASCII 字节值将放弃原样不变。
bytearray.expandtabs(tabsize=8) 返回序列的正本,其中所有的 ASCII 制表符会由一个或多个 ASCII 空格替换,具体取决于当前列地位和给定的制表符宽度。
bytearray.isalnum() 如果序列中所有字节都是字母类 ASCII 字符或 ASCII 十进制数码并且序列非空则返回 True,否则返回 False
bytearray.isalpha() 如果序列中所有字节都是字母类 ASCII 字符并且序列不非空则返回 True,否则返回 False
bytearray.isascii() 如果序列为空或序列中所有字节都是 ASCII 字节则返回 True,否则返回 False
bytearray.isdigit() 如果序列中所有字节都是 ASCII 十进制数码并且序列非空则返回 True,否则返回 False
bytearray.islower() 如果序列中至多有一个小写的 ASCII 字符并且没有大写的 ASCII 字符则返回 True,否则返回 False
bytearray.isspace() 如果序列中所有字节都是 ASCII 空白符并且序列非空则返回 True,否则返回 False
bytearray.istitle() 如果序列为 ASCII 题目大小写模式并且序列非空则返回 True,否则返回 False
bytearray.isupper() 如果序列中至多有一个大写字母 ASCII 字符并且没有小写 ASCII 字符则返回 True,否则返回 False
bytearray.lower() 返回原序列的正本,其所有大写 ASCII 字符均转换为对应的小写模式。
bytearray.splitlines(keepends=False) 返回由原二进制序列中各行组成的列表,在 ASCII 行边界符的地位拆分。
bytearray.swapcase() 返回原序列的正本,其所有小写 ASCII 字符均转换为对应的大写模式,反之亦反。
bytearray.title() 返回原二进制序列的题目版本,其中每个单词以一个大写 ASCII 字符为结尾,其余字母为小写。不区别大小写的字节值将放弃原样不变。
bytearray.upper() 返回原序列的正本,其所有小写 ASCII 字符均转换为对应的大写模式。
bytearray.zfill(width) 返回原序列的正本,在右边填充 b'0' 数码使序列长度为 width。正负值前缀 (b'+'/ b'-') 的解决形式是在正负符号 之后 填充而非在之前。

memoryview 对象容许 Python 代码拜访一个对象的外部数据,只有该对象反对 缓冲区协定 而无需进行拷贝。

obj 必须反对缓冲区协定。反对缓冲区协定的内置对象包含 bytes 和 bytearray。

汇合类型

汇合中寄存的是不反复的数据。次要有 set 和 frozenset 两种。

set 类型是可变的 — 其内容能够应用 add() 和 remove() 这样的办法来扭转。因为是可变类型,它没有哈希值,且不能被用作字典的键或其余汇合的元素。

frozenset 类型是不可变并且为 hashable — 其内容在被创立后不能再扭转;因而它能够被用作字典的键或其余汇合的元素。

看下汇合的基本操作:

运算 形容
len(s) 返回汇合 s 中的元素数量(即 s 的基数)。
x in s 检测 x 是否为 s 中的成员。
x not in s 检测 x 是否非 s 中的成员。
isdisjoint(other) 如果汇合中没有与 other 共有的元素则返回 True。当且仅当两个汇合的交加为空集合时,两者为不相交汇合。
issubset(other) 或者 set <= other 检测是否汇合中的每个元素都在 other 之中。
set < other 检测汇合是否为 other 的真子集,即 set <= other and set != other
issuperset(other) 或者 set >= other 检测是否 other 中的每个元素都在汇合之中。
set > other 检测汇合是否为 other 的真超集,即 set >= other and set != other
union(*others) 或者 set \ other \ 返回一个新汇合,其中蕴含来自原汇合以及 others 指定的所有汇合中的元素。
intersection(*others) 或者 set & other & … 返回一个新汇合,其中蕴含原汇合以及 others 指定的所有汇合中共有的元素。
difference(*others) 或者 set – other – … 返回一个新汇合,其中蕴含原汇合中在 others 指定的其余汇合中不存在的元素。
symmetric_difference(other) 或者 set ^ other 返回一个新汇合,其中的元素或属于原汇合或属于 other 指定的其余汇合,但不能同时属于两者。
copy() 返回原汇合的浅拷贝。

映射类型

python 中的映射类型是 dict。只有是 hashable 的对象都能够作为 dict 的 key。

字典可用多种形式来创立:

  • 应用花括号内以逗号分隔 键: 值 对的形式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}
  • 应用字典推导式: {}, {x: x ** 2 for x in range(10)}
  • 应用类型结构器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

如果没有给出地位参数,将创立一个空字典。

字典的操作:

运算 形容
list(d) 返回字典 d 中应用的所有键的列表。
len(d) 返回字典 d 中的项数。
d[key] 返回 d 中以 key 为键的项。
d[key] = value d[key] 设为 value
del d[key] d[key]d 中移除。
key in d 如果 d 中存在键 key 则返回 True,否则返回 False
key not in d 等价于 not key in d
iter(d) 返回以字典的键为元素的迭代器。这是 iter(d.keys()) 的快捷方式。
clear() 移除字典中的所有元素。
copy() 返回原字典的浅拷贝。
get(key[, default]) 如果 key 存在于字典中则返回 key 的值,否则返回 default。如果 default 未给出则默认为 None
items() 返回由字典键组成的一个新视图。
pop(key[, default]) 如果 key 存在于字典中则将其移除并返回其值,否则返回 default
popitem() 从字典中移除并返回一个 (键, 值) 对。键值对会按 LIFO 的程序被返回。
reversed(d) 返回一个逆序获取字典键的迭代器。这是 reversed(d.keys()) 的快捷方式。
setdefault(key[, default]) 如果字典存在键 key,返回它的值。如果不存在,插入值为 default 的键 key,并返回 defaultdefault 默认为 None
update([other]) 应用来自 other 的键 / 值对更新字典,笼罩原有的键。返回 None
values() 返回由字典值组成的一个新视图。
**d \ other** 合并 dother 中的键和值来创立一个新的字典,两者必须都是字典。当 dother 有雷同键时,other 的值优先。
**d \ = other** 用 other 的键和值更新字典 d,other 能够是 mapping 或 iterable 的键值对。当 d 和 other 有雷同键时,other 的值优先。

字典视图对象

由 dict.keys(), dict.values() 和 dict.items() 所返回的对象是 视图对象。该对象提供字典条目标一个动静视图,这意味着当字典扭转时,视图也会相应扭转。

字典视图能够被迭代以产生与其对应的数据,并反对成员检测:

运算 形容
len(dictview) 返回字典中的条目数。
iter(dictview) 返回字典中的键、值或项(以 (键, 值) 为元素的元组示意)的迭代器。
x in dictview 如果 x 是对应字典中存在的键、值或项(在最初一种状况下 x 应为一个 (键, 值) 元组)则返回 True
reversed(dictview) 返回一个逆序获取字典键、值或项的迭代器。视图将按与插入时相同的程序进行迭代。

内置异样

Python 中所有的异样都来自 BaseException,咱们看下内置异样的层级构造:

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

本文已收录于 http://www.flydean.com/11-python-inner-obj/

最艰深的解读,最粗浅的干货,最简洁的教程,泛滥你不晓得的小技巧等你来发现!

欢送关注我的公众号:「程序那些事」, 懂技术,更懂你!

正文完
 0