開發與維運

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

  • 被定義為假值的常量: 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/

最通俗的解讀,最深刻的乾貨,最簡潔的教程,眾多你不知道的小技巧等你來發現!

歡迎關注我的公眾號:「程序那些事」,懂技術,更懂你!

Leave a Reply

Your email address will not be published. Required fields are marked *