Python入门--day03--复合类型之序列类型、映射类型和集合类型-CSDN博客

本文链接：https://blog.csdn.net/2303_78278237/article/details/149245824

文章目录

前言
一、序列类型概述
二、列表类型(list)
三、元组(tuple)
四、映射类型(dict)
五、集合类型(set/frozenset)
- 1.集合的创建
- - 1.1创建集合的方式
  - 1.2创建固定集合frozensets的方式
2.集合操作
总结
--- Python基础系列相关文章 ---

前言

上一篇文章中，我们初次学习了Python变量类型，专门讲解了基本类型中的数字类型和字符串类型。

接下来我将会讲解变量类型中的复合类型，复合类型将多个同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序更容易。根据数据之间的关系，复合数据类型可以分为三类：

序列类型：是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他
集合类型：是一个元素集合，元素之间无序，不允许出现重复元素
映射类型：是“键-值” 数据项的组合，每个元素是一个键值对，表示为(key, value)

一、序列类型概述

有三种基本序列类型：list, tuple 和 range 对象。
文本序列类型(str)也是序列类型，前面我们已经学习了。

1.通用序列操作

大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。
此表按优先级升序列出了序列操作。在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。

in 和 not in 操作具有与比较操作相同的优先级。 + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级。

运算	结果：
`x in s`	如果 s 中的某项等于 x 则结果为 `True`，否则为 `False`
`x not in s`	如果 s 中的某项等于 x 则结果为 `False`，否则为 `True`
`s + t`	s 与 t 相拼接
`s * n` 或 `n * s`	相当于 s 与自身进行 n 次拼接
`s[i]`	s 的第 i 项，起始为 0
`s[i:j]`	s 从 i 到 j 的切片
`s[i:j:k]`	s 从 i 到 j 步长为 k 的切片
`len(s)`	s 的长度
`min(s)`	s 的最小项
`max(s)`	s 的最大项
`s.index(x[, i[, j]])`	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
`s.count(x)`	x 在 s 中出现的总次数

相同类型的序列也支持比较。特别地，tuple 和 list 的比较是通过比较对应元素的字典顺序。这意味着想要比较结果相等，则每个元素比较结果都必须相等，并且两个序列长度必须相同。（完整细节请参阅官方文档的比较运算部分。）

此表按优先级升序列出了序列操作。在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。

详细通用序列操作参考官方文档：
https://docs.python.org/zh-cn/3.12/library/stdtypes.html#common-sequence-operations

2.可变类型与不可变类型

Python中，Python中，变量的值分为可变（mutable）或 不可变（immutable），该特征决定了变量在赋值、修改时的行为和性能。

2.1不可变类型（immutable）

不可变类型指的是一旦创建后，其值就不能被改变的数据类型。如果试图改变一个不可变对象的值，实际上是创建了一个新对象。不可变类型保证了对象的身份不会随着其内容的变化而变化，因此它们可以用作字典的键，因为它们的哈希值在整个生命周期中保持不变。

不可变类型包括：
- 整数（int）
- 浮点数（float）
- 字符串（str）
- 元组（tuple）元素。
- 布尔型（bool）只有两个值，True和False，用于表示逻辑上的真和假。

示例：
(1)对于整型变量，当两个变量的值相同时，它们的引用指向内存中同一个地址

a = 100
b = 100
print('变量a地址:%d\n变量b地址:%d\n' % (id(a), id(b)))

结果如下：

(2)对于元组，用同一个变量接收两个元组，其引用地址会发生改变

c = (100, 200, 300)
print(f"改变前c = {c}\nc地址:{id(c)}")
c = c + (400,)
print(f"改变后c = {c}\nc地址:{id(c)}")

结果如下：

2.2可变类型（Mutable）

可变类型指的是在创建后可以改变其内容的数据类型。当你修改一个可变对象时，实际上是在原地修改该对象，而不是创建一个新对象。

可变类型包括：
- 列表（list）
- 字典（dict）
- 集合（set）
- 自定义的类(class)

示例:
对于一个列表，修改它某个元素的值，向该列表添加元素，其地址都不变。

