数据类型 python3.8 官网 (opens new window)

逻辑值检测

# 逻辑值检测，任何对象都可以进行逻辑值的检测，以便在 if 或 while 作为条件或是作为下文所述布尔运算的操作数来使用。
# 下面是会被视为假值的内置对象
# 被定义为假值的常量: None 和 False。
# 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
# 空的序列和多项集: '', (), [], {}, set(), range(0)

布尔运算

# 布尔运算 and  or  not , 优先级 not > and > or 在不清楚优先级的时候最好使用括号, and和or都是短路运算符，满足第一个值为真值就不继续往后走了。
# 0可以使用False ， 1可以使用True
print(not 0 or 1)  # True , 这里先执行了 not 0,得到True 然后 True or 1 ，True已经是真值直接返回
print(not (0 or 1))  # False , 0 or 1 返回 1 ， not 1 返回False
print(not 1 or 0)  # 0, not 1 得到 False ， False or 0 返回0

比较运算

# 比较运算，优先级都相同（比较运算比布尔运算的优先级高）
# 比较运算可以任意串连；例如，x < y <= z 等价于 x < y and y <= z，前者的不同之处在于 y 只被求值一次（但在两种情况下当 x < y 结果为假值时 z 都不会被求值）
# <：严格小于
# <=：小于或等于
# >：严格大于
# >=：大于或等于
# ==：等于，判断值是否相等
# !=：不等于，判断值是否不等
# is：对象标识，判断是否是同一对象
# is not：否顶的对象标识符，判断是否不是同一对象

运算

