Python 类型概览

变量基本要素

分别是 id，type，value。其中 id 为身份标识，即唯一能识别变量的标志，type 为数据类型，value 为数据值。

== 主要用于判断两个对象的 value 是否相等，属于 Python 标准操作符中的比较运算符。

is 同一性运算符 is 主要用来判断两个对象的身份标识，即两者的基本要素 “id”，也叫做同一性运算符。

数据类型	构造函数	示例代码
列表 (List)	list()	my_list = list() 创建空列表 my_list = list([1, 2, 3]) 创建包含整数的列表
字典 (Dictionary)	dict()	my_dict = dict() 创建空字典 my_dict = dict(key1='value1', key2='value2') 创建包含键值对的字典
集合 (Set)	set()	my_set = set() 创建空集合 my_set = set([1, 2, 3]) 创建包含整数的集合
元组 (Tuple)	tuple()	my_tuple = tuple() 创建空元组 my_tuple = tuple('abc') 创建包含字符串字符的元组
字符串 (String)	str()	my_str = str() 创建空字符串 my_str = str(123) 将整数转换为字符串
整数 (Integer)	int()	my_int = int() 创建整数 0 my_int = int('123') 将字符串转换为整数
浮点数 (Float)	float()	my_float = float() 创建浮点数 0.0 my_float = float('123.45') 将字符串转换为浮点数
布尔值 (Boolean)	bool()	my_bool = bool() 创建布尔值 False my_bool = bool([1, 2, 3]) 空集合为 False，非空集合为 True

术语/特性	解释
可变性 (Mutability)	- 不可变类型：对象的内容在其生命周期内不能被改变。 - 可变类型：对象的内容可以被修改。
有序性 (Order)	- 有序类型：元素保持特定的顺序，可以通过索引访问。 - 无序类型：元素顺序不固定，通常不通过索引访问。
索引 (Indexing)	指能够通过数字索引来访问序列中的元素的能力。
迭代 (Iteration)	指能够按顺序访问容器中的所有元素的过程。
元素重复性 (Repeatability)	指容器是否允许存储重复的元素。
元素类型 (Element Type)	指容器可以存储的数据类型。

无序意味着容器中的元素不保证保持它们被添加的顺序。换句话说，元素的顺序对于你来说是不可预测的，每次你查看容器时元素的顺序可能会不同。

# 创建一个集合
my_set = {1, 2, 3}

# 集合中的元素是无序的
print(my_set)  # 可能的输出: {1, 2, 3}，但顺序不是固定的

# 每次打印集合，元素的顺序可能会不同
print(my_set)  # 可能的输出: {2, 3, 1}

特性/数据结构	字符串 (String)	列表 (List)	元组 (Tuple)	集合 (Set)	字典 (Dict)
可变性	不可变	可变	不可变	可变	可变
有序性	有序	有序	有序	无序（Python 3.6 之前） 有序（Python 3.7+）	有序 (Python 3.7+)
索引	支持	支持	支持	不支持	通过键支持
迭代	支持	支持	支持	支持	支持
元素重复性	支持	支持	支持	不支持	键不支持
元素类型	单一（字符）	多样	多样	多样	多样
主要用途	存储文本	存储序列	保护数据	快速查找	存储映射关系
内存大小	较小	较大	中等	中等	较大
对应的抽象数据结构	-	可用作栈、队列	可用作栈、队列	可用于实现无序集合	可用于实现映射和关联数组

转换源	转换目标	转换方法	详细代码示例
列表	元组	tuple()	my_list = [1, 2, 3] my_tuple = tuple(my_list)
列表	字符串	str()	my_list = ['a', 'b', 'c', 'd'] my_str = str(my_list) # 输出: "['a', 'b', 'c', 'd']"
列表	集合	set()	my_list = [1, 2, 2, 3] my_set = set(my_list) # 输出: {1, 2, 3}
列表	字典	索引或 enumerate()	my_list = ['a', 'b', 'c'] my_dict = {i: v for i, v in enumerate(my_list)} # 输出: {0: 'a', 1: 'b', 2: 'c'}
元组	列表	list()	my_tuple = (1, 2, 3) my_list = list(my_tuple)
元组	字符串	str()	my_tuple = ('a', 'b', 'c', 'd') my_str = str(my_tuple) # 输出: "(1, 2, 3)"
元组	集合	set()	my_tuple = (1, 2, 2, 3) my_set = set(my_tuple) # 输出: {1, 2, 3}
元组	字典	enumerate()	my_tuple = ('a', 'b', 'c') my_dict = {i: v for i, v in enumerate(my_tuple)} # 输出: {0: 'a', 1: 'b', 2: 'c'}
字符串	列表	list()	my_str = "Hello" my_list = list(my_str) # 输出: ['H', 'e', 'l', 'l', 'o']
字符串	元组	tuple()	my_str = "Hello" my_tuple = tuple(my_str) # 输出: ('H', 'e', 'l', 'l', 'o')
字符串	集合	set()	my_str = "Hello" my_set = set(my_str) # 输出: {'H', 'e', 'l', 'o'}
字符串	字典	分割字符串	my_str = "key1=value1,key2=value2" my_dict = dict(item.split('=') for item in my_str.split(',')) # 输出: {'key1': 'value1', 'key2': 'value2'}
集合	列表	list()	my_set = {1, 2, 3} my_list = list(my_set) # 输出: [1, 2, 3]（顺序可能不同）
集合	元组	tuple()	my_set = {1, 2, 3} my_tuple = tuple(my_set) # 输出: (1, 2, 3)（顺序可能不同）
集合	字符串	str()	my_set = {1, 2, 3} my_str = str(my_set) # 输出: "{1, 2, 3}"
集合	字典	指定键值对	my_set = {'a', 'b', 'c'} my_dict = {v: True for v in my_set} # 输出: {'a': True, 'b': True, 'c': True}
字典	列表（键）	keys() 或 list()	my_dict = {'a': 1, 'b': 2} my_list_keys = list(my_dict.keys()) # 输出: ['a', 'b']
字典	列表（值）	values() 或 list()	my_dict = {'a': 1, 'b': 2} my_list_values = list(my_dict.values()) # 输出: [1, 2]
字典	元组（键）	keys() 或 tuple()	my_dict = {'a': 1, 'b': 2} my_tuple_keys = tuple(my_dict.keys()) # 输出: ('a', 'b')
字典	元组（值）	values() 或 tuple()	my_dict = {'a': 1, 'b': 2} my_tuple_values = tuple(my_dict.values()) # 输出: (1, 2)
字典	字符串	str()	my_dict = {'a': 1, 'b': 2} my_str = str(my_dict) # 输出: "{'a': 1, 'b': 2}"
字典	集合（键）	keys() 或 set()	my_dict = {'a': 1, 'b': 2} my_set_keys = set(my_dict.keys()) # 输出: {'a', 'b'}
字典	集合（值）	values() 或 set()	my_dict = {'a': 1, 'b': 2} my_set_values = set(my_dict.values()) # 输出: {1, 2}