【编程语言】Python|【Python系列3】列表、元素、字典和集合＜2万字整理＞建议收藏！！！ pycharm|算法|python

列表、元组、字典和集合

- 序列
- - 检查元素是否包含在序列中
  - 和序列相关的内置函数
- list 列表
- - 创建列表
  - 访问列表元素
  - 删除列表
  - 列表添加元素
  - 列表删除元素
  - 列表修改元素
  - 列表查找元素
- tuple元组
- - 创建元组
  - 访问元组
  - 修改元祖
  - 删除元组
- dict 字典
- - 创建字典
  - 访问字典
  - 删除字典
  - 字典添加键值对
  - 字典修改键值对
  - 字典删除键值对
  - 判断字典中是否存在指定键值对
  - dict 字典方法完全攻略
  - keys()、values() 和 items() 方法
  - copy() 方法
  - `update()`方法
  - `pop()`和`popitem()`方法
  - 对 popitem() 的说明
  - `setdefault()`方法
- set集合
- - 创建set集合
  - 访问set集合元素
  - 删除set集合
  - set集合基本操作
  - 1. 向set集合添加元素
  - 2. 从set集合中删除元素
  - 3. set集合做交集、并集、差集运算
  - set集合方法全
- frozenset集合（set集合的不可变版）

序列序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

序列索引
- 正索引值：从起始元素开始，索引值从 0 开始递增
  
  文章图片
- 负索引值：Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始
  
  文章图片

在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。
【示例】
? 我爱派森
正：0 1 2 3
负：-4 -3 -2 -1

str="我爱派森" print(str[0],"==",str[-4]) //运行结果我 == 我

序列切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
序列实现切片操作的语法格式

sname[start: end: step]

sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；左闭右开
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。根据我的测试，每次跳的个数时step-1

str = "123456789" # 取索引区间[0,2)之间字符串 print(str[:2]) # 隔1个字符取1个字符，区间是整个字符串 print(str[::2]) # 取整个字符串，此时[]中只1个冒号 print(str[:])

运行结果

12 13579 123456789

序列相加

Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。

序列相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。

str = "apple" print(str*3)

输出

appleappleapple

检查元素是否包含在序列中

in关键字

语法格式：

value in sequence

value 表示要检查的元素，sequence 表示指定的序列。

not in关键字

和序列相关的内置函数

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

list 列表 Python中没有数组，但是加入了更加强大的列表。如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。
从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔

[element1, element2, element3, ..., elementn]

格式中，element1 ~ elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。
从内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。（通常情况下不这么做）

["http://c.biancheng.net/python/", 1, [2,3,4] , 3.0]

创建列表

使用[]直接创建链表
- 使用[ ]创建列表后，一般使用=将它赋值给某个变量

listname = [element1 , element2 , element3 , ... , elementn]

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。
列表元素可以有多个，也可以一个都没有

emptylist = []

使用list()函数创建列表

除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。

# 将字符串转换成列表 list1 = list("hello") print(list1)# 将元组转化成列表 tuple1 = ('python', 'c++', 'java') list2 = list(tuple1) print(list2)# 将字典转换成列表 dict1 = { 'a':100, 'b':42, 'c':8} list3 = list(dict1) print(list3)# 将区间转换成列表 range1 = range(1, 6) list4 = list(range1) print(list4)# 创建空列表 print(list())

访问列表元素

使用索引访问列表中的某1个元素

listname[i]

listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

使用切片访问列表中的一组元素（得到一个新的子列表）

listname[start : end : step]

listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。
删除列表
del关键字进行删除
实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。
语法格式

del listname

其中，listname 表示要删除列表的名称。
【删除示例】

intlist = [1, 45, 8, 34] print(intlist) del intlist print(intlist)

运行结果

[1, 45, 8, 34] Traceback (most recent call last): File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in print(intlist) NameError: name 'intlist' is not defined

列表添加元素

使用+拼接列表

demo

language = ["Python", "C++", "Java"] birthday = [1991, 1998, 1995] info = language + birthday print("language =", language) print("birthday =", birthday) print("info =", info)

运行结果

language = ['Python', 'C++', 'Java'] birthday = [1991, 1998, 1995] info = ['Python', 'C++', 'Java', 1991, 1998, 1995]

** append()方法添加列表**

在列表末尾追加元素

listname.append(obj)

listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

** extend()添加元素**

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

listname.extend(obj)

** insert()插入元素**

append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。

listname.insert(index , obj)

index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。
当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
列表删除元素

