python什么是元组？
python元组和序列的区别：
1、元组作为很多内置函数和序列类型方法的返回值存在，也就是说，在使用某些函数或者方法时，它的返回值是元组类型，因此你必须对元组进行处理。
2、元组比列表的访问和处理速度更快，因此，当需要对指定元素进行访问，且不涉及修改元素的操作时，建议使用元组。
3、元组可以在映射（和集合的成员）中当做“键”使用，而列表不行。
4、列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。
5、元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。
6、元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。
更多Python知识请关注Python视频教程栏目。
↑↑↑点击上方蓝字，回复资料，10个G的惊喜
作者：陈tooyoung@阿里云Python训练营 博客地址： https://blog.csdn.net/weixin_43509371/article/details/108522941
Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。
列表的定义
列表的创建
向列表中添加元素
删除列表中的元素
获取列表中的元素
列表的常用操作符
列表的其他方法
元组
创建和访问一个元组
更新和删除一个元组
元组相关的操作符
内置方法
解压元组
列表
简单数据类型
整型
浮点型
布尔型
容器数据类型
列表
元组
字典
集合
字符串
列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为[元素1, 元素2, ..., 元素n]。
关键点是「中括号 []」和「逗号 ,」
中括号 把所有元素绑在一起
逗号 将每个元素一一分开
列表的创建 创建一个普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x, type(x))# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]print(x, type(x))# [2, 3, 4, 5, 6, 7]利用range()创建列表x = list(range(10))print(x, type(x))# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))print(x, type(x))# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))print(x, type(x))# [10, 8, 6, 4, 2]利用推导式创建列表x = [0] * 5print(x, type(x))# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]print(x, type(x))# [0, 0, 0, 0, 0]
x = [i for i in range(10)]print(x, type(x))# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]print(x, type(x))# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]print(x, type(x))# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]print(x, type(x))# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
x = [[0] * 3] * 4print(x, type(x))# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1print(x, type(x))# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3x = [a] * 4print(x, type(x))# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1print(x, type(x))# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]创建一个混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]print(mix, type(mix))# [1, 'lsgo', 3.14, [1, 2, 3]]创建一个空列表empty = []print(empty, type(empty)) # []
列表不像元组，列表内容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、删除 (remove,pop) 这些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.append('Thursday')print(x)# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.append(['Thursday', 'Sunday'])print(x)# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.extend(['Thursday', 'Sunday'])print(x)# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
严格来说append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj)在编号index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.insert(2, 'Sunday')print(x)# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6删除列表中的元素
list.remove(obj)移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.remove('Monday')print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']y = x.pop()print(y) # Friday
y = x.pop(0)print(y) # Monday
y = x.pop(-2)print(y) # Wednesdayprint(x) # ['Tuesday', 'Thursday']
remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del var1[, var2 ……]删除单个或多个对象。
如果知道要删除的元素在列表中的位置，可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']del x[0:2]print(x) # ['Wednesday', 'Thursday', 'Friday']获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]print(x[0], type(x[0])) # Mondayprint(x[-1], type(x[-1])) # ['Thursday', 'Friday']print(x[-2], type(x[-2])) # Wednesday
切片的通用写法是start : stop : step
"start :"
以step为 1 (默认) 从编号start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x[3:]) # ['Thursday', 'Friday']print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']": stop"
以step为 1 (默认) 从列表头部往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']print(week[:-3]) # ['Monday', 'Tuesday']"start : stop"
以step为 1 (默认) 从编号start往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:3]) # ['Tuesday', 'Wednesday']print(week[-3:-1]) # ['Wednesday', 'Thursday']- "start : stop : step"
以具体的step从编号start往编号stop切片。注意最后把step设为 -1，相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:4:2]) # ['Tuesday', 'Thursday']print(week[:4:2]) # ['Monday', 'Wednesday']print(week[1::2]) # ['Tuesday', 'Thursday']print(week[::-1])# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']" : "
复制列表中的所有元素（浅拷贝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:])# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']浅拷贝与深拷贝list1 = [123, 456, 789, 213]list2 = list1list3 = list1[:]
print(list2) # [123, 456, 789, 213]print(list3) # [123, 456, 789, 213]list1.sort()print(list2) # [123, 213, 456, 789]print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]list2 = list1list3 = list1[:]print(list2) # [[123, 456], [789, 213]]print(list3) # [[123, 456], [789, 213]]list1[0][0] = 111print(list2) # [[111, 456], [789, 213]]print(list3) # [[111, 456], [789, 213]]列表的常用操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
list1 = [123, 456]list2 = [456, 123]list3 = [123, 456]
print(list1 == list2) # Falseprint(list1 == list3) # True
list4 = list1 + list2 # extend()print(list4) # [123, 456, 456, 123]
list5 = list3 * 3print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # Trueprint(456 not in list3) # False
前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
列表的其它方法
list.count(obj)统计某个元素在列表中出现的次数
list1 = [123, 456] * 3print(list1) # [123, 456, 123, 456, 123, 456]num = list1.count(123)print(num) # 3
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5print(list1.index(123)) # 0print(list1.index(123, 1)) # 2print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]x.reverse()print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)对原列表进行排序。
key-- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse-- 排序规则，reverse = True降序，reverse = False升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。
x = [123, 456, 789, 213]x.sort()print(x)# [123, 213, 456, 789]
x.sort(reverse=True)print(x)# [789, 456, 213, 123]
# 获取列表的第二个元素def takeSecond(elem):return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]x.sort(key=takeSecond)print(x)# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])print(x)# [(1, 3), (2, 2), (3, 4), (4, 1)]元组
「元组」定义语法为：(元素1, 元素2, ..., 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开
创建和访问一个元组
Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')t2 = 1, 10.31, 'python'print(t1, type(t1))# (1, 10.31, 'python')
print(t2, type(t2))# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)print(tuple1[1]) # 2print(tuple1[5:]) # (6, 7, 8)print(tuple1[:5]) # (1, 2, 3, 4, 5)tuple2 = tuple1[:]print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)print(type(x)) #x = 2, 3, 4, 5print(type(x)) #x = []print(type(x)) #x = ()print(type(x)) #x = (1,)print(type(x)) #print(8 * (8)) # 64print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
创建二维元组。
x = (1, 10.31, 'python'), ('data', 11)print(x)# ((1, 10.31, 'python'), ('data', 11))
print(x[0])# (1, 10.31, 'python')print(x[0][0], x[0][1], x[0][2])# 1 10.31 python
print(x[0][0:2])# (1, 10.31)更新和删除一个元组week = ('Monday', 'Tuesday', 'Thursday', 'Friday')week = week[:2] + ('Wednesday',) + week[2:]print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9print(t1) # (1, 2, 3, [9, 5, 6])元组相关的操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t1 = (123, 456)t2 = (456, 123)t3 = (123, 456)
print(t1 == t2) # Falseprint(t1 == t3) # True
t4 = t1 + t2print(t4) # (123, 456, 456, 123)
t5 = t3 * 3print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # Trueprint(456 not in t3) # False内置方法
元组大小和内容都不可更改，因此只有count和index两种方法。
t = (1, 10.31, 'python')print(t.count('python')) # 1print(t.index(10.31)) # 1
count('python')是记录在元组t中该元素出现几次，显然是 1 次
index(10.31)是找到该元素在元组t的索引，显然是 1
解压元组
解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')(a, b, c) = tprint(a, b, c)# 1 10.31 python
解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))(a, b, (c, d)) = tprint(a, b, c, d)# 1 10.31 OK python
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest变量。
t = 1, 2, 3, 4, 5a, b, *rest, c = tprint(a, b, c) # 1 2 5print(rest) # [3, 4]
如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。
t = 1, 2, 3, 4, 5a, b, *_ = tprint(a, b) # 1 2
匹配括号中包含的项目序列 。
元组简单的理解就是将一堆数据存放到一个容器中，但这个容器有一个特点，就是很固执，一旦定义了之后就不可改变，从某种意义上来说元组就是不可以改变的列表，功能和列表类似，同样可以进行切片、修改等操作。
元组的定义和列表类似，在括号中添加元素，元素之间使用逗号隔开，值得注意的是如果元组中只有一个元素的话，需要在元素的后面加上一个逗号。
如果元组只有一个元素不加逗号话，那么python
并不会认为它是一个元组，这个需要注意一下。元组和列表一样也是可以嵌套的，通过嵌套你可以定义一个二维元组或者多维元组。
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号定义，列表使用方括号定义。
例如：
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
元组与列表类似，下标索引从0开始，使用下标来访问数据。但元祖中，元素值是不允许修改的。
元组可理解为一组不可修改的有序序列，用圆括号表示，如：(2,7,0)
Python进阶——什么是元类?
总结来说，元类是Python中控制类创建过程的关键，它允许开发者在类创建时进行定制，是实现复杂类功能的有效工具。深入理解元类，将有助于提高代码的灵活性和可扩展性。
python中的元类是什么,它们用于什么?
元类是类的类。类定义类的实例（即对象）的行为，而元类定义类的行为。类是元类的实例。虽然在Python中你可以对元类使用任意可调用对象（例如Jerub演示），但是更好的方法是使其成为实际的类。type是Python中常见的元类。type它本身是一个类，并且是它自己的类型。你将无法type纯粹使用Python 重新创...
python中的元类是什么,它们用于什么?
1、元类就是创建类的类，通过元类可以在创建类的时候动态地修改类，比如新增方法或属性，从而实现在具体类实例中使用这些方法或属性。2、类是与某个层[1]的对象的最具体的类型。类还可以有运行时表示形式（元对象），它为操作与类相关的元数据提供了运行时支持。支持类的编程语言在支持与类相关的各...
Python进阶——详解元类,metaclass的原理和用法
元类可以看作是Python中的类的“类”，它允许我们自定义类的创建过程。与动态使用`type`创建类时相似，元类通过`__new__`方法实现，但形式上有所区别。我们通过一个例子来演示，创建了一个名为`AddInfo`的元类，它继承自`type`，并在`__new__`方法中处理类创建时的参数。当我们创建类`Test`...
Python元类源码分析
元类的应用主要体现在以下几个方面：创建类的途径：通常，我们可以通过两种方式创建类：一是继承自内置的object，二是直接利用Type类。理解这两个基础操作有助于深入元类的工作原理。Type在类创建过程中的角色：它是Python内置的类类型，用于实例化新的类。通过自定义metaclass（元类实例），我们可以定制类...
python的元组和列表的区别
元组是Scala语言中非常有用的容器对象。元组非常类似于列表，但是元组是不可变的。列表控件可以在四种不同的视图中显示项目，而元组适用于许多场景。List list是一种处理有序项目集的数据结构，也就是说，您可以在一个列表中存储一系列项目。列表中的项目应该用方括号括起来，这样python就知道您在指示一个...
元编程:Python 里的 metaclass 介绍
理解 metaclass 的关键在于认识到它们是用于创建类的工厂。在 Python 2 中，你可以通过类定义中的 `__metaclass__` 属性来指派创建类的特定类。这会改变类对象的创建方式，使得类能够基于特定的元类来生成。在 Python 3 中，这个特性被简化，元类的使用变得更加直接，但仍然允许我们控制类的创建和结构...
tuple在python中的含义
Python中的tuple表示元组，是一种不可变序列类型。接下来对tuple进行 1. 基本定义：tuple是Python中的一种基本数据类型，用于表示一系列有序且不可更改的元素集合。与列表不同，元组中的元素一旦组合在一起，就不能进行修改。2. 不可变性：tuple的不可变性意味着一旦创建了一个tuple，就不能添加、删除...
python 列表和元组的区别
元组是Scala语言中非常有用的容器对象。元组非常类似于列表，但是元组是不可变的。列表控件可以在四种不同的视图中显示项目，而元组适用于许多场景。List list是一种处理有序项目集的数据结构，也就是说，您可以在一个列表中存储一系列项目。列表中的项目应该用方括号括起来，这样python就知道您在指示一个...
python入门要学些什么东西?
7、什么是Python装饰器?用来装饰一个函数从而使这个函数在不修改本身的函数定义外，动态产生额外的功能;装饰函数的入参为需要被装饰的函数。装饰器本质上是一个返回函数的高阶函数一个Python装饰器是我们在符合Python语法的同时又方便地对函数做的一些特定的修改。8、列表、元组、集合、字典的区别是什么?...
鄞治曲安： 序列包括:列表、元组、字符串 列表:是最常用的数组,可以进行嵌套; 元组:相当于Enum,一旦创建,元组的值是不允许修改的; 字符串:顾名思义就是中英文字符以及标点符号等. 索引:序列中的每个元素被分配一个序号.注意索引默认从0开始.
会理县17376277581： Python 中列表和元组有哪些区别 - ？
鄞治曲安： 列表中的项目应该包括在方括号中, 你可以添加、删除或是搜索列表中的项目. 由于你可以增加或删除项目,所以列表是可变的数据类型, 即这种类型是可以被改变的.元组和列表十分类似,但是元组是不可变的. 也就是说你不能修改元组. 元组通过圆括号中用逗号分割的项目定义. 元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候, 即被使用的元组的值不会改变.
会理县17376277581： python 元组和列表的区别 - ？
鄞治曲安： 1、不可变和可变 元组是不可变对象,对象一旦生成,它的值将不能更改;列表是可变对象,对象生成后,可以对其元素进行更改、添加、删除、清空、排序等操作.2、可哈希和不可哈希 可哈希对象就是能映射成内存地址的对象.在Python基本数据类型中,只有列表、字典和可变集合是不可哈希的.说元组是可哈希也不对,如果元组中某个元素是列表、字典或可变集合,那么这个元组也是不可哈希的.可哈希对象和不可哈希对象的区别体现在:可哈希对象可以作为字典的键和集合的元素,不可哈希对象则不可以.
会理县17376277581： python什么是不可变序列 - ？
鄞治曲安： 即元组, 是用圆括号括起来的. 用逗号分隔一些值,自动创建了元组 >>>1, 2, 3 (1, 2, 3) 空元组 >>>() () 包含一个值的元组,必须加逗号 >>>33 33 >>>(33) 33 >>>33, (33,) tuple函数 与list函数基本上一样:以一个序列作为参数并把它转换为...
会理县17376277581： python 中 元组如何定义? - ？
鄞治曲安： 不是,(c_double *nr)classifier)应该是一个函数.
会理县17376277581： tcp ip协议报文的三元组是哪几个? - ？
鄞治曲安： 元组类型Python的元组与列表类似,不同之处在于元组的元素不能修改,元组使用小... 源IP地址源端口目的IP地址目的端口传输层协议例
会理县17376277581： python中数组,列表和元组的区别 - ？
鄞治曲安： 确切的说,python没有数组,与之对应的是list[]和元组() 元组是不能改变长度的list
会理县17376277581： Python3的元组,字典,列表,集合有什么联系和区别? - ？
鄞治曲安： 4个都是python的数据结构. 元组和列表的底层实现是一样的,本质都是把一堆东西放在一排,区别在于元祖放完后就不能改了. 你把字典理解成我们普通用的字典就可以了,而集合就是把字典的所有value都设置成None.字典和集合的底层实...
会理县17376277581： python3 tuple是无序还是有序 - ？
鄞治曲安： tuple是另一种有序的列表,中文翻译为“ 元组 ”.tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了.>>> t = ('Adam', 'Lisa', 'Bart') 创建tuple和创建list唯一不同之处是用( )替代了[ ].
会理县17376277581： 在python中自带的高级类型,set list 元组 字典有什么区别 - ？
鄞治曲安： 在列表和元组之间 列表是可变的 而元组是不可变的 这是二者唯一的差别字典 就是键值对set 就是无序的集合 列表和元组都是有序的set 中的元素不可以重复 列表和元组则没有这个要求另外 这四种数据结构 属于符合数据类型 并不属于高级类型 高级类型指的是 Collection Array Heapq Bisect 等等
