python列表元组集合字典_Python列表、元组、字典、集合的方法

一、列表

1、count()

定义：统计指定元素在列表中出现的次数并返回这个数。若指定的元素不存在则返回：0。

格式：[列表].count（“指定元素”）

例：统计指定元素的个数

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']

l1 = l.count('xiaobai')

print(l1)

输出结果：

1

图示：

例2：统计这一个不存在的元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']

l1 = l.count('k') #指定一个不存在的元素

print(l1)

输出结果：

0

图示：

2、index()

定义：查找并返回指定元素的索引位置，若指定的元素不存在则会抛出异常，可以指定范围查找。

格式：[列表].index("指定元素"，指定范围)

例1：查找指定元素的索引位置

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']

l1 = l.index('lisa')

print(l1)

输出结果：

1

图示：

例2：指定范围查找指定元素的索引位置，范围查找顾首不顾尾

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.index('lisa',2,7) ## 查找索引2到7的范围，顾首不顾尾

print(l1)

输出结果：

6

图示：

例3：查找一个列表中不存在的元素则会抛出异常

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.index('k') #查找一个列表中不存在的元素

print(l1)

输出结果：

ValueError: 'k' is not in list

图示：

3、pop()

定义：作用：移除列表中一个指定元素。括号中必须写被移除元素的索引位置，并返回这个被移除的元素，括号中不写则默认移除列表中最后一个元素

格式：[列表].pop（指定元素的索引位置）

例1：默认移除列表中的最后一个元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.pop() # 默认移除列表中的最后一个元素

print(l1) # 返回这个被移除的元素

print(l) # 查看原列表

输出结果：

lisa

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi']

图示：

例2：移除指定的元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.pop(3) # 移除列表中索引位置的元素

print(l1) # 返回这个被移除的元素

print(l) # 查看原列表

输出结果：

yujiemeigui

['xiaobai', 'lisa', 'Miss_Jing', 'taidi', 'xiaodi', 'lisa']

图示：

例3：删除一个超出列表元素索引的元素则会抛出异常

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.pop(8) # 移除列表中索引位置为8的元素，但列表中的元素没有索引位置为8的元素

print(l1) # 返回这个被移除的元素

print(l) # 查看原列表

输出结果：

IndexError: pop index out of range

图示：

4、remove()

定义：移除列表中一个指定的元素，返回值为None，括号中必须指定元素名，否则抛出异常。移除一个不存在列表中的元素也会抛出异常。

格式：[列表].remove（“指定的元素名”）

例1：移除指定元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.remove('taidi')

print(l1) # 返回值为None

print(l) # 修改后的原列表

输出结果：

None

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'xiaodi', 'lisa']

图示：

例2：移除一 个不存在列表的元素则会抛出异常。

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.remove('kk')

print(l1) # 查看移除后的列表

print(l) # 查看原列表

输出结果：

ValueError: list.remove(x): x not in list

图示：

5、insert()

定义：将要插入的元素插入至列表中指定的索引位置处，返回值为None。

格式：[列表].insert（指定的索引位置，"要插入的元素"

例1：将要插入的元素插入至列表中指定的索引位置处

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.insert(3,'taibai') # 将字符串“taibai”前面插入到yujiemiegui前面

print(l1) # 返回值为None

print(l) # 查看原列表

输出结果：

None

