Python基礎之:Python中的内部對象

簡介

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值的對象：

• 被定義為假值的常量:

  None

  和

  False

  。
• 任何數值類型的零:

  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	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 和 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	x 和 y 按位 或
x ^ y	x 和 y 按位 異或
x & y	x 和 y 按位 與
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	False True
s + t	s 與 t 相拼接
s * n 或 n * s	相當于 s 與自身進行 n 次拼接
s[i]	s 的第 i 項，起始為 0
s[i:j]	s 從 i 到 j 的切片
s[i:j:k]	s 從 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 中出現的總次數

可變序列類型的操作：

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 的元素
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] 範圍内非重疊出現的次數。 可選參數 start 與 end 會被解讀為切片表示法。
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 False 。 suffix 也可以為由多個供查找的字尾構成的元組。
str.expandtabs (tabsize=8)	傳回字元串的副本，其中所有的制表符會由一個或多個空格替換，具體取決于目前列位置和給定的制表符寬度。
str.find(sub[, start[, end]])	傳回子字元串 sub 在 s[start:end] 切片内被找到的最小索引。
str.format(args*, kwargs)	執行字元串格式化操作。
str.format_map (mapping)	類似于 str.format(**mapping)，不同之處在于 mapping 會被直接使用而不是複制到一個 dict。
str.index	類似于 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 在字元串内被找到的最大（最右）索引，這樣 sub 将包含在 s[start:end] 當中。
str.rindex	類似于 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	傳回原字元串的副本，移除其中的末尾字元。
str.split(sep=None, maxsplit=-1)	傳回一個由字元串内單詞組成的清單，使用 sep 作為分隔字元串。 如果給出了 maxsplit，則最多進行 maxsplit 次拆分（是以，清單最多會有 maxsplit+1 個元素）。 如果 maxsplit 未指定或為 -1 ，則不限制拆分次數（進行所有可能的拆分）。
str.splitlines([keepends])	傳回由原字元串中各行組成的清單，在行邊界的位置拆分。 結果清單中不包含行邊界，除非給出了 keepends 且為真值。
str.startswith(prefix[, start[, end]])	如果字元串以指定的 prefix 開始則傳回 True False 。 prefix 也可以為由多個供查找的字首構成的元組。 如果有可選項 start，将從所指定位置開始檢查。 如果有可選項 end，将在所指定位置停止比較。
str.strip	傳回原字元串的副本，移除其中的前導和末尾字元。 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] 範圍内非重疊出現的次數。 可選參數 start 與 end 會被解讀為切片表示法。
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] 當中。 可選參數 start 與 end 會被解讀為切片表示法。 如果未找到則傳回 -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)
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。
popitem	從字典中移除并傳回一個 (鍵, 值) 對。 鍵值對會按 LIFO 的順序被傳回。
reversed(d)	傳回一個逆序擷取字典鍵的疊代器。 這是 reversed(d.keys())
setdefault	如果字典存在鍵 key ，傳回它的值。如果不存在，插入值為 default 的鍵 key ，并傳回 default 。 default 預設為 None
update ([other])	使用來自 other 的鍵/值對更新字典，覆寫原有的鍵。 傳回 None
values	傳回由字典值組成的一個新視圖。
d | other	合并 d 和 other 中的鍵和值來建立一個新的字典，兩者必須都是字典。當 d 和 other 有相同鍵時， 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/

最通俗的解讀，最深刻的幹貨，最簡潔的教程，衆多你不知道的小技巧等你來發現！

歡迎關注我的公衆号:「程式那些事」,懂技術，更懂你！