lst_1 = [1, 2, 3]
print(f"{lst_1}\n{id(lst_1)}")
lst_1[0] = 10
print(f"{lst_1}\n{id(lst_1)}")
lst_1.append(4)
print(f"{lst_1}\n{id(lst_1)}")

结果如下：

2.3二者区别

内存管理
- 对不可变类型改值时，Python会创建一个新的对象，并将该对象的引用赋给原来的变量。
- 对可变类型修改内容时，不会创建新的对象，而是直接在原地进行修改。


变量引用	浅拷贝	深拷贝

行为差异
- 不可变对象的引用在修改后总会指向一个新对象，而可变对象的引用在修改时仍然指向原始对象。

作为字典键

不可变类型具有固定的哈希值，可以作为字典的键。
可变类型哈希值可能变化，不能作为字典的键。

d = {}
d[(1, 2)] = "tuple key"  # 元组是不可变的，可以作为字典的键
d[[1, 2]] = "list key"   # 会抛出 TypeError: unhashable type: 'list'

特别注意

以上是基于修改而不是赋值，重新赋值操作都会指向新的对象引用。

2.4 类型判断

使用isinstance判断类型变量

a = 1
print(isinstance(a, int)) #判断是否属于指定类型
str1 = 'abc'
print(isinstance(str1, (int, str))) #判断是否属于多个类型之一

补充：

可变序列操作

