常见内置数据类型
标签(tag):
Python，数据类型，可变对象，不可变对象，可哈希对象，可迭代对象，可遍历对象
参考资料：
Python 文档：内置类型(Build-in Types)
Python 文档：数据模型 - 对象、值与类型
Python 文档：术语对照表 - 可哈希
Python 文档：属于对照表 - 可迭代对象
Python 文档：逻辑值检测
Python 文档：数字类型 - int, float, and complex
Python 文档：序列类型 - list, tuple, and range
Python 文档：字符串的方法
Python 文档：可变序列类型
Python 文档：集合类型 set 与 frozenset
Python 文档：映射类型 dict
Python 文档：运算优先级
Python的常用内置类型（Build-in Types）
参考资料：Python内置类型(Build-in Types)
在Python中，常用的类型是这些：
Python中查看数据类型的函数(function)为type()。
Python中常看该数据类型的内置方法(build-in method)的函数为dir()。
Python中查看变量内存地址的函数为：id()。
一个对象是否可变(mutable)
复习：来自01_Python中的变量
- 对象(object)是存储在内存(memory)某处的数据(data)。
- 每个对象都有一个内存地址(memory address)、一个类型(type)和一个值(value)。
在Python中，一个对象被创建后，它的内存地址是永远不变的。
一些对象的值在对象被创建后是不能再更改的，这类对象被称为不可变对象(immutable objects)；
一些对象的值在被创建后任可被修改，这类对象被称为可变对象(mutable obejcts)。
一个对象是否可变，取决于该对象的类型(type)。也就是说：拥有不可变类型的对象就是不可变对象，拥有可变类型的对象就是可变对象。
哪些常见类型是可变或不可变类型呢？
常见可变类型有：列表(List)，集合(Set)，字典(Dictionary)
常见不可变类型有：数值类型(Numeric Types)、元组(Tuple)、range、字符串(String)、frozenset。
Python实例1：
>>>var = [1, 2, 3] # 创建一个引用列表对象(list)的变量
>>>print(id(var),type(var)) # 打印该变量的内存地址和类型
2803140207104 <class 'list'>
>>>var[0] = 5 # 更改该对象的值（var没有引用新的对象）
>>>var # 打印该对象，对象的值已被修改
[5, 2, 3]
>>>print(id(var),type(var)) # 再次打印该对象的内存地址和类型
2803140207104 <class 'list'> # 内存地址没有改变，var引用同一个对象。
>>>var = True # 创建一个引用布尔对象(bool)的变量
>>>print(id(var),type(var)) # 打印该变量的内存地址和类型
140716609805160 <class 'bool'>
>>>var = False # 改变该变量的值
>>>print(id(var),type(var)) # 重新打印该变量的内存地址和类型
140716609805192 <class 'bool'> # 内存地址改变，var引用不同的对象
一个对象是否可哈希(hashable)
一个对象的哈希值(hash value)如果在其生命周期内绝不改变，并可以同其他对象进行比较，就被称为可哈希(hashable)。
在Python中，如果对象有__hash__()和__eq__()方法(method)，且该对象不可变，那么该对象就是可哈希的。
Python常用内置类型中：
-
可哈希的类型有：数值类型、字符串类型、range。
-
不可哈希类型有：列表类型、字典类型、可变集合类型(set)。
-
如果不可变容器的所有元素都是可哈希的，那么该不可变容器也是可哈希的。
- 元组、frozenset
Python实例：
>>>'__hash__' in dir(5)
True
>>>'__eq__' in dir(5)
True
>>>hash(5)
5
>>># 数值类型不可变，且有用__hash__和__eq__，因此数据类型可哈希。
>>>list1 = [1, 2, 3]
>>>'__hash__' in dir(list1)
True
>>>'__eq__' in dir(list1)
True
>>>hash(list1)
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
hash(list1)
TypeError: unhashable type: 'list'
>>># list类型可变，哪怕拥有__hash__和__eq__也不可哈希。
一个对象是否可迭代(iterable)
如果一个对象能够逐一返回其成员项，那么这个对象就是可迭代的(iterable)，也叫做可遍历(traversal)的。
在Python中，如果对象有__iter__()或__getitem__方法(method)，那么该对象就是可迭代的。
Python常见类型中所有的序列类型(list, tuple, str, range)、集合类型(set, frozenset)与映射类型(dict)都可迭代。
Python实例：
>>>'__iter__' in dir([1, 2, 3])
True
>>># list类型拥有可迭代。
>>>'__iter__' in dir(5)
False
>>># 数值类型不可迭代。
数值类型(Numeric Type)
数值类型是不可变类型(immutable type)，它包括布尔类型、整数、浮点数与复数。
| 类型 | 英文名 | 构造方式 | 对应关键字 | 构造函数 |
|---|---|---|---|---|
| 布尔 | Boolean | var = True |
bool |
bool() |
| 整数 | Integer | var = 5 |
int |
int() |
| 浮点数 | Float | var = 5.0 |
float |
float() |
| 复数 | Complex Number | var = 5.0 + 0j |
complex |
complex() |
布尔类型
参考资料：Python 文档：逻辑值检测
布尔类型只有俩个值，一个是True，另一个是False。
常见内置类型被视为False的情况：
- 被定义为假值的常量:
None和False - 任何数值类型的零:
0,0.0,0j,Decimal(0),Fraction(0, 1) - 空的序列和多项集:
'',(),[],{},set(),range(0)
通俗来讲，非空非零即为真。
布尔运算 --- and, or, not
这些属于布尔运算(Boolean Operations)，按优先级排列:
| 运算 | 结果： | 备注 |
|---|---|---|
not x |
if x is false, then True, else False |
|
x and y |
if x is false, then x, else y | 短路运算 |
x or y |
如果 x 为真值，则 x，否则 y | 短路运算 |
比较运算符(Comparison Operators)
在 Python 中有八种比较运算符。 它们的优先级相同，且高于布尔运算。
比较运算可以任意串连；例如，x < y <= z 等价于 x < y and y <= z，前者的不同之处在于 y 只被求值一次。在两种情况下当 x < y 结果为假值时 z 都不会被求值，因为and为短路运算符。
此表格汇总了比较运算:
| 运算 | 含意 | 运算 | 含意 |
|---|---|---|---|
< |
严格小于 (strictly less than) | == |
相等（等于）(equal) |
<= |
小于或等于 (less than or equal) | != |
不等于 (not equal) |
> |
严格大于 (strictly greater than) | is |
对象标识 (object identity) |
>= |
大于或等于 (greater than or equal) | is not |
否定的对象标识 (negated object identity) |
除不同的数值类型外，不同类型的对象相等比较的结果总是False。
对于某些对象类型（例如，类对象 class object），== 等价于 is 。
因此，具有不同标识的类的实例比较结果通常为不相等，除非类定义了__eq__()方法。
整数型、浮点型、复数型
参考资料：Python 文档：数字类型 - int, float, and complex
Python完全支持三种数值类型的混合运算，因此平时不必太过在意它们的类型。
在Python中，复数的虚数部分由j表示，而不是数学中常用的i。这主要是为了增加代码在不同字体下的可读性。
要从一个复数 z 中提取这两个部分，可使用 z.real 和 z.imag。
所有数字类型（复数除外）都支持下列运算（有关运算优先级，请参阅：运算符优先级）:
| 运算 | 结果： | 备注 | 运算 | 结果： | 备注 |
|---|---|---|---|---|---|
x + y |
x 和 y 的和 | abs(x) |
x 的绝对值或大小(magnitude ) | ||
x - y |
x 和 y 的差 | c.conjugate() |
复数 c 的共轭 | ||
x * y |
x 和 y 的乘积 | divmod(x, y) |
(x // y, x % y) |
(2) | |
x / y |
x 和 y 的商 | pow(x, y) |
x 的 y 次幂 | (4) | |
x // y |
x 和 y 的商数 | (1)(2) | x ** y |
x 的 y 次幂 | (4) |
x % y |
x / y 的余数 |
(2) | -x |
x 取反 |
部分方程的完整文档：abs()，int()， float()，complex()，divmod()，pow()。
注释：
- 也称为整数除法。 对于
int类型的操作数，结果的类型为int。 对于float类型的操作数，结果的类型为float。 - 不可用于复数。 而应在适当条件下使用
abs()转换为浮点数。 - float 也接受字符串 "nan" 和附带可选前缀 "+" 或 "-" 的 "inf" 分别表示非数字 (NaN) 以及正或负无穷。
- Python 将
pow(0, 0)和0 ** 0定义为1，这是编程语言的普遍做法。
序列类型(Sequence Type)
参考资料：Python 文档：序列类型 - list, tuple, and range
| 类型 | 英文名 | 对应关键字 | 构造函数 | 是否可变 |
|---|---|---|---|---|
| 列表 | list | list | list() |
可变 |
| 元组 | tuple | tuple | tuple() |
不可变 |
| 数字序列：range | range | range | range() |
不可变 |
| 文本序列：字符串 | string | str | str() |
不可变 |
列表(list)
列表是可变序列，通常用于存放同类项目的集合。列表实现了所有通用序列操作[通用序列操作](#通用序列操作(Common Sequence Operation) )和[可变序列操作](#可变序列类型(Mutable Sequence Type))。
列表的构建方式：
- 使用一对方括号来表示空列表:
[] - 使用方括号，其中的项以逗号分隔:
[a],[a, b, c] - 使用列表推导式:
[x for x in iterable] - 使用类型的构造器:
list()或list(iterable)
列表内置方法：
sort(*, key=None, reverse=False)
此方法会对列表进行排序，只使用 < 来进行各项间比较。
key 是带有一个参数的函数，它用于从每个列表元素中提取比较键 (例如 key=str.lower)。 对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。 默认值 None 表示直接对列表项排序而不计算一个单独的键值。
reverse 如果设为 True，则每个列表元素将按反向顺序比较进行排序。
元组(tuple)
元组是不可变序列，实现了所有[通用序列操作](#通用序列操作(Common Sequence Operation) )。
元组的构建方式：
- 使用一对圆括号来表示空元组:
() - 使用一个后缀的逗号来表示单元组:
a,或(a,) - 使用以逗号分隔的多个项:
a, b, cor(a, b, c) - 使用内置的
tuple():tuple()或tuple(iterable)
请注意决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。 例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时附带一个三元组。
range对象
range类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。range 对象实现了[通用序列操作](#通用序列操作(Common Sequence Operation) )，但拼接和重复除外。
range的构造方式：
class range(stop)class range(start, stop[, step])
注意事项
- range 构造器的参数必须为整数。
- 如果省略 step 参数，则默认为
1。 如果省略 start 参数，则默认为0。 如果 step 为零，则会引发ValueError。 - 如果 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. - 如果
r[0]不符合值的限制条件，则该 range 对象为空。 - range 对象支持负索引，将其解读为从正索引所确定的序列的末尾开始索引。
字符串(String)
字符串是由 Unicode 码位构成的不可变序列。字符串实现了所有[通用序列操作](#通用序列操作(Common Sequence Operation) )。
str的构造方式
- 单引号:
'允许包含有 "双" 引号' - 双引号:
"允许嵌入 '单' 引号" - 三重引号:
'''三重单引号''',"""三重双引号"""（三重引号保留文本原始格式） - 禁止转义字符生效：
r'\n不会转义',r"\t也不会转义"等
由于不存在单独的“字符”类型，对字符串做索引操作将产生一个长度为 1 的字符串。 也就是说，对于一个非空字符串 s, s[0] == s[0:1]。
字符串常用内置方法：
参考资料：Python 文档：字符串的方法
| 查找类 | 方法说明 |
|---|---|
find() |
查找元素是否在字符串中，若存在则返回下边(index)，否则返回-1 |
index() |
查找元素是否在字符串中，若存在则返回下标，否则报错 |
| 修改类 | 方法说明 |
|---|---|
replace() |
替换内容 |
split() |
切割字符串，默认以空格切割，返回一个列表 |
join() |
将序列的内容以指定符号拼接 |
upper() |
将字符串中的小写转大写 |
lower() |
将字符串中的大写转小写 |
strip() |
删除字符串两侧的空白字符 |
| 判断类 | 方法说明 |
|---|---|
isalpha() |
如果字符串所有字符都是字母，返回True，否则返回False。 |
isdigit() |
如果字符串所有字符都是数字，返回True，否则返回False。 |
isalnum() |
如果字符串所有字符都是字母或数字，返回True，否则返回False。 |
通用序列操作(Common Sequence Operation)
大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。
此表按优先级升序列出了序列操作。 在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。
| 运算 | 结果： | 备注 |
|---|---|---|
x in s |
如果 s 中的某项等于 x 则结果为 True，否则为 False |
|
x not in s |
如果 s 中的某项等于 x 则结果为 False，否则为 True |
|
s + t |
s 与 t 相拼接(concatenation) | (6)(7) |
s * n 或 n * s |
相当于 s 与自身进行 n 次拼接 | (2)(7) |
s[i] |
s 的第 i 项，起始为 0 | (3) |
s[i:j] |
s 从 i 到 j 的切片(slice ) | (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 中首次出现项的索引号(index)（索引号在 i 或其后且在 j 之前） | (8) |
s.count(x) |
x 在 s 中出现的总次数 |
in 和 not in 操作具有与比较操作相同的优先级。 + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级，因为解析器无法判断操作数的类型
相同类型的序列也支持比较运算(Comparison Operation)。tuple 和 list 的比较是通过比较对应元素的字典顺序(lexicographically order)。 想要二者比较结果相等，则每个元素比较结果都必须相等，且两个序列长度必须相同。
注释：
- 小于
0的 n 值会被当作0来处理 (生成一个与 s 同类型的空序列)。 请注意序列 s 中的项并不会被拷贝；它们会被多次引用。例如:
lists = [[]] * 3
lists
[[], [], []]
lists[0].append(3)
lists
[[3], [3], [3]]
具体的原因在于 [[]] 是一个包含了一个空列表的单元素列表，所以 [[]] * 3 结果中的三个元素都是对这一个空列表的引用。 修改 lists 中的任何一个元素实际上都是对这一个空列表的修改。 你可以用以下方式创建以不同列表为元素的列表:
lists = [[] for i in range(3)]
lists[0].append(3)
lists[1].append(5)
lists[2].append(7)
lists
[[3], [5], [7]]
-
如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为
len(s) + i或len(s) + j。 但要注意-0仍然为0。 -
s 从 i 到 j 的切片被定义为所有满足
i <= k < j的索引号 k 的项组成的序列。 如果 i 或 j 大于len(s)，则使用len(s)。 如果 i 被省略或为None，则使用0。 如果 j 被省略或为None，则使用len(s)。 如果 i 大于等于 j，则切片为空。 -
s 从 i 到 j 步长为 k 的切片被定义为所有满足
0 <= n < (j-i)/k的索引号x = i + n*k的项组成的序列。 换句话说，索引号为i,i+k,i+2*k,i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。 当 k 为正值时，i 和 j 会被减至不大于len(s)。 当 k 为负值时，i 和 j 会被减至不大于len(s) - 1。 如果 i 或 j 被省略或为None，它们会成为“终止”值 (是哪一端的终止值则取决于 k 的符号)。 请注意，k 不可为零。 如果 k 为None，则当作1处理。 -
拼接不可变序列总是会生成新的对象。 这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。 想要获得线性的运行时开销，你必须改用下列替代方案之一：
- 如果拼接
str对象，你可以构建一个列表并在最后使用str.join()或是写入一个io.StringIO实例并在结束时获取它的值 - 如果拼接
bytes对象，你可以类似地使用bytes.join()或io.BytesIO，或者你也可以使用bytearray对象进行原地拼接。bytearray对象是可变的，并且具有高效的重分配机制 - 如果拼接
tuple对象，请改为扩展list类 - 对于其它类型，请查看相应的文档
-
某些序列类型 (例如 range`) 并不支持序列拼接或重复，仅支持遵循特定模式的项序列
-
当 x 在 s 中找不到时
index会引发ValueError)。 不是所有对象(object)都支持传入额外参数 i 和 j。 这两个参数允许高效地搜索序列的子序列。 传入这两个额外参数大致相当于使用s[i:j].index(x)，但是不会复制任何数据，并且返回的索引是相对于序列的开头而非切片的开头。
可变序列类型(Mutable Sequence Type)
参考资料：Python 文档：可变序列类型
以下表格中的操作是在可变序列类型上定义的。
表格中的 s 是可变序列类型的实例(instance)，t 是任意可迭代对象(iterable object)，而 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 的元素 |
(1) |
del s[i:j:k] |
从列表中移除 s[i:j:k] 的元素 |
|
s.append(x) |
将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x]) |
|
s.clear() |
从 s 中移除所有项 (items)(等同于 del s[:]) |
(5) |
s.copy() |
创建 s 的浅拷贝(shallow copy) (等同于 s[:]) |
(5) |
s.extend(t) 或 s += t |
用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t) |
|
s *= n |
使用 s 的内容重复 n 次来对其进行更新 | (6) |
s.insert(i, x) |
在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x]) |
|
s.pop() 或 s.pop(i) |
提取在 i 位置上的项，并将其从 s 中移除 | (2) |
s.remove(x) |
删除 s 中第一个 s[i] 等于 x 的项目。 |
(3) |
s.reverse() |
就地将列表中的元素逆序。 | (4) |
注释：
-
t 必须与它所替换的切片具有相同的长度。
-
可选参数 i 默认为
-1，因此在默认情况下会移除并返回最后一项。 -
当在 s 中找不到 x 时
remove()操作会引发ValueError。 -
当反转大尺寸序列时
reverse()方法会原地修改该序列以保证空间经济性。 为提醒用户此操作是通过间接影响进行的，它并不会返回反转后的序列。 -
包括
clear()和copy()是为了与不支持切片操作的可变容器 (例如dict和set) 的接口保持一致。copy()不是collections.abc.MutableSequenceABC 的一部分，但大多数具体的可变序列类都提供了它。3.3 新版功能:
clear()和copy()方法。 -
n 值为一个整数，或是一个实现了
__index__()的对象。 n 值为零或负数将清空序列。 序列中的项不会被拷贝；它们会被多次引用，正如 [通用序列操作](#通用序列操作(Common Sequence Operation)) 中有关s * n的说明。
集合类型(Set Type)
参考资料：Python 文档：集合类型 set 与 frozenset
set type 对象是由具有唯一性的可哈希(hashable)对象所组成的无序多项集，set type的所有元素必须可哈希。由于集合类型是无序的，它并不记录元素位置或插入顺序，因此集合类型不支持索引、切片或其他序列类的操作。
| 类型 | 对应关键字 | 构造函数 | 是否可变 | 是否可哈希 |
|---|---|---|---|---|
| set | set | set() |
可变 | 不可哈希 |
| frozenset | frozenset | frozenset() |
不可变 | 可哈希 |
set的内容可以使用 add() 和 remove() 来改变。
set和frozenset的构建方式:
- 使用花括号内以逗号分隔元素的方式:
{'jack', 'sjoerd'} - 使用集合推导式:
{c for c in 'abracadabra' if c not in 'abc'} - 使用类型构造器:
set(),set('foobar'),set(['a', 'b', 'foo'])
frozenset可通过构造函数frozenset()来创建：
class set([iterable])class frozenset([iterable])
上述俩种构建器输入一个可迭代对象(iterable))返回一个新的 set 或 frozenset 对象。 集合的元素必须为可哈希的。要表示由集合对象构成的集合，所有的内层集合必须为 frozenset对象。 如果未指定可迭代对象，则将返回一个新的空集合。
可用于set和frozenset的操作
下表中 s 代表多项集(collection)，x 是任何满足 s 所规定的类型和值限制的任意对象，set代表集合，other代表另一集合。
| 操作 | 操作说明 |
|---|---|
len(s) |
返回集合 s 中的元素数量（即 s 的基数）。 |
x in s |
检测 x 是否为 s 中的成员。 |
x not in s |
检测 x 是否非 s 中的成员。 |
isdisjoint(other) |
如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。 |
set <= other，issubset(other) |
检测是否集合中的每个元素都在 other 之中。 |
set < other |
检测集合是否为 other 的真子集，即 set <= other and set != other。 |
set >= other，issuperset(other) |
检测是否 other 中的每个元素都在集合之中。 |
set > other |
检测集合是否为 other 的真超集，即 set >= other and set != other。 |
| `set | other |
set & other & ...，intersection(others) |
返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。 |
set - other - ...，difference(others) |
返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。 |
set ^ other，symmetric_difference(others) |
返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。 |
copy() |
返回原集合的浅拷贝。 |
注意：
-
union()、intersection()、difference()、symmetric_difference()、issubset()和issuperset()方法可以接受任何可迭代对象作为参数。
而基于运算符的对应方法则要求参数为集合对象。 -
混合了
set实例与frozenset的二进制位运算将返回与第一个操作数相同的类型。例如:frozenset('ab') | set('bc')将返回frozenset的实例。
可用于set但不可用于frozenset的操作
下表中 set代表集合，other代表另一集合。elem代表满足set所有要求的元素。
| 操作 | 操作说明 |
|---|---|
| `set | = other |
set &= other & ...，intersection_update(others) |
更新集合，只保留其中在所有 others 中也存在的元素。 |
| `set -= other | ...，difference_update(others)` |
set ^= other，symmetric_difference_update(others) |
更新集合，只保留存在于集合的一方而非共同存在的元素。 |
add(elem) |
将元素 elem 添加到集合中。 |
remove(elem) |
从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发KeyError。 |
discard(elem) |
如果元素 elem 存在于集合中则将其移除。 |
pop() |
从集合中移除并返回任意一个元素。 如果集合为空则会引发KeyError。 |
clear() |
从集合中移除所有元素。 |
注意：
update()，intersection_update()，difference_update()和symmetric_difference_update()方法将接受任意可迭代对象作为参数。__contains__(),remove()和discard()方法的 elem 参数可能是一个 set。 为支持对一个等价的 frozenset 进行搜索，会根据 elem 临时创建一个该类型对象。
映射类型(dict)
参考资料：Python 文档：映射类型 dict
映射(mapping)类型对象会将可哈希值映射到任意对象。 映射属于可变对象。字典是内置的映射类型。
字典由键值对构成。字典的键(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)
如果没有给出位置参数，将创建一个空字典。 如果给出一个位置参数并且其属于映射对象，将创建一个具有与映射对象相同键值对的字典。 否则的话，位置参数必须为一个 iterable对象。 该可迭代对象中的每一项本身必须为一个刚好包含两个元素的可迭代对象。 每一项中的第一个对象将成为新字典的一个键，第二个对象将成为其对应的值。 如果一个键出现一次以上，该键的最后一个值将成为其在新字典中对应的值。
如果给出了关键字参数，则关键字参数及其值会被加入到基于位置参数创建的字典。 如果要加入的键已存在，来自关键字参数的值将替代来自位置参数的值。
可用于字典(dict)的操作
d代表一个字典
| 操作 | 操作说明 |
|---|---|
list(d) |
返回字典 d 中使用的所有键的列表。 |
len(d) |
返回字典 d 中的项数。 |
| d[key] | 返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError。 |
d[key] = value |
将 d[key] 设为 value。 |
del d[key] |
将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。 |
key in d |
如果 d 中存在键 key 则返回 True，否则返回 False。 |
key not in d |
等价于 not key in d。 |
iter(d) |
返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。 |
clear() |
移除字典中的所有元素。 |
copy() |
返回原字典的浅拷贝。 |
d | other |
合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。 |
d |= other |
用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。 |