# 数字类型 --- int：整数, float：浮点数, complex：复数
# 所有数字类型（复数除外）都支持下列运算
# x + y 求和
# x - y 求差
# x * y 求乘积
# x / y  x除以y，返回浮点数
print(2 / 1)  # 2.0
# x // y   整除，运算结果总是向负无穷的方向舍入
print(1 // 2)  # 0
print(4 // 3)  # 1
print(-1 // 2)  # -1
print(-4 // 3)  # -2
# x % y  取余
print(2 % 3)  # 2
# -x  取反
# +x  不变
# abs(x)  绝对值
# int(x)  将x转换为整数
# float(x)  将x装换为浮点数
# complex(re, im)  一个带有实部re和虚部im的复数，im默认为0，复数目前我没用过
# pow(x, y)  x的y次幂 ，python将 pow(0,0) 和 0**0 定义为1，这是编程语言的普遍做法
# x ** y     x的y次幂
import math

print(math.trunc(3.23), math.trunc(3.56))  # 3 3 截断为整数
print(round(3.655, 2))  # 3.65  注意在有小数位的时候，半数会被忽略
print(round(3.5))  # 4
print(math.floor(3.6))  # 3  向下取整
print(math.ceil(3.2))  # 4  向上取整

位运算符

# 按位运算符 |  ^  &  <<   >>   -
print(3 | 12)  # 15 ，根据二进制数 0011 | 1100  得到 1111 ，或运算  两个为0时才为0
print(3 ^ 12)  # 15 ， 0011 ^ 1100  得到 1111 ， 亦或运算  两个不相同时才为1
print(3 & 12)  # 0 ，0011 & 1100  得到 0000 ，与运算  两个都为1时才为1
print(3 >> 2)  # 0, 0011 >> 2  得到  0000 ，向右移
print(3 << 2)  # 12, 0011 << 2  得到  1100 ，向左移

迭代器

# 迭代器类型
# 容器对象要提供迭代支持，必须定义一个方法:
# container.__iter__()  返回一个迭代器对象。 该对象需要支持下文所述的迭代器协议。

# 迭代器对象自身需要支持以下两个方法，它们共同组成了 迭代器协议:
# iterator.__iter__()  返回迭代器对象本身。 这是同时允许容器和迭代器配合 for 和 in 语句使用所必须的。
# iterator.__next__()  从容器中返回下一项。 如果已经没有项可返回，则会引发 StopIteration 异常。
# 一旦迭代器的 __next__() 方法引发了 StopIteration，它必须一直对后续调用引发同样的异常。不遵循此行为特性的实现将无法正常使用。

# 生成器类型（使用yield实现）,生成器是一个特殊的迭代器
# Python 的 generator 提供了一种实现迭代器协议的便捷方式。如果容器对象 __iter__() 方法被实现为一个生成器，
# 它将自动返回一个迭代器对象（从技术上说是一个生成器对象），该对象提供 __iter__() 和 __next__() 方法。

序列类型

# 序列类型  list：列表, tuple：元组, range：一般用来快速生成一个列表
# ------ 大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。 collections.abc.Sequence ABC 被提供用来更容易地在自定义序列类型上正确地实现这些操作。
# 一般序列运算
print([1, 3, 10, 3].count(3))  # 2  元素3在列表中出现的次数
print(2 in range(10))  # True    判断元素在列表中，不在返回False   range返回一个有规律的迭代器
print(2 not in [1, 2, 3, 4, 5])  # False    判断元素不在列表中，存在返回False
print(list(range(3)) + [99])  # [0, 1, 2, 99]   两个列表相加返回一个新的列表，注意内存的消耗，可以使用其他优化的方式
print(''.join([str(i) for i in range(10)]))  # 0123456789      字符串列表拼接为字符串，注意列表里面必须是字符串
print(','.join([str(i) for i in range(10)]))  # 0,1,2,3,4,5,6,7,8,9
print(list(range(3)) * 3)  # [0, 1, 2, 0, 1, 2, 0, 1, 2]   列表重复多次，不常用
print(range(10)[5])  # 5   取值，下标从0开始
# 切片
print(list(range(10))[:3], list(range(10))[-3:])  # [0, 1, 2]  [7, 8, 9]
print(list(range(10))[1:9:2])  # [1, 3, 5, 7]   切片，从下标1到下标8中间隔开两位（步长为2，默认步长为1）
print(len(range(10)))  # 10  获取列表或迭代器长度
print(min(range(10)), max(range(10)))  # 0 9   获取列表或迭代器最小值和最大值
print(list(range(10)).index(3))  # 3,  索引首次出现的下标,如果
# list(range(10)).index(3, 4, 9)  这里表示从下标4(默认为0)开始找，找到下标为8(默认到最后一个)结束  如果不存在会抛出异常  ValueError: 3 is not in list
# 列表取值一般是前闭后开(含头不含尾)


# ------可变序列(list，dict，set)常见使用，collections.abc.MutableSequence ABC 被提供用来更容易地在自定义序列类型上正确实现这些操作
# 可变序列运算
tmp_list = list(range(10))
print(tmp_list)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

tmp_list[3] = 100  # 单个值替换
print(tmp_list)  # [0, 1, 2, 100, 4, 5, 6, 7, 8, 9]
tmp_list[5:7] = [11, 12, 13, 14, 15]  # 切片替换
print(tmp_list)  # [0, 1, 2, 100, 4, 11, 12, 13, 14, 15, 7, 8, 9]
tmp_list[2:10:2] = [1, 2, 3, 4]  # 注意需要替换的个数（不常用）
print(tmp_list)  # [0, 1, 1, 100, 2, 11, 3, 13, 4, 15, 7, 8, 9]

del tmp_list[5:7]  # 删除切片元素   等同于  tmp_list[5:7] = []
print(tmp_list)  # [0, 1, 1, 100, 2, 13, 4, 15, 7, 8, 9]
del tmp_list[2:6:2]  # 按步长删除元素，默认步长为1
print(tmp_list)  # [0, 1, 100, 13, 4, 15, 7, 8, 9]

tmp_list.append([1, 2, 3])  # 末尾添加
print(tmp_list)  # [0, 1, 100, 13, 4, 15, 7, 8, 9, [1, 2, 3]]

# 其第一层，是实现了深拷贝，但对于其内嵌套的List(不止List,所有可变类型)，仍然是浅拷贝。等同于 tmp_list1 = tmp_list[:]
tmp_list1 = tmp_list.copy()
tmp_list1[2] = 10000  # 此时只会修改tmp_list1
tmp_list1[-1][2] = 10000  # 此时修改列表中的列表，两个列表的值都会改变
# [0, 1, 10000, 13, 4, 15, 7, 8, 9, [1, 2, 10000]] [0, 1, 100, 13, 4, 15, 7, 8, 9, [1, 2, 10000]]
print(tmp_list1, tmp_list)
tmp_list1.clear()  # 移除所有项  等同于  del tmp_list1[:]
print(tmp_list1, tmp_list)  # [] [0, 1, 100, 13, 4, 15, 7, 8, 9, [1, 2, 10000]]
tmp_list.extend([97, 98])  # 等同于 tmp_list += [97, 98]  等同于 tmp_list[len(tmp_list):len(tmp_list)] = [97,98]
print(tmp_list)  # [0, 1, 100, 13, 4, 15, 7, 8, 9, [1, 2, 10000], 97, 98]
tmp_list.insert(3, 111)  # 在下标处插入数据， 等同于 tmp_list[3:3] = [111]
print(tmp_list)  # [0, 1, 100, 111, 13, 4, 15, 7, 8, 9, [1, 2, 10000], 97, 98]

tmp_list.pop()  # 移除最后一项，按下标删除
print(tmp_list)  # [0, 1, 100, 111, 13, 4, 15, 7, 8, 9, [1, 2, 10000], 97]
tmp_list.pop(3)  # 移除指定下标
print(tmp_list)  # [0, 1, 100, 13, 4, 15, 7, 8, 9, [1, 2, 10000], 97]

tmp_list.remove(1)  # 删除列表中第一个为1的值，按值删除
print(tmp_list)  # [0, 100, 13, 4, 15, 7, 8, 9, [1, 2, 10000], 97]

tmp_list.reverse()  # 倒序
print(tmp_list)  # [97, [1, 2, 10000], 9, 8, 7, 15, 4, 13, 100, 0]

# ------不可变序列，可以被hash，可以用来当做字典的key
print(hash(tuple()))  # 5740354900026072187 , 不同系统可能hash值不同
# print(hash(list()))  # TypeError: unhashable type: 'list'    不可被hash使用hash会抛出异常
print(hash(str()))
print(hash(int()))
print(hash(float()))
print(hash(range(5)))
print(hash(bool()))
print(hash(bytes()))
# ********* 不可变类型有(可被hash)：tuple：元组、str：字符串、int：整数、float：浮点数、range、bool:布尔、bytes：字节、frozenset  等
# ********* 可变类型有(不可以被hash)：list：列表、dict：字典、set：集合、bytearray

列表

# 列表，列表是可变序列，通常用于存放同类项目的集合（其中精确的相似程度将根据应用而变化）。
# 列表实现了所有 一般 和 可变 序列的操作
# 列表排序(额外方法)
tmp_list = [3, 1, 2, 10, 5]
tmp_list.sort()  # 默认升序    tmp_list.sort(reverse=True) 降序
print(tmp_list)  # [1, 2, 3, 5, 10]
# 可变序列的所有操作都可用在列表上

元组

# 元组，元组是不可变序列，通常用于储存异构数据的多项集（例如由 enumerate() 内置函数所产生的二元组）
# 元组实现了所有 一般 序列的操作。
a = 1,  # 注意在编码时，如果加上逗号都会变成元组。有时候不注意加上逗号，可能会导致意想不到的结果！！！
print(a)  # (1,)
print((1, 2))  # (1, 2)

range

# range对象，range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。
# range 对象实现了 一般 序列的所有操作，但拼接和重复除外（这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式）。
# range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大
# （因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值）。
print(range(0, 10, 2))  # range(0, 10, 2)
print(range(10))  # range(0, 10)
print(range(0) == range(2, 1, 3))

文本序列类型

# 文本序列类型 --- str 字符串，字符串是由 Unicode 码位构成的 不可变 序列
# 字符串字面量有三种写法  '单引号可以包含"双引号"'  "双引号可以包含'单引号'"  '''三单引号'''  """三双引号"""三重引号可以跨行，包含所有空白字符
# 不存在可变的字符串类型，但是 str.join() 或 io.StringIO 可以被被用来根据多个片段高效率地构建字符串。
print(','.join([str(i) for i in range(10)]))  # 0,1,2,3,4,5,6,7,8,9
# 字符串实现了所有 一般 序列的操作，还额外提供了以下列出的一些附加方法。
# 常用的方法
print('abcda'.count('a'))  # 2 ， str.count(sub[, start[, end]])，a出现的次数
print('abc'.encode('utf-8'))  # b'abc'  str.encode(encoding="utf-8", errors="strict") 返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'
print('abc'.endswith('c'))  # True , str.endswith(suffix[, start[, end]])，判断是否以c结尾
print('abc'.startswith('a'))  # True , str.startswith(prefix[, start[, end]])，判断是否以a开头
print('abc'.find('b'))  # 1  ,str.find(sub[, start[, end]]),返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引
print('abca'.rfind('a'))  # 3 ,从右向左查找
print('abc'.index('b'))  # 1 , str.index(sub[, start[, end]])，类似于find，但在找不到子类时会引发 ValueError
print('abca'.rindex('a'))  # 3 ,从右向左查找
print('say {}, {}!'.format('hello', 'ok'))  # say hello, ok!  ，格式化，不带参数
print('say {a}, {b}!'.format(a='hello', b='ok'))  # say hello, ok!  ，格式化，带参数，a,b根据实际场景命令
print('abc1Dsaf'.isalnum())  # True ,如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False
print('afdAsda'.isalpha())  # True, 如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False
print('1234'.isdigit())  # True, 如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False
print('U2U'.isupper())  # True, 如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False
print('u2U'.islower())  # False, 如果字符串中至少有一个区分大小写的字符 4 且此类字符均为小写则返回 True ，否则返回 False
print('-'.join(['a', 'c', 'b']))  # a-c-b ，返回一个由 iterable 中的字符串拼接而成的字符串
print('Abcd'.lower())  # abcd , 返回原字符串的副本，其所有区分大小写的字符均转换为小写。
print('Abcd'.upper())  # ABCD , 返回原字符串的副本，其所有区分大小写的字符均转换为大写。
print('    abc    '.lstrip())  # 'abc    ' ，去除左边的空格
print('    abc    '.rstrip())  # '    abc' ，去除右边的空格
print('    abc    '.strip())  # 'abc' ，去除两边的空格
print('abcb'.replace('b', 'B'))  # aBcB ，str.replace(old, new[, count]) 替换字符，默认替换全部，可以选择替换的次数
print('a,,b,c'.split(','))  # ['a', '', 'b', 'c'] ，str.split(sep=None, maxsplit=-1) 分割，返回列表，默认分割所有
print('a,,b,c'.rsplit(',', 1))  # ['a,,b', 'c']
print('42'.zfill(5), '-1'.zfill(5))  # 00042 -0001 ,str.zfill(width)返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width

print('abc'.center(6, 'A'))  # AabcAA ,默认使用空格填充前后多余空位
print('abc'.capitalize())  # Abc  ,返回原字符串的副本，其首个字符大写，其余为小写。
print('AcBc'.casefold())  # acbc  ,返回原字符串消除大小写的副本, 和lower()有些许不同  具体细节参考官网

二进制序列类型

# 二进制序列类型 --- bytes, bytearray, memoryview
# 操作二进制数据的核心内置类型是 bytes 和 bytearray。 它们由 memoryview 提供支持，该对象使用 缓冲区协议 来访问其他二进制对象所在内存，不需要创建对象的副本。
# ------bytes
# bytes 对象是由单个字节构成的  不可变 序列。 由于许多主要二进制协议都基于 ASCII 文本编码，
# 因此 bytes 对象提供了一些仅在处理 ASCII 兼容数据时可用，并且在许多特性上与字符串对象紧密相关的方法。
# bytes 字面值中只允许 ASCII 字符（无论源代码声明的编码为何）。 任何超出 127 的二进制值必须使用相应的转义序列形式加入 bytes 字面值。
# bytes字面量有三种写法  b'单引号可以包含"双引号"'  b"双引号可以包含'单引号'"  b'''三单引号'''  b"""三双引号"""三重引号可以跨行，包含所有空白字符

# 由于两个十六进制数码精确对应一个字节，因此十六进制数是描述二进制数据的常用格式。 相应地，bytes 类型具有从此种格式读取数据的附加类方法：
print(bytes.fromhex('2E F1f2  '))  # b'.\xf1\xf2' ,3.7开始会忽略所有ASCII 空白符而不只是空格符
print(b'.\xf1\xf2'.hex())  # 2ef1f2 , 将 bytes 对象转换为对应的十六进制表示
print(b'.\xf1\xf2'.hex('-'))  # 2e-f1-f2

# ------bytearray
# 由于 bytearray 对象是 可变的 序列，该对象除了 bytes 和 bytearray 操作 中所描述的 bytes 和 bytearray 共有操作之外，还支持 可变 序列操作
print(bytearray(10))  # bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
print(bytearray.fromhex('2E F1f2  '))  # bytearray(b'.\xf1\xf2')
print(bytearray(b'.\xf1\xf2').hex('-'))  # 2e-f1-f2  ,3.8开始支持和bytes一样的可选的 sep 和 bytes_per_sep 参数

# 操作：bytes 和 bytearray 对象都支持 通用 序列操作, bytearray 还支持 可变 序列操作
# 它们不仅能与相同类型的操作数，也能与任何 bytes-like object 进行互操作
# bytes的很多方法跟字符串类似，在使用不清楚的请参考官方文档。
print('你'.encode('utf-8'))  # b'\xe4\xbd\xa0'
print(b'\xe4\xbd\xa0'.decode('utf-8'))  # 你

集合类型

# 集合类型 --- set, frozenset
# set 对象是由具有唯一性的 hashable 对象所组成的无序多项集。 常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。
# 与其他多项集一样，集合也支持 x in set, len(set) 和 for x in set。 作为一种无序的多项集，集合并不记录元素位置或插入顺序。
# 相应地，集合不支持索引、切片或其他序列类的操作。
# set 类型是可变的 --- 其内容可以使用 add() 和 remove() 这样的方法来改变。 由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素
# frozenset 类型是不可变并且为 hashable --- 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

# 创建集合的多种方式：
# 使用花括号内以逗号分隔元素的方式: {'jack', 'sjoerd'}
# 使用集合推导式: {c for c in 'abracadabra' if c not in 'abc'}
# 使用类型构造器: set(), set('foobar'), set(['a', 'b', 'foo'])
print({'a', 'b'}, type({'b', 'a'}))  # {'a', 'b'} <class 'set'>
print(frozenset({'a', 'b'}), type(frozenset({'a', 'b'})))  # frozenset({'b', 'a'}) <class 'frozenset'>

# 注意set是无序的，下面的结果顺序可能每次都不一样。
# set 和 frozenset 的实例提供以下操作：
tmp_set = {'a', 'b', 'c'}
print(len(tmp_set))  # 3 ,返回集合的元素数量
print('a' in tmp_set)  # True ,检查a是否为集合的成员
print('a' not in tmp_set)  # False ,检查a是否非集合的成员
print(tmp_set.isdisjoint({'d', 'e'}))  # True, 如果集合中没有与其共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。
print(tmp_set.issubset({'a', 'b', 'c', 'd'}))  # True, issubset(other) 检查tmp_set是否都在 other中
print(tmp_set.issuperset({'a', 'b'}))  # True, issuperset(other) 检查other是否都在 tmp_set中
print(tmp_set.union({'a', 'e'}, {'g', 'a'}))  # {'e', 'a', 'c', 'g', 'b'}, 返回一个新集合，包含所有集合的元素
print(tmp_set.intersection({'a', 'c', 'g'}, {'a', 'g'}))  # {'a'}, 返回一个新集合，包含所有集合 共有 的元素
print(tmp_set.difference({'a', 'c', 'g'}, {'a', 'd'}))  # {'b'}, 返回一个新集合，tmp_set有 但是其他集合都没有的元素
print(tmp_set.symmetric_difference({'a', 'c', 'g'}))  # {'b', 'g'}, 返回一个新集合，不同时存在两个集合中
tmp_set1 = tmp_set.copy()  # 浅拷贝
print(tmp_set1)  # {'a', 'b', 'c'}

# 下面是 可用于set  不能用于frozenset 的操作：
tmp_set.update({1, 2}, {'e'})  # update(*others), 更新集合，添加来自 others 中的所有元素。
print(tmp_set)  # {1, 2, 'a', 'b', 'c', 'e'}
tmp_set.intersection_update({'a', 'g', 'e'}, {'a', 'g'})  # intersection_update(*others) 更新集合，只保留其中在所有 others 中也存在的元素
print(tmp_set)  # {'a'}
tmp_set.difference_update({'a', 'd'}, {'e'})  # difference_update(*others) 更新集合，移除其中也存在于 others 中的元素
print(tmp_set)  # set()
tmp_set.symmetric_difference_update({'a', 'b', 'c'})  # symmetric_difference_update(other) 更新集合，只保留存在于集合的一方而非共同存在的元素
print(tmp_set)  # {'c', 'a', 'b'}  ,因为tmp_set为空，所以这里的结果跟other一样
tmp_set.add('d')  # 将元素添加在set中
print(tmp_set)  # {'c', 'd', 'a', 'b'}
tmp_set.remove('b')  # 移除元素，如果元素不存在会报错 KeyError
print(tmp_set)  # {'c', 'd', 'a'}
tmp_set.discard('b')  # 如果元素存在，则移除元素
tmp_set.discard('a')
print(tmp_set)  # {'c', 'd'}
print(tmp_set.pop())  # d  , 从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError。
print(tmp_set)  # {'c'}
tmp_set.clear()  # 从集合中移除所有元素。
print(tmp_set)  # set()

映射类型

# 映射类型 --- dict  字典
# 字典的键 所有 不可变 的都可作为键（即可hashable的值）（但是请注意，由于计算机对于浮点数存储的只是近似值，因此将其用作字典键是不明智的。）

# 创建字典的几种方式：
# 使用花括号内以逗号分隔 键: 值 对的方式: {'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)
tmp_dict = 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})
print(tmp_dict == b == c == d == e)  # True，所有结果都是{'one': 1, 'two': 2, 'three': 3}

# 字典所支持的操作（因而自定义的映射类型也应当支持）
print(list(tmp_dict))  # ['one', 'two', 'three'] , 返回字典的 key（键）
print(len(tmp_dict))  # 3， 返回字典的项数（长度）
print(tmp_dict['one'])  # 1， 返回对应 key 的 value（值），如果key不存在则会引发 KeyError
print(tmp_dict.get('four'))  # None， 返回对应 key 的 value（值），如果key不存在返回 None
print(tmp_dict.get('four', 'hello'))  # hello， 返回对应 key 的 value（值），如果key不存在返回 None 设置了默认值返回默认值
tmp_dict['one'] = 99  # 将 one 的值设置为 99
print(tmp_dict)  # {'one': 99, 'two': 2, 'three': 3}
del tmp_dict['one']  # 移除对应元素，如果映射中不存在 key 则会引发 KeyError
print(tmp_dict)  # {'two': 2, 'three': 3}
print('one' in tmp_dict)  # False ,判断key是否存在
print('one' not in tmp_dict)  # True，判断key是否不存在
print(iter(tmp_dict))  # 返回以字典的key为元素的迭代器。 这是 iter(tmp_dict.keys()) 的快捷方式。
tmp1_dict = tmp_dict.copy()  # 浅拷贝
print(tmp_dict.items())  # dict_items([('two', 2), ('three', 3)])， 返回由字典项 ((key, value) 对) 组成的一个新视图
print(tmp_dict.keys())  # dict_keys(['two', 'three'])， 返回由字典key组成的一个新视图
print(tmp_dict.values())  # dict_values([2, 'A', 4])，返回由字典 value 组成的一个新视图
# 如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError
print(tmp_dict.pop('one', 'hello'))  # hello
# 从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回，适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。 如果字典为空，调用 popitem() 将引发 KeyError
print(tmp_dict.popitem())  # ('three', 3)，
tmp_dict.update({'a': 'A'})  # 如果存在key更新tmp_dict的值，不存在则新增
print(tmp_dict)  # {'two': 2, 'a': 'A'}
print(reversed(tmp_dict))  # 返回一个逆序获取字典 key 的迭代器。 这是 reversed(d.keys()) 的快捷方式
print(tmp_dict.setdefault('four', 4))  # 4，如果字典存在key，返回它的value。如果不存在，插入值为 default 的键 key ，并返回 default 。default默认为 None。
print(tmp_dict)  # {'two': 2, 'a': 'A', 'four': 4}
tmp1_dict.clear()  # 移除字典中的所有元素
print(tmp_list1)  # []
# 在 3.7 版更改: 字典顺序会确保为插入顺序。 此行为是自 3.6 版开始的 CPython 实现细节
# 在 3.8 版更改: 字典现在是可逆的，字典和字典视图都是可逆的

# ------字典视图对象
# 由 dict.keys(), dict.values() 和 dict.items() 所返回的对象是 视图对象。 该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。
# 字典视图可以被迭代以产生与其对应的数据，并支持成员检测
tmp_dict_view = tmp_dict.items()
print(len(tmp_dict_view))  # 3，返回字典视图的数量
print(iter(tmp_dict_view))  # 返回字典视图的迭代器
print(('a', 'A') in tmp_dict_view)  # True， 存在的键、值或项（在最后一种情况下 应为一个 (键, 值) 元组） 则返回 True
print(reversed(tmp_dict_view))  # 返回一个逆序获取字典键、值或项的迭代器。 视图将按与插入时相反的顺序进行迭代
for k, v in tmp_dict_view:  # 遍历键值对
    print(k, v)

上下文管理器类型

案例参考

# 上下文管理器类型
# Python 的 with 语句支持通过上下文管理器所定义的运行时上下文这一概念。
# 此对象的实现使用了一对专门方法，允许用户自定义类来定义运行时上下文，在语句体被执行前进入该上下文，并在语句执行完毕时退出该上下文

其他内置类型

# 模块 ，可以通过 import datetime 或 from datetime import datetime 引入模块
# 类与类实例 ，class 定义类
# 函数 ，def 定义的就是函数
# 方法 ，类中定义的函数叫做方法
# 代码对象
# 类型对象  type，获取对应的类型
# 空对象 ，None
# 省略符对象  ， 该对象的写法为 Ellipsis 或 ...
# 未实现对象
# 布尔值  ，True 或 False
# 内部对象