运算	结果：
`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 的元素
`del s[i:j:k]`	从列表中移除 `s[i:j:k]` 的元素
`s.append(x)`	将 x 添加到序列的末尾 (等同于 `s[len(s):len(s)] = [x]`)
`s.clear()`	从 s 中移除所有项 (等同于 `del s[:]`)
`s.copy()`	创建 s 的浅拷贝 (等同于 `s[:]`)
`s.extend(t)` 或 `s += t`	用 t 的内容扩展 s (基本上等同于 `s[len(s):len(s)] = t`)
`s *= n`	使用 s 的内容重复 n 次来对其进行更新
`s.insert(i, x)`	在由 i 给出的索引位置将 x 插入 s (等同于 `s[i:i] = [x]`)
`s.pop()` 或 `s.pop(i)`	提取在 i 位置上的项，并将其从 s 中移除
`s.remove(x)`	从 s 中移除第一个 `s[i]` 等于 x 的条目
`s.reverse()`	就地将列表中的元素逆序。

详细可变序列操作参考官方文档

二、列表类型(list)

列表是可变序列，通常用于存放同类项目的集合（其中精确的相似程度将根据应用而变化）。

class list([iterable])

1.列表的创建

可以用多种方式构建列表：
- 使用一对方括号来表示空列表: []
- 使用方括号，其中的项以逗号分隔: [a], [a, b, c]
- 使用列表推导式: [x for x in iterable]
- 使用类型的构造器: list() 或 list(iterable)

构造器将构造一个列表，其中的项与 iterable 中的项具有相同的的值与顺序。 iterable 可以是序列、支持迭代的容器或其它可迭代对象。如果 iterable 已经是一个列表，将创建并返回其副本，类似于 iterable[:]。
例如，list('abc') 返回 ['a', 'b', 'c'] 而 list( (1, 2, 3) ) 返回 [1, 2, 3]。如果没有给出参数，构造器将创建一个空列表 []。

1.1字面值创建

  L = []     # 创建一个空的列表
  L = ['北京', '上海', '广州', '西安']  # 创建一个含有4个字符串的列表
  L = [1, 'Two', 3.14, True, False, None]
  L = [1, 2, [3.1, 3.2], 4]   #  含有四个元素的列表，第三个元素是列表
  L2 = [
  	['姓名','语文成绩','数学成绩'],
  	['小王', 90, 100],
  	['牛犇', 59, 26]
  ]

1.2使用构造器list()

  list()           # 创建一个空的列表，等同于 []
  list(可迭代对象)   # 用可迭代对象创建一个列表

示例：

  L = list()          # L = []
  L = list("ABC")     # L = ['A', 'B', 'C']
  L = list(range(5))  # L = [0, 1, 2, 3, 4]

1.3列表推导式

[x for x in iterable]

例如：

# 生成 0~9 的平方数列表
squares = [x**2 for x in range(10)]
# 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 生成 1~10 的偶数列表
evens = [x for x in range(1, 11) if x % 2 == 0]
# 输出: [2, 4, 6, 8, 10]

补充:
其它许多操作也会产生列表，包括 sorted() 内置函数。

2.列表操作

2.1 列表运算

列表list同字符串str都是序列, 他们的运算规则基本相同。

+ 用于拼接列表

[1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]

+= 追加

语法 列表 += 可迭代对象

L = [1, 2, 3]
L += [4, 5]         # L = [1, 2, 3, 4, 5]
L = [1, 2, 3]
L += "ABC"          # L = [1, 2, 3, 'A', 'B', 'C']
L += range(2)

* 用于生产重复的列表

[1, 2] * 3    # [1, 2, 1, 2, 1, 2]
L = [5, 6]
L *= 3        # L = [5, 6, 5, 6, 5, 6]

== 、!= 用于比较

[1, 2, 3] == [1, 2, 3]    # True
[1, 2, 3] != [3, 2, 1]    # True

in 、not in 用于判断一个数据元素是否在列表中

"hello" in [1, "hello", 'world']
True
'红楼梦'  in ['三国演义', '西游记']
False

2.2 列表访问

2.2.1 索引

列表[整数表达式]

L = [1, 2, 3, 4, 5, 6]
print(L[0])    # 1
print(L[-1])   # 6

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

2.2.2 反向索引

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

2.2.3 切片

列表[[开始索引b]:[终止索引e][: (步长s)]]

[]里的内容代表可以省略

x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4]     # y1 = [1, 2, 3, 4]
y2 = x[::2]    # y2 = [1, 3, 5, 7]
y3 = x[::-1]   # y3 = [8, 7, 6, 5, 4, 3, 2, 1]

切片后，对切片的索引也是从0开始

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

list = ['openAI', 'ChatGPT', "Zhihu", "Taobao", "Wiki"] 
# 读取第二位
print (list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (list[1:-2])
# 从下标2开始(包含2)到最后一个
print (list[2:])
# 从下标0开始到下标3结束(左闭右开)
print (list[:3])

2.3 添加数据

方法

方法名(L代表列表)	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象

示例

mylist1 = [1, 3, 4]            	# 目标是变成 [1, 2, 3, 4, 5]
mylist1.append(5)               # mylist1 = [1, 3, 4, 5]
mylist1.insert(1, 2)            # mylist1 = [1, 2, 3, 4, 5]
mylist1.extend(range(6, 10))    # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

2.4 修改数据

用索引赋值可以改变列表内的数据

列表[整数表达式] = 表达式

示例

mylist2 = [1, 1.99, 3]   # 把1.99 改为2
mylist2[1] = 2    # mylist2 = [1, 2, 3]

2.5 删除数据

方法

方法	说明
lst.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
lst.pop()	根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素
lst.clear()	清空列表

示例

L = [1, 2, 3, 4, 2, 2, 3, 4]
L.remove(3)    #  L = [1, 2, 4, 2, 2, 3, 4]
L.remove(3)    #  L = [1, 2, 4, 2, 2, 4]
L.remove(3)    #  报错了
L.clear()      #  L = []

del 语句删除指定位置的数据元素

语法

del 变量名     # 删除变量，同时解除变量绑定的对象
del 列表[整数表达式]

示例

L = ['张飞', '赵云', '鲁班7号', '孙悟空']
del L[2]    # L = ['张飞', '赵云', '孙悟空']
del L       # 删除 L 变量

三、元组(tuple)

元组是不可变序列，通常用于储存异构数据的多项集（例如由 enumerate() 内置函数所产生的二元组）。元组也被用于需要同构数据的不可变序列的情况（例如允许存储到 set 或 dict 的实例）。

class tuple([iterable])

1.元组的创建

可以用多种方式构建元组：
- 使用一对圆括号来表示空元组: ()
- 使用一个后缀的逗号来表示单元组: a, 或 (a,)
- 使用以逗号分隔的多个项: a, b, c or (a, b, c)
- 使用内置的 tuple()方法: tuple() 或 tuple(iterable)

构造器将构造一个元组，其中的项与 iterable 中的项具有相同的值与顺序。 iterable 可以是序列、支持迭代的容器或其他可迭代对象。如果 iterable 已经是一个元组，会不加改变地将其返回。例如，tuple('abc') 返回 ('a', 'b', 'c') 而 tuple( [1, 2, 3] ) 返回 (1, 2, 3)。如果没有给出参数，构造器将创建一个空元组 ()。

请注意决定生成元组的其实是逗号而不是圆括号。圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时附带一个三元组。

1.1字面值创建

用小括号() 括起来，单个元素括起来后一定要记得加逗号，逗号才能用来区分单个元素还是元组

示例：

t = ()         # 空元组
t = (100,)     # 一个元素的元组，在元素后面添加逗号，否则括号会被当作运算符
t = 100,       # 一个元素的元组
t = (1, 2, 3)  # 含有三个数据元素的元组
t = ( 'hello world', 2004) # 存放不同类型的元组
t = 1, 2, 3    # 含有三个数据元素的元组

1.2使用构造器 tuple()

t = tuple()          # t = ()
t = tuple(range(5))  # t = (0, 1, 2, 3, 4)

2.元组操作

2.1删除元组

元组中的元素值是不允许删除的，但可以用del删除元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)		#name 'tup' is not defined

2.2元组的访问

tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)

2.3解包技能

必备技能

序列解包：解构赋值，左侧变量与右侧序列元素的数量应相等
可以用"_"来接收多余的值

fruit = ('apple', 'pear', 'peach')
f1, f2, f3 = fruit
print(f1, f2, f3)

tup_1, _, _, tup_2 = 100, 0, 1, 200
print(tup_1,tup_2)

2.4 元组运算

元组中的元素值是不允许修改的，但可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

t = (1, 2, 3) + (4, 5, 6)
t += (7, 8, 9)  # 等同于 t = t + (7, 8, 9)
t = t * 2
t *= 2
5 in t

2.5 元组常用API

通用操作详见官方文档:
https://docs.python.org/zh-cn/3.13/library/stdtypes.html#common-sequence-operations

Python元组包含了以下内置函数

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。

元组常用的方法

运算	结果
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数

四、映射类型(dict)

映射属于可变对象。目前仅有一种标准映射类型字典。字典的键几乎可以为任何值。不是 hashable 的值，即包含列表、字典或其他可变类型（按值比较而非按对象标识比较）的值不可被用作键。比较结果相等的值（如 1, 1.0 和 True 等）可被互换使用以索引同一个字典条目。

class dict(**kwargs)
class dict(mapping, **kwargs)
class dict(iterable, **kwargs)

返回一个新的字典，基于可选的位置参数和可能为空的关键字参数集来初始化。

1.字典的创建

字典可用多种方式来创建:
- 使用花括号内以逗号分隔 键: 值 对的方式: {'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)

如果没有给出位置参数，将创建一个空字典。如果给出一个位置参数并且其定义了 keys() 方法，则通过在该参数上调用 __getitem__() 创建一个字典并包含从该方法返回的每个键。在其他情况下，位置参数必须是一个iterable(可迭代) 对象。该可迭代对象中的每一项本身必须是一个恰好包含两个元素的可迭代对象。每一项中的第一个元素将成为新字典的一个键，第二个元素将成为其对应的值。如果一个键出现多次，该键的最后一个值将成为其在新字典中的对应值。

如果给出了关键字参数，则关键字参数及其值会被加入到基于位置参数创建的字典。如果要加入的键已存在，来自关键字参数的值将替代来自位置参数的值。

1.1字面值创建

d = {}    # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}

以下写法会存在问题

d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2}  
d = {[1, 2, 3]: 'a'}          # TypeError: unhashable type: 'list'

1.2使用构造器dict()

d = dict()   # d = {}
d = dict([("name", "小王"), ("age", 35)])  # {'name': '小王', 'age': 35}
d = dict(a=1, b=2, c=3)    # {'a':1, 'b':2, 'c':3}
dict_1 = dict(zip(['a', 'b', 'c'],[1, 2, 3]))	#{'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4])  # 错

2 字典操作

详情参考官方文档:
https://docs.python.org/zh-cn/3.12/library/stdtypes.html#mapping-types-dict

2.1增加或修改

添加和修改字典的元素

语法
```
字典[键key] = 表达式
dict.update({键值对})
```
键不存在, 就添加

键存在, 会改变键对应的值

示例

d = {}
d['name'] = 'tarena'  # 添加键值对
d['age'] = 18         # d = {'name': 'tarena', 'age': 18}
d['age'] = 19         # 改变键对应的值

2.2字典的访问

字典的键索引

语法
```
字典[键key]
```

示例

d = {'one': 1, 'two': 2}
print(d['two'])

如果键不存在，会报错

mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'} 
print (mydic['Alice']) # KeyError: 'Alice'

2.3删除元素

能删单一的元素也能清空字典，显式删除一个字典用del命令

语法

del 字典[键]

示例

mydic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del mydic['Name'] # 删除键 'Name'
mydic.clear()     # 清空字典
 
print (mydic['Age'])
print (mydic['School'])

del mydic         # 删除字典

2.4字典特性

不允许同一个键出现两次，否则后一个覆盖前一个

mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (mydic['Name'])

键必须不可变，可以用数字、字符串或元组，列表不行

mydic1 = {97:"a",98:"b"}
mydic2 = {"name":"karen","age":27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']])	#报错unhashable type: 'list'

五、集合类型(set/frozenset)

set 对象是由具有唯一性的 hashable 对象所组成的无序多项集。常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。

目前有两种内置集合类型，set和 frozenset。 set类型是可变的 — 其内容可以使用 add() 和 remove() 这样的方法来改变。由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。frozenset类型是不可变并且为 hashable —— 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。
两个类的构造器具有相同的作用方式：

class set([iterable])
class frozenset([iterable])

1.集合的创建

1.1创建集合的方式

空集合 set()

非空集合用 {} 括起来，值用逗号分隔开

s = set()            # 用函数空集合
s = {1, 2, 3, 4}     # 创建非空集合的字面值
s = set(range(5))    # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
s = set("ABC")       # s = {'B', 'C', 'A'}
s = set("ABCCCCCCC")  # s = {'B', 'C', 'A'}
s = set(['ABC'])      # s = {'ABC'} 使用 set()函数从列表创建集合
s = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合

1.2创建固定集合frozensets的方式

fs = frozenset()              # 空固定集合 fs = frozenset()
fs = frozenset([1, 2, 3])     # fs =  frozenset({1, 2, 3})

注意：
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

2.集合操作

详情参考官方文档:
https://docs.python.org/zh-cn/3.12/library/stdtypes.html#set-types-set-frozenset

2.1 添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x ) 添加元素到集合。
s.update( x ) 添加元素到集合，且参数可以是列表、元组、字典等，x 可以有多个，用逗号分开。

s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1)
s1.update([200,300])
print(s1)

2.2 删除元素

s.remove( x )：将元素 x 从集合 s 中移除，不存在会发生错误。
s.discard( x )：将元素 x 从集合 s 中移除，不存在也不会发生错误。
s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

s1 = {10, 20, 30}
s1.remove(20)
print(s1)
s1.remove(40)#报错

s1 = {10, 20, 30}
s1.discard(20)
print(s1)
s1.discard(40)

s1 = {10, 20, 30}
s1.pop()
print(s1)

del s1 # 也可以直接删除整个集合

2.3 访问与修改

集合是无序的、不可重复的数据结构，不能通过索引来访问其元素。所以也没有对应的修改功能。

TODO：需要通过遍历或者迭代器去访问。

判断元素是否存在

in/not in

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

s1 = {10, 20, 30}
print(20 in s1)

2.4常用API

集合的常用方法如下

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集，并更新到集合。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

示例：

# 1.len()
s1 = {10, 20, 30}
print(len(s1))

#2. clear()
s1 = {10, 20, 30}
s1.clear()
print(s1)

#3.union()
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = {5, 6, 7}

result = set1.union(set2, set3)
print(result)