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

一、列表

1、count()

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

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

例：统计指定元素的个数

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']
l1 = l.count('xiaobai')
print(l1)

输出结果：

图示：

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

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']
l1 = l.count('k')  #指定一个不存在的元素
print(l1)

输出结果：

图示：

2、index()

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

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

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

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi']
l1 = l.index('lisa')
print(l1)

输出结果：

图示：

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

l = ['xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa']
l1 = l.index('lisa',2,7)  ## 查找索引2到7的范围，顾首不顾尾
print(l1)

输出结果：

图示：

例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：统计一个不存在元组的中的元素

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')
t1 = t.count('k')
print(t1)

输出结果：

图示：

2、index()

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

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

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

t = ('xiaobai','lisa','Miss_Jing','yujiemeigui','taidi','xiaodi','lisa')
t1 = t.index('lisa')
print(t1)

输出结果：

图示：

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

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

输出结果：

图示：

例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) # 返回值

输出结果：

图示：

例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'}

图示：

并集运算图示：

posted @ 2017-06-25 14:50 御姐玫瑰阅读(1047) 评论(0) 编辑收藏举报

刷新页面返回顶部

御姐玫瑰

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

一、列表

1、count()

2、index()

3、pop()

4、remove()

5、insert()

6、append()

7、clear()

8、copy()

9、extend()

10、reverse()

11、sort()

二、元组

1、count()

2、index()

三、字典

1、keys()

2、values()

3、copy()

5、pop()

6、get()

7、items()

8、update()

9、popitem()

10、fromkeys()

11、setdefault()

四、集合

1、update()

2、copy()

3、pop()

4、clear()

5、remove()

6、add()

7、difference()

8、difference_update()

9、discard()

10、intersection()

11、intersection_update()

12、isdisjoint()

13、issubset()

14、issuperset()

15、symmetric_difference()

16、symmetric_difference_update()

17、union()

公告