del：根据索引值删除元素
- 删除列表中的单个元素 del listname[index]
- 删除中间一段连续的元素 del listname[start : end]，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。
pop()：根据索引值删除元素
listname.pop(index)，如果不写 index 参数，默认会删除列表中的最后一个元素。
Python 并没有提供 push() 方法，因为完全可以使用 append()来代替 push() 的功能。
remove()：根据元素值进行删除
根据元素本身的值来进行删除操作，需要注意的是，remove()方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
clear()：删除列表所有元素
clear() 用来删除列表的所有元素，也即清空列表。

language = ["python", "cpp", "java"] language.clear()print(language)// 输出 []

列表修改元素

修改单个元素：直接对元素赋值

nums = [40, 36, 89, 2, 36, 100, 7] nums[2] = -26#使用正数索引 nums[-3] = -66.2#使用负数索引 print(nums)
修改一组元素：切片语法给一组元素赋值

nums = [40, 36, 89, 2, 36, 100, 7] #修改第 1~4 个元素的值（不包括第4个元素） nums[1: 4] = [45.25, -77, -52.5] print(nums)

列表查找元素

index()

listname.index(obj, start, end)

listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：
- start 和 end 可以都不写，此时会检索整个列表；
- 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
- 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。
index() 方法会返回元素所在列表中的索引值。
count()

listname.count(obj)

count() 方法用来统计某个元素在列表中出现的次数。
如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

tuple元组元组和列表（list）的不同之处在于：

列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔。

(element1, element2, ... , elementn)

从存储内容上看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同。

("c.biancheng.net", 1, [2,'a'], ("abc",3.0))

创建元组

()直接创建
在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。
使用tuple()函数创建元组，也可以把列表、字典、、、、转换为元组

tuple(data)

访问元组

tuplename[i]
tuplename[start : end : step]

修改元祖
元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。

对元组进行重新赋值
通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素

tup1 = tuple("hello") tup2 = tuple("world") print(tup1 + tup2)# 输出 ('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')

删除元组
del关键字

tup1 = tuple("hello") tup2 = tuple("world") print(tup1 + tup2) del tup1 print(tup1)# 输出 ('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd') Traceback (most recent call last): File "D:\桌面\py\main.py", line 5, in print(tup1) NameError: name 'tup1' is not defined

Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。
dict 字典字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。
字典类型是 Python 中唯一的映射类型。“映射”是数学中的术语，简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。

【编程语言】Python|【Python系列3】列表、元素、字典和集合＜2万字整理＞建议收藏！！！

文章图片

字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。
字典里的音节表就相当于字典类型中的键，而键对应的汉字则相当于值。
创建字典

使用{}创建字典