['xiaobai', 'lisa', 'Miss_Jing', 'taibai', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa']

图示：

例2：将要插入的元素插入至列表中指定的索引位置处。

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.insert(18,'御姐玫瑰') # 将字符串“御姐玫瑰”插入到索引位置18前面

print(l1) # 返回值为None

print(l) # 查看原列表

输出结果：

None

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa', '御姐玫瑰']

图示：

6、append()

定义：在列表中的末尾处添加指定的元素，返回值为None。

格式：[列表].append（“指定元素”）

例：在列表的末尾处添加指定的元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.append('御姐玫瑰')

print(l1) # 返回值为None

print(l) # 查看原列表

输出结果：

None

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa', '御姐玫瑰']

图示：

7、clear()

定义：清空列表中所有的元素，返回值为None

格式：[列表].clear（）

例：清空列表中所有的元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.clear()

print(l1) # 返回值为None

print(l) # 查看原列表

输出结果：

None

[]

图示：

8、copy()

定义：拷贝列表，并返回一个浅拷贝后的新列表

格式：[列表].copy（）

例：拷贝一个列表

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.copy()

print(l1) # 得到复制后的列表

print(l) # 查看原列表

输出结果：

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa']

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa']

图示：

9、extend()

定义：扩展列表。在原列表中末尾处追加一个序列，该序列中的所有元素都会被添加至原列表末尾。返回值为None

格式：[列表].extend（一个序列）

例：扩展列表

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

t = (1,2,3,4,5,6)

l1 = l.extend(t)

print(l1) # 得到复制后的列表

print(l) # 查看原列表

输出结果：

None

['xiaobai', 'lisa', 'Miss_Jing', 'yujiemeigui', 'taidi', 'xiaodi', 'lisa', 1, 2, 3, 4, 5, 6]

图示：

10、reverse()

定义：反向排序列表中的元素，返回值为None。

格式：[列表].reverse（）

例：反向列表中的元素

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.reverse()

print(l1) # 返回值为None

print(l) # 得到反向排序后的列表

输出结果：

None

['lisa', 'xiaodi', 'taidi', 'yujiemeigui', 'Miss_Jing', 'lisa', 'xiaobai']

图示：

11、sort()

定义：对列表进行排序，返回值为None。

有两个可选参数：key和reversekey。

key在使用时必须提供一个排序过程总调用的函数，默认key = None；

reverse实现升降序排序，需要提供布尔值，默认reverse = False

格式：[列表].sort（key = 过程总调用函数，reverse = 布尔值）

例1：将每个元素的首字母以“a-z”的顺序进行排序

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']

l1 = l.sort()

print(l1) # 返回值为None

print(l) # 得到排序后的列表

输出结果：

None

['Miss_Jing', 'lisa', 'lisa', 'taidi', 'xiaobai', 'xiaodi', 'yujiemeigui']

图示：

例2：将每个元素以“0-9”的顺序进行排序.

l = [5,3,2,7,4,1,6]

l1 = l.sort() # 数字按0-9的升序排序。相当于l1 = l.sort(key = None,reverse = False)

print(l1) #返回值为None

print(l) # 查看原列表

输出结果：

None

[1, 2, 3, 4, 5, 6, 7]

图示：

例3：列表中若既有数字又有字符串则不能用sort方法进行排序，否则报错。

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','55',8,9]

l1 = l.sort()

print(l1) #返回值为None

print(l) # 查看原列表

输出结果：

TypeError: '<' not supported between instances of 'int' and 'str'

图示：

例4：将每个字符串元素按长度从短到长的方式进行排序

l = ['xixixixixixixixixi','xixixixixi','xi']

l1 = l.sort(key = len) # 相当于l1 = l.sort(key = len,reverse = False)

print(l1) #返回值为None

print(l) # 查看原列表

输出结果：

None

['xi', 'xixixixixi', 'xixixixixixixixixi']

图示：

例5：将每个字符串元素按长度从长到短的方式进行排序

l = ['xixixixixixixixixi','xixixixixi','xi']

l1 = l.sort(key = len,reverse = True)

print(l1) #返回值为None

print(l) # 查看原列表

输出结果：

None

['xixixixixixixixixi', 'xixixixixi', 'xi']

图示：

二、元组

1、count()

定义：统计指定元素在元组中出现的次数并返回这个数。若指定的元素不存在则返回：0。

格式：(元组).count(“指定的元素”)

例1：统计指定元素在元组中出现的次数

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')

t1 = t.count('lisa')

print(t1)

输出结果：

2

图示：

例2：统计一个不存在元组的中的元素

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')

t1 = t.count('k')

print(t1)

输出结果：

0

图示：

2、index()

定义：查找并返回指定元素的索引位置，若指定的元素不存在则会抛出异常，可以指定范围查找。

格式：(元组).index（“指定元素”，指定范围）

例1：当有多个相同的元素时，按从左到右的顺序，找到第一个元素的索引位置

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')

t1 = t.index('lisa')

print(t1)

输出结果：

1

图示：

例2：按范围查找指定元素的索引位置

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')

t1 = t.index('lisa',2,7) # 按范围查找指定元素的索引位置

print(t1)

输出结果：

6

图示：

例3：查找一个元组中不存在的元素则会抛出异常

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')

t1 = t.index('k')

print(t1)

输出结果：

ValueError: tuple.index(x): x not in tuple

图示：

三、字典

1、keys()

定义：返回字典里的所有的键

格式：{字典}.keys()

例：取出字典中所有的键

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.keys()

print(d1)

输出结果：

dict_keys(['xiaobai', 'lisa', 'daidi', 'yujiemeigui'])

图示：

2、values()

定义：返回字典里的所有的值

格式：{字典}.values()

例：返回字典里的所有的值

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.values()

print(d1)

输出结果：

dict_values([20, 18, 21, 22])

View Code

图示：

3、copy()

定义：拷贝字典，并返回一个浅拷贝后的新字典。

格式：{字典}.copy()

例：拷贝字典

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.copy()

print(d1)

输出结果：

{'xiaobai': 20, 'lisa': 18, 'daidi': 21, 'yujiemeigui': 2

图示：

5、pop()

定义：删除指定键值。返回被删除指定键值的值。

格式：{字典}.pop(指定的键)

例：指定删除一对键值。

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.pop('daidi')

print(d1) # 返回值

print(d)

输出结果：

21{'xiaobai': 20, 'lisa': 18, 'yujiemeigui': 22}

图示：

6、get()

定义：返回指定键的值。若指定的键不存在则返回None

格式：{字典}.get（指定的键）

例1：返回指定键的值

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.get('lisa')

print(d1)

输出结果：

１８

图示：

例2：指定的键不在字典中

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.get('k')

print(d1) #返回None

输出结果：

Ｎone

图示：

7、items()

定义：返回可遍历的（键、值）元组数组

格式：{字典}.items（）

例：返回可遍历的（键、值）元组数组

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.items()

print(d1)

输出结果：

dict_items([('xiaobai', 20), ('lisa', 18), ('daidi', 21), ('yujiemeigui', 22)])

图示：

8、update()

定义：扩展字典，返回值为None

格式：{字典1}.update（{字典2}

例：扩展字典

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = {'x':1,'y':2}

d2 = d.update(d1)

print(d2) # 返回值为None

print(d) # 查看原字典

输出结果：

dict_items([('xiaobai', 20), ('lisa', 18), ('daidi', 21), ('yujiemeigui', 22)])

图示：

9、popitem()

定义：随机删除字典中的一对键和值，并返回被删除的键和值。（一般删除字典末尾的键和值）

格式：{字典}.popitem（）

例：随机删除字典中的一对键和值。

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.popitem()

print(d1) # 返回被随机删除的键和值

print(d) # 查看原字典

输出结果：

('yujiemeigui', 22)

{'xiaobai': 20, 'lisa': 18, 'daidi': 21}

图示：

10、fromkeys()

定义：创建并返回一个新字典，有两个参数：seq和value。

seq是必选参数，表示要传入的序列。

value是可选参数，表示要传入新字典中的值。（若不指定值则生成的新字典所有的值都为None）

格式：{字典}.fromkeys（要传入的序列，指定新字典的值）

例：创建一个新字典

d = {} # 有值也会被覆盖

l1 = ['xiaoxiaobai','xiaobai','daidi']

d1 = d.fromkeys(l1,'sb')

print(d1) # 返回一个新的字典，其中列表“l”的所有元素作为新字典键，值为None

输出结果：

{'xiaoxiaobai': 'sb', 'xiaobai': 'sb', 'daidi': 'sb'}

图示：

11、setdefault()

定义：与get()方法类似。当指定的键存在时则返回它对应的的值；当指定的键不存在时于字典中时，返回值为None，

则将这个键加入到字典里，对应一个空值。

格式：{字典}.setdefault（指定的键）

例1：当指定的键存在字典中时返回这个键的值

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.setdefault('xiaobai')

print(d1) # 返回值

输出结果：

20

图示：

例2：当指定的键不存在字典中时则将这个键添加到字典中，并对应一个空值。

d = {'xiaobai':20,'lisa':18,'daidi':21,'yujiemeigui':22}

d1 = d.setdefault('k')

print(d1) # 返回值

print(d) # 查看原字典

输出结果：

None

{'xiaobai': 20, 'lisa': 18, 'daidi': 21, 'yujiemeigui': 22, 'k': None}

图示：

四、集合

1、update()

定义：扩展集合。返回值为None

格式：{集合}.update({被扩展的集合})

例：扩展集合g1，两个集合中相同的元素将被合并

g1 = {'xiaobai','lisa','daidi','yujiemeigui'}

g2 = {'lisa','xiaodao','xiaozhang','yujiemeigui'}

g = g1.update(g2) # 扩展集合g1

print(g) # 返回值

print(g2) # 原集合

输出结果：

None

{'lisa', 'xiaozhang', 'yujiemeigui', 'xiaodao'}

图示：

图示2：

2、copy()

定义：拷贝集合，并返回一个新的集合。

格式：{集合}.copy（）

例1：拷贝集合

g = {'xiaobai','lisa','daidi','yujiemeigui'}

g1 = g.copy()

print(g1) # 返回值，得到拷贝后的新集合

print(g) # 原集合

输出结果：

{'yujiemeigui', 'xiaobai', 'lisa', 'daidi'}

{'yujiemeigui', 'xiaobai', 'lisa', 'daidi'}

图示：

3、pop()

定义：随机删除集合中的一个元素，并返回这个被删除的元素。

格式：{集合}.pop()

例1：随机删除集合中的一个元素

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.pop()

print(g1) # 返回值

print(g) # 原集合

输出结果：

taidi

{'xiaobai', 'yujiemeigui', 'lisa'}

图示：

4、clear()

定义：清空集合，返回值为None。

格式：{集合}.clear()

例：清空集合

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.clear()

print(g1) # 返回值

print(g) # 原集合

输出结果：

None

set()

图示：

5、remove()

定义：移除指定的元素，返回值为None。被移除的元素若不存在则会抛出异常。

格式：{集合}.remove（指定的元素）

例1：移除指定的元素

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.remove('xiaobai')

print(g1) # 返回值

print(g) # 原集合

输出结果：

None

{'lisa', 'taidi', 'yujiemeigui'}

图示：

6、add()

定义：给集合添加一个元素，返回值为None。

格式：{集合}.add(元素)

例：给集合添加一个元素

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.add('taibai')

print(g1) # 返回值

print(g) # 原集合

输出结果：

None

{'xiaobai', 'yujiemeigui', 'taibai', 'taidi', 'lisa'}

图示：

7、difference()

定义：差集运算，原集合不更新。第一个集合与第二个集合进行差集运算后，那么第一个集合中剩下的元素就是返回值。

格式：{集合1}.difference（{集合2}）

简写：{集合1} - {集合2}

例：集合1对集合2进行差集运算时，返回值则为集合1中与集合2不相同的元素。

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','laowang','zhangpeng'}

g = g1.difference(g2)

print(g) # 返回值

print(g1) # 原集合

输出结果：

{'yujiemeigui'}

{'xiaobai', 'taidi', 'lisa', 'yujiemeigui'}

图示：

差集图示：

8、difference_update()

定义：差集运算，原集合会更新，返回值为None。

格式： {集合1}.difference_update（{集合2}）

例：差集运算，原集合会更新

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','laowang','zhangpeng'}

g = g1.difference_update(g2)

print(g) # 返回值

print(g1) # 原集合

输出结果：

None

{'yujiemeigui'}

图示：

9、discard()

定义：删除集合中指定的元素，返回值为None。若删除一个集合中的不存在的元素也不会抛出异常

格式：{集合}.discard（指定元素）

例1：删除一个指定的元素。

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.discard('taidi')

print(g1) # 返回值

print(g) # 原集合

输出结果：

None

{'lisa', 'yujiemeigui', 'xiaobai'}

图示：

例2：删除一个集合中不存在的元素

g = {'xiaobai','lisa','taidi','yujiemeigui'}

g1 = g.discard('k')

print(g1) # 返回值

print(g) # 原集合

输出结果：

None

{'yujiemeigui', 'lisa', 'taidi', 'xiaobai'}

图示：

10、intersection()

定义：交集运算，原集合不更新。第一个集合与第二个集合进行交集运算后，那么两个集合中相同的元素就是返回值

格式：{集合1}.intersection（{集合2}）

简写：｛集合1｝&｛集合2｝

例：交集运算

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','zhangpeng'}

g = g1.intersection(g2)

print(g) # 返回值

print(g1) # 原集合

输出结果：

{'xiaobai', 'taidi', 'lisa'}

{'yujiemeigui', 'xiaobai', 'taidi', 'lisa'}

图示：

交集图示：

11、intersection_update()

定义：交集运算，原集合会更新，返回值为None。

格式： {集合1}.intersection_update（{集合2}）

例：交集运算，原集合会更新

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','zhangpeng'}

g = g1.intersection_update(g2)

print(g) # 返回值

print(g1) # 原集合

输出结果：

None

{'xiaobai', 'lisa', 'taidi'}

图示：

12、isdisjoint()

定义：判断是否有交集，并返回一个布尔值。有交集则返回False，没有交集则返回True。

格式：{集合1}.isdisjoint（{集合2}）

例1：两个集合有交集时返回False

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','zhangpeng','laowang'}

g = g1.isdisjoint(g2)

print(g) # 返回值

输出结果：

False

图示：

例2：两个集合之间没有交集时返回True

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xx','kk','yy'}

g = g1.isdisjoint(g2)

print(g) # 返回值

输出结果：

True

图示：

13、issubset()

定义：判断一个集合是否为另一个集合的子集，返回布尔值。如果是则返回True，否则返回False，若两个集合相等时，则返回True。

表示这两个集合互为子集。

格式：{集合1}.issubset（{集合2}）

例1：判断是否为子集

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','taidi','lisa','yujiemeigui'}

g = g1.issubset(g2) # g1是g2的子集，所以返回True

print(g)

输出结果：

True

图示：

例2：相同的集合互为子集，也返回True。

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','taidi','yujiemeigui'}

g = g1.issubset(g2) # g1和g2互为子集，所以返回True

print(g)

输出结果：

True

图示：

例3： 若不是子集则返回False。

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','gege','xingxing','bingbing'}

g = g1.issubset(g2) # g1不是g2的子集，所以返回False

print(g)

输出结果：

False

图示：

14、issuperset()

定义：判断一个集合是否为另一个集合的超集（父集），返回一个布尔值。如果是返回True，否则返回False

格式：{集合1}.issuperset（{集合2}）

例1：判断是否为父集

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','gege','xingxing','bingbing'}

g = g1.issuperset(g2) # g1不是g2的父集，所以返回True

print(g)

输出结果：

False

图示：

例2：判断是否为父集

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa',}

g = g1.issuperset(g2) # g1是g2的父集，所以返回True

print(g)

输出结果：

True

图示：

15、symmetric_difference()

定义：对称差集运算，原集合不更新。第一个集合与第二个集合进行对称差集运算后，那么两个集合中不同的元素就是返回值。

格式：{集合1}.symmetric_difference（{集合2}）

简写：｛集合1｝^｛集合2｝

例：对称差集运算

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','laowang','gege','xiaoxue','taibai'}

g = g1.symmetric_difference(g2)

print(g) # 返回值，得到两个集合中的不相同元的素

print(g1) #原集合不改变

输出结果：

{'xiaoxue', 'taidi', 'laowang', 'yujiemeigui', 'gege', 'taibai'}

{'taidi', 'xiaobai', 'lisa', 'yujiemeigui'}

图示：

对称差集图示：

16、symmetric_difference_update()

定义：对称差集运算，原集合更新。返回值为None。

格式：{集合1}.sysmmetric_difference_update（{集合2}）

例：对称差集运算，原集合会更新。

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','laowang','gege','xiaoxue','taibai'}

g = g1.symmetric_difference_update(g2)

print(g) # 返回值为None

print(g1) #原集合

输出结果：

None

{'taibai', 'laowang', 'yujiemeigui', 'xiaoxue', 'gege', 'taidi'}

图示：

17、union()

定义：并集运算，原集合不更新，。第一个集合与第二个集合进行并集运算后，两个集合中的相同元素会被合并，然后把这两个元素中所有的元素组成一个新的集合就是它的返回值

格式：{集合1}.union（{集合2}）

简写：｛集合1｝|｛集合2｝

例：并集运算，原集合不更新

g1 = {'xiaobai','lisa','taidi','yujiemeigui'}

g2 = {'xiaobai','lisa','laowang','gege','xiaoxue','taibai'}

g = g1.union(g2)

print(g) # 返回值，为两个集合中相同元素被合并

print(g1) #原集合不会改变

输出结果：

{'xiaobai', 'lisa', 'xiaoxue', 'gege', 'laowang', 'taidi', 'taibai', 'yujiemeigui'}

{'lisa', 'taidi', 'yujiemeigui', 'xiaobai'}

图示：

并集运算图示：