Ⅰ python中创建集合的方法有哪些呢
集合分为两种：可变集合（set）和不可变集合（frozenset），现在学习的是可变集合。
在Python中，有关于集合的操作主要有：集合的创建；集合的添加和删除；集合的交、并和差集运算。
今天先来学习如何创建集合。
集合的创建有两种方法：直接赋值法和set()函数法。
1、直接赋值法
和Python的其它序列一样，采用直接赋值法就可以直接创建一个集合，具体语法格式如下：
setname = {“element1”,“element2”,“element3”,……,“elementn”,}
从格式上看，和其它的序列创建方法基本一样，就是集合名setname直接使用赋值运算符等号“=”赋值，等号后面的元素内容使用英文半角的大括号“{ }”括起来，各个元素之间依然使用英文半角的逗号“,”分隔。
这里虽然和字典一样使用大括号“{ }”，但是只要记住字典的元素是由键值对组成的（详见前第62节内容），就完全可以区分所创建的是字典还是集合了。
Ⅱ Python的集合有哪些操作
集合是一个无序的，不重复的数据组合，它有着两个主要作用：去重以及关系测试。去重指的是当把一个列表变成了集合，其中重复的内容就自动的被去掉了
关系测试指的是，测试两组数据之间的交集、差集、并集等关系。
去重测试代码如下：
#创建一个列表--里面存在一些重复值
test_list = [1,2,3,4,2,2,3,4,3,2,3,4]
#利用集合将列表中重复的内容去掉
test_list = set(test_list)
#打印测试并且查看test_list被赋予新值后的数据类型print(test_list,type(test_list)) # {1, 2, 3, 4}
Tip：需要注意的是，集合和字典一样都是无序的。
获取交集需要使用集合中的方法intersection方法，获取两个集合中的交集代码如下：
#创建两个集合，并且获取集合的交集
test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#在上面的两个集合中，存在相同的值，那么现在我们取出两个集合中的交集
test_intersection = test_list_01.intersection(test_list_02)print(test_intersection) # {'YanYan', 'LiBai'}
获取并集的方式需要采用集合中union方法，获取两个集合的并集代码如下：
#创建两个集合，并且获取集合的交集
test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#采用集合中的union方法获取并集
test_list_union = test_list_01.union(test_list_02)
print(test_list_union) # {'LiBai', 'LuLu', 'ZhangXueYou', 'LiuDeHua', 'YangMi', 'YanYan'}
获取差集的方式要采用集合中的difference方法，获取两个集合的差集的代码如下所示：
#创建两个集合，并且获取集合的交集
test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#使用集合中的difference方法来获取差集
test_difference = test_list_01.difference(test_list_02)
test_difference2 = test_list_02.difference(test_list_01)
print(test_difference) # {'LuLu', 'YangMi'}print(test_difference2) # {'ZhangXueYou', 'LiuDeHua'}
判断一个集合是否是另外一个集合的子集可以使用issubset()方法，同样，还可以使用issuperset()方法判断一个集合是否是另外一个集合的父级
代码如下：
#创建两个集合
list_set = set([1,2,3,4])
list_son = set([2,3])
#判断list_son是否是list_set的子集print(list_son.issubset(list_set)) # True#判断list_set是否是list_son的父级print(list_set.issuperset(list_son)) # True
对称差集(又有人称之为叫做反向差集)，指的是取出两个集合中互相都没有的值取出放在一个集合中。
代码如下：
#创建两个集合
list_set_num1 = set([1,3,5,7,9])
list_set_num2 = set([2,3,4,6,9,10])
#获取两个集合的对称差集print(list_set_num1.symmetric_difference(list_set_num2)) # {1, 2, 4, 5, 6, 7, 10}
如果上述的难以理解的话，可以对对称差集理解为去掉两个集合中都存在的内容，将剩余的内容取到一个新的集合中。
除了上述的这些方法实现的关系功能之外，还有一个方法isdisjoint()，功能是判断两个集合中是否有相同的值，如果两个集合中没有相同的值(即没有交集)，那么返回True
代码如下：
#创建集合
test_set_num1 = set([1,2,3,4])
test_set_num2 = set([5,6,7,8])
test_set_num3 = set([1,3,7,8])
#使用isdisjoint()方法来判断print(test_set_num1.isdisjoint(test_set_num2)) # Trueprint(test_set_num1.isdisjoint(test_set_num3)) # False
通过运算符来进行关系测试
在上面的应用中，主要是通过python中的方法进行的关系测试，那么在python中，除了使用方法以外，还可以使用关系运算符来进行关系测试。
实例代码如下：
test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#获取交集&print(test_list_01 & test_list_02) # {'LiBai', 'YanYan'}
#获取并集|print(test_list_01 | test_list_02) # {'LuLu', 'LiBai', 'LiuDeHua', 'YanYan', 'ZhangXueYou', 'YangMi'}
#获取差集-print(test_list_01 - test_list_02) # {'LuLu', 'YangMi'}print(test_list_02 - test_list_01) # {'LiuDeHua', 'ZhangXueYou'}
#获取对称差集print(test_list_01 ^ test_list_02) # {'ZhangXueYou', 'YangMi', 'LuLu', 'LiuDeHua'}
集合的增删改查
添加
语法：Set.add()
代码如下：
#创建一个集合
test_set =set(['YanYan'])
#添加
test_set.add('LiBai') #添加一项
test_set.update(['LuLu','JingJing']) #一次性向集合中添加多项
#输出集合
print(test_set) #{'YanYan', 'LuLu', 'LiBai', 'JingJing'}
删除
删除集合中的某一个元素可以使用remove方法
代码如下：
#创建一个集合
test_set = set(['YanYan'])
#使用remove方法删除元素
test_set.remove('YanYan')print(test_set) # set()
删除项目除了使用remove以外，还可以使用pop()方法，但是pop()方法删除内容不能够指定，只是随机删除。
pop方法会把删除的内容返回，示例代码如下：
#创建一个集合
test_set = set([20,9,'a',1,2,3,4])print(test_set.pop()) # 1print(test_set.pop()) # 2print(test_set.pop()) # 3
删除元素还可以使用discard()方法，这个方法没有返回值，如果打印返回值的话会输出None
#创建一个集合
test_list = set([1,2,3,4,5])
#使用discard()方法删除--注意，discard()方法删除返回None，也就是没有返回值print(test_list.discard(3)) # None#此时原集合中的3已经被删除了print(test_list) # {1, 2, 4, 5}
查询
xins #判断x是否是s的成员
xnotins 判断x是否是s的成员
len(x) #查看x的长度
s <= t #测试是否s中的每一个元素都在t中
s >= t #测试是否t中的每一个元素都在s中
Ⅲ 关于python集合运算
差集 a-b 从集合a中去除所有在集合b中出现的元素集合
并集 a|b 集合a,b中所有不重复的元素集合
交集 a&b 集合a,b中均出现的元素集合
如 a={1,2,3,4} b={2,4,6,8} a集合中减去b中出现的2,4 a-b为{1,3}
a|b 为 {1,2,3,4,6,8} a&b为 a ，b中均出现的{2,4}
Ⅳ python两个集合间的and作用是什么
这个是两个逻辑条件之间的判断，跟集合没关系。
在while 后面的，必须是一个True或者False的布尔表达式。
像这个，m和f都是集合，条件就是 当集合m和f 都不为空时，条件成立。
Ⅳ Python 简明教程 ---13，Python 集合
目录
前几节我们已经介绍了Python 中的 列表list ， 元组tuple 和 字典dict ，本节来介绍Python 中的最后一种数据结构—— 集合set 。
Python 中的 set 与 dict 很像，唯一的不同是， dict 中保存的是 键值对 ，而 set 中只保存 键 ，没有 值 。
Python 集合 有如下特点：
Python 集合的声明有两种方式：
创建 空集合 时，只能用 set() ，而不能用 {} ：
创建 非空集合 时，可以用 set() ，也可以用 {} ：
由于集合中的元素是唯一的，如果初始化时的 可迭代 数据中有重复的元素，则会自动删去重复的元素：
使用 len() 函数可以查看集合中元素的个数：
由于Python 集合中的元素的是无序的，所以可不能使用 下标 的方式来访问集合中的单个元素。
我们可以使用 for 循环 来遍历集合中的所有元素：
我们可以对两个集合进行如下运算：
交集与并集
in 运算
使用 dir(set) 查看集合支持的所有方法：
下面一一介绍这些 非魔法方法 ，共17 个。
1. add 方法
由于集合中的元素是唯一的，向集合中添加元素时有两种情况：
示例：
2. remove 方法
示例：
3. discard 方法
示例：
4. pop 方法
示例：
5. union 方法
示例：
6. update 方法
示例：
7. clear 方法
示例：
8. 方法
示例：
9. difference 方法
示例：
10. difference_update 方法
示例：
11. intersection 方法
示例：
12. intersection_update 方法
示例：
13. isdisjoint 方法
示例：
14. issubset 方法
示例：
15. issuperset 方法
示例：
16. symmetric_difference 方法
示例：
17. symmetric_difference_update 方法
示例：
（完。）
推荐阅读：
Python 简明教程 --- 8，Python 字符串函数
Python 简明教程 --- 9，Python 编码
Python 简明教程 ---10，Python 列表
Python 简明教程 ---11，Python 元组
Python 简明教程 ---12，Python 字典
Ⅵ Python其实很简单 第十章 字典与集合
前面介绍的列表和元组都是有序序列，而字典与集合属于无序序列，也就是说，不能通过索引来操作元素。
10.1 字典
语法格式：
dictionary= {key1 : value1, key2 : value2, key3 : value3 ,...., key n : value n }
其中，dictionary是字典名称，key表示元素的键，value表示元素的值，键和值必须是成对的。
如：
>>> dict1 = { 'abc': 123, 98.6: 37 }
>>> dict1
{'abc': 123, 98.6: 37}
可以看出，键可以是字符串、数字或者元组，但必须是唯一的；而值可以是任何数据类型，也没有要求是唯一的。
1、创建字典的方法
方法一：同时给定键和值，即“关键字参数”形式。
dictionary=dict(key1=value1,key2=value2,.....,key n=value n)
注意：这里的key 必须符合Python标识符的命名规则。
例：
先使用“{}”创建字典：
>>> dict1={1:'一',2:'二',3:'三',4:'四',5:'五'}
>>> dict1
{1: '一', 2: '二', 3: '三', 4: '四', 5: '五'}
再通过“关键字参数”形式创建：
>>> dict1=dict(1='一',2='二',3='三',4='四',5='五')
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?
创建不成功，原因在于key 不符合Python标识符的命名规则。前面已经介绍过，标识符不能用数字表示或者用数字打头。
现在对键如下修改：
>>> dict1=dict(n1='一',n2='二',n3='三',n4='四',n5='五') #在数字前加了一个字符”n”
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
方法二 ：使用已经存在的元组和列表通过映射函数创建字典。
格式：dictionary=dict(zip(tuplekey,listvalue))
例：
>>> tuplekey=('n1','n2','n3','n4','n5') #键的序列采用元组
>>> listvalue=['一','二','三','四','五'] #值的序列采用列表
>>> dict1=dict(zip(tuplekey,listvalue))
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
注意：tuple(listname)函数可以将列表转换为元组，list(tuplename)函数可以将元组转换为列表。
2、通过键访问字典
直接获取键的相应元素的值
>>> dict1['n2']
'二'
利用get()方法
>>> dict1.get('n2')
'二'
get()方法也可以带参数，当要访问的键不存在时返回一个字符串。如：
>>> dict1.get('n0','can't find!') #当要查找的键不存在，返回'can't find!'
"can't find!"
3、遍历字典
使用字典对象的items()方法可以获取字典的“键.值对”列表。
>>> for item in dict1.items():
print(item)
('n1', '一')
('n2', '二')
('n3', '三')
('n4', '四')
('n5', '五')
也可以获取具体的每个元素的键和值，如：
>>> for key,value in dict1.items():
print(key,'对应的是',value)
n1 对应的是 一
n2 对应的是 二
n3 对应的是 三
n4 对应的是 四
n5 对应的是 五
4、添加、修改和删除字典元素
使用下面的语句，若指定的键存在，就可以修改该元素的值；若指定的键不存在，则添加该元素。如：
>>> dict1['n6']='六' # 键’n6’不存在，故添加该元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五', 'n6': '六'}
>>> dict1['n4']='肆' # 键’n4’存在，故修改该元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '肆', 'n5': '五', 'n6': '六'}
5、利用推导式建立字典
import random
dict1={i:random.randint(1,100) for i in range(5)}
# 生成元素的键为0到5整数，值为1到100之间的随机数
print(dict1)
运行结果：{0: 28, 1: 59, 2: 79, 3: 30, 4: 88}
10.2 集合
集合是数学中一个很重要的概念，集合具有确定性、互异性、无序性三个基本属性。在Python中，集合同样具有这三个基本属性，其中，确定性是指对象要么是集合的元素，要么不是集合的元素；互异性是指集合中的元素不能重复；无序性是指集合中的元素不分先后次序，可以随意更换位置。
1、集合的创建
直接使用“{}”创建
>>> set1={'春','夏','秋','冬'}
>>> set1
{'秋', '春', '冬', '夏'}
>>> set2={3,2,1,4,5}
>>> set2
{1, 2, 3, 4, 5}
利用已有的列表、元组创建集合
>>> list1=['东','南','西','北']
>>> set3=set(list1)
>>> set3
{'南', '东', '北', '西'}
利用已有的集合建立一个“副本”
>>> set3
{'南', '东', '北', '西'} #set3和set4的值一样
>>> set4=set3
>>> set4
{'南', '东', '北', '西'}
>>> set4.add('中') #给set4添加元素
>>> set4
{'西', '中', '东', '南', '北'} # 这个好理解
>>> set3
{'西', '中', '东', '南', '北'} # 意想不到吧？Set3为什么会发生变化？
再看看简单变量的情况：
>>> a=2
>>> b=a #是不是与前面set4=set3相似
>>> b+=1
>>> b
3
>>> a
2 #但a的值并没有发生改变
从上面集合set3、set4和简单变量a、b的值的变化情况对比，不难发现set3和set4是指向同一地址的对象，而变量a和变量b指向了不同地址，语句b=a是将a的值传递个b，并不是将a的地址传递给b。列表、元组、字典都和集合一样具有这样的性质。
所以，将set4称为set3的“副本”更为恰当。
2、添加和删除元素
>>> set3
{'南', '东', '北', '西'}
>>> set3.add('中') # 添加元素
>>> set3
{'西', '中', '东', '南', '北'} # 集合内的元素是无序的，不要纠结次序的变化
>>> set3.remove('中') # 删除元素
>>> set3
{'西', '东', '南', '北'}
3、集合运算
集合运算包括交(&)、并(|)、差(-)，和数学中的集合运算是一致的。
>>> set3={'南', '东', '北', '西'}
>>> set4={'西', '中', '东', '南', '北'}
>>> set3 & set4 #取set3和set4的交集
{'西', '南', '北', '东'}
>>> set3 | set4 #取set3和set4的并集
{'中', '南', '北', '西', '东'}
>>> set3 - set4 #取set3与set4的差，即set3比set4多出来的元素
set()
>>> set4 -set3 #取set4与set3的差，即set4比set3多出来的元素
{'中'}
Ⅶ python集合支持与整数的乘法运算吗
可以的，python支持多重数学运算
可以将集合设置成数组的形式，例如
3*［1 2 3 4］
Ⅷ python数据类型（集合）
1.集合（set）是一个无序不重复元素的序列(意思是有重复的会自动删除,每次打印元素的位置不一定)
2.基本功能是进行成员关系测试和删除重复元素
3.可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
4.因为set存储的是无序集合，所以我们没法通过索引来访问。访问 set中的某个元素实际上就是判断一个元素是否在set中。
1.创建集合
s=set()#创建一个空集合
s1={1,2,3,'a','python'}
2.删除重复的元素
集合是一个无序不重复元素的序列(意思是有重复的会自动删除,每次打印元素的位置不一定)
3.成员关系测试(检测某个成员是否在集合中)
案例:从终端输入5位数,以空格隔开,把这5位数存入列表中,剔除重复的数据,打印出来
#提示,列表转集合,集合转列表
a=input("请输入5位数字:")
mylist=a.split()
print(mylist)
b=set(mylist)
c=list(b)
print(c)
4.集合常用操作
1.添加元素
2.删除元素
3.删除整个集合
4.获取集合的长度
5.不支持改元素
集合操作-添加元素
格式:
集合.add(元素)
格式:
集合.update(元素)
区别:
add不能添加列表,update可以
update是将字符串中的拆分成字符进行追加
add，是当做整体追加在集合中
#案例:从终端输入一个数字就加入集合中,然后打印,又输入一个数字,然后打印,直到输入-1,退出输入
#然后打印最终的集合
ms=set()
while 1:
a=int(input("请输入一个数字:"))
if a==-1:
break
ms.add(a)
print(ms)
print(ms)
#案例:从终端输入一个字符串就加入集合中,然后打印,又输入一个字符串,然后打印,直到输入q,退出输入
#然后打印最终的集合,字符串要分开存储,如输入hello,存储的列表是{'h','e','l','0'}
ms=set()
while 1:
a=input("请输入一个字符串:")
if a=='q':
break
ms.update(a)
print(ms)
print(ms)
集合操作-删除元素及删除整个集合
格式:
集合.remove(元素) # 元素如果不存在会引发KeyError
集合.discard(元素) # 元素如果不存在不发生任何事
集合.pop() # 集合元素是字符串类型时删除随机元素。 集合元素是其他数据类型时，删除左边第一个元素
del 集合名 #删除整个集合
#案例:有集合{1,2,3,'hello','world'},删除全部字符串,然后最左边第一个元素
a={1,2,3,'hello','world'}
a.discard("hello")
a.discard("world")
a.pop()
print(a)
集合操作-获取集合的长度
格式:
len(集合名)
#案例:有集合{1,2,3,4,'hello','a'},保留1个元素,其他的删除,假如元素个数不确定
s={1,2,3,4,'hello','a'}
for i in range(len(s)-1):
s.pop()
print(s)
集合的集运算
集合的交集,并集,差集,对称差集的运算
{1,2,3,4}交集{4,5,6,7} -->4 交集(&)
{1,2,3,4}并集{4,5,6,7} ->1,2,3,4,5,6,7 并集(|)
{1,2,3,4}差集{4,5,6,7} ->1,2,3 差集(-)
{1,2,3,4}对称差集{4,5,6,7}->1,2,3,5,6,7 4同时出现在两个集合中,不选它 对称差集(^)
#案例:使用花括号和set创建各一个集合,然后对集合进行交、并、差、对称差运算
s={1,2,3,4,5,6}
s1=set([6,7,8,9,10])
print(s&s1)
print(s|s1)
print(s-s1)
print(s^s1)
Ⅸ python集合
*事先说明：以下代码及结果来自本设备Python控制台，在不同设备上可能结果有区别，望自己尝试为妙
集合（set），是一种Python里的类（class），
集合类似于列表（list），可更改，可迭代（iterable），但是元素不重复
定义集合使用花括号{}，例如：
>>> s = {"apple", "banana", "strawberry", "watermelon"}
警告！！！如果使用空括号
>>> a = {}
>>> a.__class__
<class 'dict'>
a将成为一个字典
想要定义空集合，
请使用类名。
>>> a = set()
类名定义也可以把迭代转换为集合：
>>> b = set("abc")
>>> b
{'a', 'b', 'c'}
但是，保存后它是无序的。
>>> s
{'banana', 'watermelon', 'strawberry', 'apple'}
（结果仅供参考，在不同设备上略有不同）
下面介绍它的性质：
1. 可更改：
使用add(x)方法添加元素x：
>>> s.add("lemon")
>>> s
{'banana', 'strawberry', 'lemon', 'watermelon', 'apple'}
使用update(iter1, iter2, …)方法添加多个可迭代对象（如列表，元组（tuple），另一个集合）里的元素：
>>> s.update(("orange", "grape"))
>>> s
{'banana', 'strawberry', 'orange', 'lemon', 'watermelon', 'apple', 'grape'}
警告！！！如果使用字符串，字符串也会被迭代：
>>> a = set()
>>> a.update("apple")
>>> a
{'a', 'p', 'e', 'l'}
使用remove(x)移除元素x，如果x不存在，则抛出KeyError错误
>>> s.remove("lemon")
>>> s
{'banana', 'strawberry', 'orange', 'watermelon', 'apple', 'grape'}
>>> s.remove("cat")
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
s.remove("cat")
KeyError: 'cat'
使用discard(x)移除元素x，不会发生错误
>>> s.discard("grape")
>>> s
{'banana', 'strawberry', 'orange', 'watermelon', 'apple'}
>>> s.discard("dog")
>>> s
{'banana', 'strawberry', 'orange', 'watermelon', 'apple'}
2. 可迭代：
>>> for x in s:
... print(x)
banana
strawberry
orange
watermelon
apple
3. 可以使用 len 函数获取集合长度；
>>> len(s)
5
可以使用in关键字检查一个元素是否在集合内，将返回逻辑值（bool）：
>>> "apple" in s
True
>>> "candy" in s
False
4.集合具有不重复性，因此它会自动去重：
>>> c = set("Hello World!")
>>> c
{' ', 'e', 'l', 'H', '!', 'r', 'W', 'o', 'd'}
5. 集合的运算
>>> d = set("abcdef")
>>> e = set("efghij")
>>> d
{'c', 'e', 'a', 'b', 'f', 'd'}
>>> e
{'h', 'e', 'g', 'j', 'f', 'i'}
>>> d - e # 集合d去掉集合e含有的元素，或者说集合d包含而集合e不包含的元素（不改变原集合）
{'a', 'b', 'd', 'c'}
>>> d | e # 集合d,e的所有元素
{'c', 'e', 'h', 'g', 'a', 'b', 'j', 'f', 'd', 'i'}
>>> d & e # 集合d,e都包含的元素
{'f', 'e'}
>>> d ^ e # 不同时出现在集合d, e中的元素
{'c', 'g', 'h', 'a', 'b', 'j', 'd', 'i'}
注意！！！
字符串、列表通用的+和*不适用于集合
>>> "abc" + "def"
'abcdef'
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> d + e
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
d + e
TypeError: unsupported operand type(s) for +: 'set' and 'set'
>>> "a" * 5
'aaaaa'
>>> [1] * 3
[1, 1, 1]
>>> d*3
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
d * 2
TypeError: unsupported operand type(s) for *: 'set' and 'int'
(作者的小观点：既然集合是不能重复的，那么乘以、重复是没有意义的)
Ⅹ Python精讲：Python中集合的交集并集差集和对称差集运算方法详解
欢迎你来到站长在线的站长学堂学习Python知识，本文学习的是《Python中集合的交集、并集、差集和对称差集运算方法详解》。主要讲的是集合运算的相关的概念，及运算方法，包括：集合的交集、集合的并集、集合的差集、集合的对称差集、集合的交集运算方法、集合的并集运算方法、集合的差集运算方法、集合的对称差集运算方法。
在Python中，集合最常用的操作就是进行交集、并集、差集和对称差集的运算。
要想学习集合的交集、并集、差集和对称差集运算方法，首先我们来了解这些名词的含义：
设A、B两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集。在Python中，进行交集运算时使用“&”符号。
给定两个集合A、B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集。在Python中，进行并集运算时使用“|”符号。
设A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A与集合B的差集。在Python中，进行差集运算时使用“-”符号。
对称差集也称为对称差分或者补集，设A，B是两个集合，所有不相同的集合，叫做集合A与集合B的对称差集（对称差分或者补集）。在Python中，进行对称差集运算时使用“^”符号。
上面都是概念性的描述，下面站长在线来举实际的场景来对交集、并集、差集和对称差集运算方法进行深入浅出的解读。
场景模拟：某高中三年级，文科班高考的科目是语文、数学、英语、政治、 历史 和地理。理科班高考的科目是语文、数学、英语、物理、化学和生物。
设定集合A为文科班高考的科目，集合B为理科班高考的科目。
A = {'语文','数学','英语','政治',' 历史 ','地理'}
B = {'语文','数学','英语','物理','化学','生物'}
我们使用集合的交集运算的时候可以采用两种方式，一种是使用“&”运算符进行操作，另一种是使用 intersection() 方法来实现。
运行结果：
运行结果：
同理集合B和集合A的交集也是一样。我这里就不重复了，自己去体验一下。
集合的并集运算也有两种方式，一种是使用“|”运算符进行操作，另一种是使用union()方法来实现。
运行结果如下：
运行结果为：
同理集合B和集合A的并集也是一样。自己去体验一下吧！
集合的差集运算也有两种方式，一种是使用“-”运算符进行操作，另一种是使用difference()方法来实现。
运行结果为：
上面是集合A和集合B的差集，但是集合B和集合A的差集就不是一样的了哦！
运行结果为：
从上面可以看出，集合A和集合B的差集 与 集合B和集合A的差集是不一样的，(A - B)是A中存在的部分，(B - A)是B中存在的部分。
运行结果：
同理，使用difference()方法进行集合B和集合A的差集也是不同的
运行结果：
集合的差集运算也有两种方式，一种是使用“^”运算符进行操作，另一种是使用symmetric_difference()方法来实现。
运行结果为：
运行结果为：
同样的，集合B与集合A的对称差集也是一样，自己去体验一下。
我们对集合的交集、并集、差集和对称差集运算方法全部详细的讲解了一遍，通过运行结果，我们得出结论：
集合中进行交集、并集、对称差集进行运算的时候，集合A与集合B，位置替换的时候，结果相同。
集合中进行差集运算的时候，集合A与集合B，位置替换的时候，结果不同，为前面那个集合独立存在的部分。
到此为止，本节课的内容《Python中集合的交集、并集、差集和对称差集运算方法详解》就完全讲完了，主要讲的集合运算的相关的概念，及运算方法，包括：集合的交集、集合的并集、集合的差集、集合的对称差集、集合的交集运算方法、集合的并集运算方法、集合的差集运算方法、集合的对称差集运算方法。