dictname = { 'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。
通过fromkeys方法创建

dictname = dict.fromkeys(list，value=https://www.it610.com/article/None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

l = ['math', 'english', 'science'] d = dict.fromkeys(l, 90) print(d)# {'math': 90, 'english': 90, 'science': 90}
通过dict()映射函数创建字典

创建格式	注意事项
a = dict(str1=value1, str2=value2, str3=value3)	str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。
#方式1 demo = [(‘two’,2), (‘one’,1), (‘three’,3)] #方式2 demo = [[‘two’,2], [‘one’,1], [‘three’,3]] #方式3 demo = ((‘two’,2), (‘one’,1), (‘three’,3)) #方式4 demo = ([‘two’,2], [‘one’,1], [‘three’,3]) a = dict(demo)	向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) )	通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。
访问字典
列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。

dictname[key]
更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。dictname.get(key[,default])其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。
demo1

a = dict(two=0.65, one=88, three=100, four=-59) print( a.get('five', '该键不存在') )

demo2

a = dict(two=0.65, one=88, three=100, four=-59) print( a.get('one') )

删除字典
del关键字

a = dict(two=0.65, one=88, three=100, four=-59) print(a) del a print(a)

Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。
字典是由一个一个的 key-value 构成的，key 是找到数据的关键，Python 对字典的操作都是通过 key 来完成的。
字典添加键值对
直接给不存在的 key 赋值即可
dictname[key] = value

dictname 表示字典名称。
key 表示新的键。
value 表示新的值，只要是 Python 支持的数据类型都可以。

a = { '数学': 98} print(a) a['音乐'] = 90 print(a) a['英语'] = 100 print(a)

结果

{ '数学': 98} { '数学': 98, '音乐': 90} { '数学': 98, '音乐': 90, '英语': 100}

字典修改键值对
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。
字典删除键值对
要删除字典中的键值对，还是可以使用 del 语句。

# 使用del语句删除键值对 a = { '数学': 95, '语文': 89, '英语': 90} del a['语文'] del a['数学'] print(a)

判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。
需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

a = { '数学': 98, '音乐': 90, '英语': 100} print('数学' in a) print('科学' in a) print('科学' not in a)''' True False True '''

通过 in（或 not in）运算符，我们可以很轻易地判断出现有字典中是否包含某个键，如果存在，由于通过键可以很轻易的获取对应的值，因此很容易就能判断出字典中是否有指定的键值对。
dict 字典方法完全攻略
可使用 dir(dict) 来查看该类型包含哪些方法，例如：

>>> dir(dict) ['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

keys()、values() 和 items() 方法

keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）。

a = { '数学': 98, '音乐': 90, '英语': 100} print(a.keys()) print(a.values()) print(a.items())''' dict_keys(['数学', '音乐', '英语']) dict_values([98, 90, 100]) dict_items([('数学', 98), ('音乐', 90), ('英语', 100)]) '''

可以发现，keys()、values() 和 items() 返回值的类型分别为 dict_keys、dict_values 和 dict_items。

使用 list() 函数，将它们返回的数据转换成列表

a = { '数学': 98, '音乐': 90, '英语': 100} b = list(a.keys()) c = list(a.values()) d = list(a.items()) print(b) print(c) print(d)''' ['数学', '音乐', '英语'] [98, 90, 100] [('数学', 98), ('音乐', 90), ('英语', 100)] '''

使用 for in 循环遍历它们的返回值

a = { '数学': 98, '音乐': 90, '英语': 100}for k in a.keys(): print(k, end=' ')print("\n--------------------")for v in a.values(): print(v, end=' ')print("\n--------------------")for k,v in a.items(): print("key:", k, ", value:", v)''' 数学音乐英语 -------------------- 98 90 100 -------------------- key: 数学 , value: 98 key: 音乐 , value: 90 key: 英语 , value: 100 '''

copy() 方法
copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典。

a = { 'one': 1, 'two': 2, 'three': [1,2,3]} b = a.copy() print(b)

注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。
拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []}；
而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。

字典遵循深拷贝
列表遵循浅拷贝

a = { 'one': 1, 'two': 2, 'three': [1,2,3]} b = a.copy()a['four'] = 4 print("a: ", a) print("b: ", b) print('--------------------------------') a['three'].remove(3) print("a: ", a) print("b: ", b)''' a:{'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 4} b:{'one': 1, 'two': 2, 'three': [1, 2, 3]} -------------------------------- a:{'one': 1, 'two': 2, 'three': [1, 2], 'four': 4} b:{'one': 1, 'two': 2, 'three': [1, 2]} '''

从运行结果不难看出，对 a 增加新键值对，b 不变；而修改 a 某键值对中列表内的元素，b也会相应改变。
update()方法
update() 方法可以使用一个字典所包含的键值对来更新己有的字典。
在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

a = { 'one':1, 'two':2, 'three':3} a.update({ 'one':4.5, 'four':9.3}) print(a)''' {'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3} '''

pop()和popitem()方法
pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对。

dictname.pop(key) dictname.popitem()

其中，dictname 表示字典名称，key 表示键。
看到这里，我认为键就是和索引差不多，但是字典是无序的，就酱，不废话，继续学~
对 popitem() 的说明
其实，说 popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。

a = { '数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89} print(a) a.popitem() print(a) a.popitem() print(a)''' {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89} {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98} {'数学': 95, '语文': 89, '英语': 90, '化学': 83} '''

setdefault()方法
setdefault() 方法用来返回某个 key 对应的 value：
dictname.setdefault(key, defaultvalue)。
说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。
当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。
也就是说，setdefault() 方法总能返回指定 key 对应的 value：

如果该 key 存在，那么直接返回该 key 对应的 value；
如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

a = { '数学': 95, '语文': 89, '英语': 90} a.setdefault('物理', 0) a.setdefault('化学') a.setdefault('数学', 0) print(a)''' {'数学': 95, '语文': 89, '英语': 90, '物理': 0, '化学': None} '''

set集合

集合中元素互不重复
只存储不可变的数据类型（列表、字典、集合是可变的）
无序

和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。
Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔：
{element1,element2,...,elementn}

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
由于 Python 中的 set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同。

创建set集合

使用{}创建
set()函数创建集合

set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。
setname = set(iteration)
如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {}，Python 解释器会将其视为一个空字典。
访问set集合元素
由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。

s = { 1,'c',1,(1,2,3),'c'} for e in s: print(e, end=' ')''' 1 c (1, 2, 3) '''

删除set集合
使用del()语句

s = { 1,'c',1,(1,2,3),'c'} print(s) del(s) print(s)''' Traceback (most recent call last): File "D:\桌面\py\main.py", line 4, in print(s) NameError: name 's' is not defined {'c', 1, (1, 2, 3)} '''

set集合基本操作
set 集合最常用的操作是向集合中添加、删除元素，以及集合之间做交集、并集、差集等运算。
1. 向set集合添加元素
add()方法
【【编程语言】Python|【Python系列3】列表、元素、字典和集合＜2万字整理＞建议收藏！！！】语法：setname.add(element)
需要注意的是，使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误。

a = { 1,2,3} # 集合 a.add(4) a.add((4,5)) # 添加元组 a.add("hello set") print(a)''' {1, 2, 3, 4, 'hello set', (4, 5)} '''

2. 从set集合中删除元素

remove()

删除现有 set 集合中的指定元素，可以使用 remove() 方法
setname.remove(element)
被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误。

discard()

不想在删除失败时令解释器提示 KeyError 错误，还可以使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误。
3. set集合做交集、并集、差集运算

运算操作	Python运算符	含义	例子
交集	&	取两集合公共的元素	>>> set1 & set2 {3}
并集	\|	取两集合全部的元素	>>> set1 \| set2 {1,2,3,4,5}
差集	-	取一个集合中另一集合没有的元素	>>> set1 - set2 {1,2} >>> set2 - set1 {4,5}
对称差集	^	取集合 A 和 B 中不属于 A&B 的元素	>>> set1 ^ set2 {1,2,4,5}

set集合方法全

方法名	语法格式	功能	实例
add()	set1.add()	向 set1 集合中添加数字、字符串、元组或者布尔类型	>>> set1 = {1,2,3} >>> set1.add((1,2)) >>> set1 {(1, 2), 1, 2, 3}
clear()	set1.clear()	清空 set1 集合中所有元素	>>> set1 = {1,2,3} >>> set1.clear() >>> set1 set() set()才表示空集合，{}表示的是空字典
copy()	set2 = set1.copy()	拷贝 set1 集合给 set2	>>> set1 = {1,2,3} >>> set2 = set1.copy() >>> set1.add(4) >>> set1 {1, 2, 3, 4} >>> set1 {1, 2, 3}
difference()	set3 = set1.difference(set2)	将 set1 中有而 set2 没有的元素给 set3	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.difference(set2) >>> set3 {1, 2}
difference_update()	set1.difference_update(set2)	从 set1 中删除与 set2 相同的元素	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.difference_update(set2) >>> set1 {1, 2}
discard()	set1.discard(elem)	删除 set1 中的 elem 元素	>>> set1 = {1,2,3} >>> set1.discard(2) >>> set1 {1, 3} >>> set1.discard(4) {1, 3}
intersection()	set3 = set1.intersection(set2)	取 set1 和 set2 的交集给 set3	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.intersection(set2) >>> set3 {3}
intersection_update()	set1.intersection_update(set2)	取 set1和 set2 的交集，并更新给 set1	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.intersection_update(set2) >>> set1 {3}
isdisjoint()	set1.isdisjoint(set2)	判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回 True	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.isdisjoint(set2) False
issubset()	set1.issubset(set2)	判断 set1 是否是 set2 的子集	>>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issubset(set2) False
issuperset()	set1.issuperset(set2)	判断 set2 是否是 set1 的子集	>>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issuperset(set2) True
pop()	a = set1.pop()	取 set1 中一个元素，并赋值给 a	>>> set1 = {1,2,3} >>> a = set1.pop() >>> set1 {2,3} >>> a 1
remove()	set1.remove(elem)	移除 set1 中的 elem 元素	>>> set1 = {1,2,3} >>> set1.remove(2) >>> set1 {1, 3} >>> set1.remove(4) Traceback (most recent call last): File “”, line 1, in set1.remove(4) KeyError: 4
symmetric_difference()	set3 = set1.symmetric_difference(set2)	取 set1 和 set2 中互不相同的元素，给 set3	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.symmetric_difference(set2) >>> set3 {1, 2, 4}
symmetric_difference_update()	set1.symmetric_difference_update(set2)	取 set1 和 set2 中互不相同的元素，并更新给 set1	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.symmetric_difference_update(set2) >>> set1 {1, 2, 4}
union()	set3 = set1.union(set2)	取 set1 和 set2 的并集，赋给 set3	>>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3=set1.union(set2) >>> set3 {1, 2, 3, 4}
update()	set1.update(elem)	添加列表或集合中的元素到 set1	>>> set1 = {1,2,3} >>> set1.update([3,4]) >>> set1 {1,2,3,4}