一、列表

温馨提示：对图片点右键——在新标签页中打开图片：

1、count()

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

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

例：统计指定元素的个数

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.count('dark_knight')
  3. print(l1)

输出结果：

  1. 2

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.count('x') # 指定一个不存在的元素
  3. print(l1)

输出结果：

  1.  0

图示：

2、index()

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

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.index('dark_knight')
  3. print(l1)

输出结果：

  1. 0

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.index('dark_knight',2,7)  # 查找索引2到6的范围，顾首不顾尾
  3. print(l1)

输出结果：

  1. 6

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.index('x') # 查找一个列表中不存在的元素
  3. print(l1)

输出结果：

  1. ValueError: 'x' is not in list

图示：

　　

3、pop()

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

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.pop() # 默认移除列表中的最后一个元素
  3. print(l1)    #　返回这个被移除的元素
  4. print(l)     # 查看原列表

输出结果：

  1. dark_knight
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila']

图示：

例2：移除指定的元素

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.pop(2) # 移除列表中索引位置为2的元素
  3. print(l1)    #　返回这个被移除的元素
  4. print(l)     # 查看原列表

输出结果：

  1. Miss_Jing
  2. ['dark_knight', 'lisa', '老张', '糖宝', 'copila', 'dark_knight']

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.pop(10) # 移除列表中索引位置为10的元素，但列表中的元素没有索引位置为10的元素
  3. print(l1)    #　返回这个被移除的元素
  4. print(l)     # 查看原列表

输出结果：

  1. IndexError: pop index out of range

图示：

4、remove()

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

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

例1：移除指定元素

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.remove('dark_knight')
  3. print(l1)    #　返回值为None
  4. print(l)     #  打印原列表

输出结果：

  1. None
  2. ['lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight']

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.remove('x')
  3. print(l1)
  4. print(l)     #  查看原列表

输出结果：

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

图示：

5、insert()

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

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.insert(5,'暗黑骑士') # 将字符串“暗黑骑士”插入至“coplia”前面
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', '暗黑骑士', 'copila', 'dark_knight']

图示：

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.insert(20,'暗黑骑士') # 将字符串“暗黑骑士”插入索引位置为20的地方
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight', '暗黑骑士']

图示：

6、append()

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

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.append('暗黑骑士')
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight', '暗黑骑士']

图示：

7、clear()

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

格式：[列表].clear（）

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

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.clear()
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. []

图示：

8、copy()

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

格式：[列表].copy（）

例：拷贝一个列表

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.copy()
  3. print(l1)    # 得到复制后的新列表
  4. print(l)     # 查看原列表

输出结果：

  1. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight']
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight']

图示：

9、extend()

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

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

例：扩展列表

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. t = (1,2,3,4,5)
  3. l1 = l.extend(t)
  4. print(l1)    # 得到复制后的新列表
  5. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['dark_knight', 'lisa', 'Miss_Jing', '老张', '糖宝', 'copila', 'dark_knight', 1, 2, 3, 4, 5]

图示：

10、reverse()

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

格式：[列表].reverse（）

例：反向列表中的元素

  1. l = ['dark_knight','lisa','Miss_Jing','老张','糖宝','copila','dark_knight']
  2. l1 = l.reverse()
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['dark_knight', 'copila', '糖宝', '老张', 'Miss_Jing', 'lisa', 'dark_knight']

图示：

11、sort()

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

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

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

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

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','copila','dark_knight']
  2. l1 = l.sort() # 相当于：l1 = l.sort(key = None,reverse = False)
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['Miss_Jing', 'copila', 'dark_knight', 'dark_knight', 'lisa']

图示：

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

  1. l = [5,3,2,7,4,1,6]
  2. l1 = l.sort()   # 数字按0-9的升序排序。相当于l1 = l.sort(key = None,reverse = False)
  3. print(l1)       # 返回值为None
  4. print(l)        # 查看原列表

输出结果：

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

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

  1. l = ['dark_knight','lisa','Miss_Jing','copila',8,7,6]
  2. l1 = l.sort()
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

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

图示：

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

  1. l = ['hahahahaha','hahaha','hahahaha','ha']
  2. l1 = l.sort(key = len) # 相当于l1 = l.sort(key = len,reverse = False)
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['ha', 'hahaha', 'hahahaha', 'hahahahaha']

图示：

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

  1. l = ['hahahahaha','hahaha','hahahaha','ha']
  2. l1 = l.sort(key = len,reverse=True)
  3. print(l1)    # 返回值为None
  4. print(l)     # 查看原列表

输出结果：

  1. None
  2. ['hahahahaha', 'hahahaha', 'hahaha', 'ha']

图示：

二、元组

1、count()

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

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

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

  1. t = ('dark_knight','lisa','Miss_Jing','老张','糖宝','dark_knight')
  2. t1 = t.count('dark_knight')
  3. print(t1)

输出结果：

  1.  2

图示：

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

  1. t = ('dark_knight','lisa','Miss_Jing','老张','糖宝','dark_knight')
  2. t1 = t.count('x')
  3. print(t1)

输出结果：

  1. 0

图示：

2、index()

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

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

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

  1. t = ('dark_knight','lisa','Miss_Jing','老张','糖宝','dark_knight')
  2. t1 = t.index('dark_knight')
  3. # 当一个元组中有多个相同的元素时，按从左到右的顺序，找到第一个元素的索引位置
  4. print(t1)

输出结果：

  1. 0

图示：

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

  1. t = ('dark_knight','lisa','Miss_Jing','老张','糖宝','dark_knight')
  2. t1 = t.index('dark_knight',2,6) # 按范围查找指定元素的索引位置
  3. print(t1)

输出结果：

  1. 5

图示：

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

  1. t = ('dark_knight','lisa','Miss_Jing','老张','糖宝','dark_knight')
  2. t1 = t.index('x')
  3. print(t1)

输出结果：

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

图示：

三、字典 

1、keys()

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

格式：{字典}.keys()

例：取出字典中所有的键

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.keys()
  3. print(d1)

输出结果：

  1. dict_keys(['dark_knight', 'lisa', 'copila', '糖宝', '老张', 'Miss_Jing'])

图示：

2、values()

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

格式：{字典}.values()

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.values()
  3. print(d1)

输出结果：

  1. dict_values([28, 28, 50, 21, 21, 24])

图示：

3、copy()

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

格式：{字典}.copy()

例：拷贝字典

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.copy()
  3. print(d1)

输出结果：

  1. {'dark_knight': 28, 'lisa': 28, 'copila': 50, '糖宝': 21, '老张': 21, 'Miss_Jing': 24}

图示：

4、clear()

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

格式：{字典}.clear()

例：清空字典中所有的元素

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.clear()
  3. print(d1) # 返回值
  4. print(d)

输出结果：

  1. None
  2. {}

图示：

5、pop()

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

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

例：指定删除一对键值。

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.pop('copila')
  3. print(d1) # 返回值
  4. print(d)

输出结果：

  1. 50
  2. {'dark_knight': 28, 'lisa': 28, '糖宝': 21, '老张': 21, 'Miss_Jing': 24}

图示：

6、get()

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

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

例1：返回指定键的值

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.get('copila')
  3. print(d1)

输出结果：

  1. 50

图示：

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.get('x')
  3. print(d1)

输出结果：

  1. None

图示：

7、items()

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

格式：{字典}.items（）

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.items()
  3. print(d1)

输出结果：

  1. dict_items([('dark_knight', 28), ('lisa', 28), ('copila', 50), ('糖宝', 21), ('老张', 21), ('Miss_Jing', 24)])

图示：

8、update()

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

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

例：扩展字典

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = {'x':1,'y':2}
  3. d2 = d.update(d1)
  4. print(d2)  # 返回值为None
  5. print(d)   # 查看原字典

输出结果：

  1. None
  2. {'dark_knight': 28, 'lisa': 28, 'copila': 50, '糖宝': 21, '老张': 21, 'Miss_Jing': 24, 'x': 1, 'y': 2}

图示：

9、popitem()

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

格式：{字典}.popitem（）

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.popitem()
  3. print(d1)  # 返回被随机删除的键和值
  4. print(d)   # 查看原字典

输出结果：

  1. ('Miss_Jing', 24)   # 这个结果是随机删除，有变化的
  2. {'dark_knight': 28, 'lisa': 28, 'copila': 50, '糖宝': 21, '老张': 21}

图示：

10、fromkeys()

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

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

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

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

例：创建一个新字典

  1. d = {} # 有值也会被覆盖
  2. l1 = ['copila', '糖宝', '老张']
  3. d1 = d.fromkeys(l1,'SB')
  4. print(d1)
  5. # 返回一个新的字典，其中列表“l”的所有元素作为新字典键，值为None

输出结果：

  1. {'copila': 'SB', '糖宝': 'SB', '老张': 'SB'}

图示：

11、setdefault()

定义：与get()方法类似。当指定的键存在时则返回它对应的的值；当指定的键不存在时于字典中时，返回值为None，则将这个键加入到字典里，对应一个空值。

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

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.setdefault('copila')
  3. print(d1)  # 返回值

输出结果：

  1. 50

图示：

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

  1. d = {'dark_knight':28,'lisa':28,'copila':50,'糖宝':21,'老张':21,'Miss_Jing':24}
  2. d1 = d.setdefault('x')
  3. print(d1)  # 返回值
  4. print(d)   # 查看原字典

输出结果：

  1. None
  2. {'dark_knight': 28, 'lisa': 28, 'copila': 50, '糖宝': 21, '老张': 21, 'Miss_Jing': 24, 'x': None}

图示：

例3：若指定的键存在则不会修改值

  1. d = {'x':1,'y':2,'z':3}
  2. d.setdefault('x',3333333333)
  3. print(d)

输出结果：

  1. {'x': 1, 'y': 2, 'z': 3}

图示：

例4：若指定的键不存在则会添加键和值

  1. d = {'x':1,'y':2,'z':3}
  2. d.setdefault('haha',3333333333)
  3. print(d)

输出结果：

  1. {'x': 1, 'y': 2, 'z': 3, 'haha': 3333333333}

图示：

四、集合

1、update()

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

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

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.update(g2) # 扩展集合g1，
  4. print(g)   # 返回值
  5. print(g1)  # 原集合

输出结果：

  1. None
  2. {'Miss_Jing', '谢公子', 'william', 'dark_knight', '糖宝', '老张', 'lisa'}

图示1：

图示2：

2、copy()

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

格式：{集合}.copy（）

例1：拷贝集合

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.copy()
  3. print(g1)   # 返回值，得到拷贝后的新集合
  4. print(g)  # 原集合

输出结果：

  1. {'老张', 'lisa', 'dark_knight', 'Miss_Jing'}
  2. {'老张', 'lisa', 'dark_knight', 'Miss_Jing'}

图示：

3、pop()

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

格式：{集合}.pop()

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

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.pop()
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. 老张
  2. {'dark_knight', 'lisa', 'Miss_Jing'}

图示：

4、clear()

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

格式：{集合}.clear()

例：清空集合

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.clear()
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. None
  2. set()

图示：

5、remove()

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

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

例1：移除指定的元素

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.remove('Miss_Jing')
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. None
  2. {'老张', 'lisa', 'dark_knight'}

图示：

6、add()

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

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

例：给集合添加一个元素

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.add('copila')
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. None
  2. {'lisa', '老张', 'Miss_Jing', 'dark_knight', 'copila'}

图示：

7、difference()

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

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

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

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.difference(g2)
  4. # g = g1 - g2     # 简写
  5. print(g)   # 返回值
  6. print(g1)  # 原集合

输出结果：

  1. {'lisa', 'Miss_Jing'}
  2. {'lisa', 'Miss_Jing', '老张', 'dark_knight'}

图示1：

差集图示：

8、difference_update()

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

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

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.difference_update(g2)
  4. print(g)   # 返回值
  5. print(g1)  # 原集合

输出结果：

  1. None
  2. {'lisa', 'Miss_Jing'

图示：

9、discard()

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

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

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

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.discard('lisa')
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. None
  2. {'老张', 'dark_knight', 'Miss_Jing'}

图示：

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

  1. g = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g1 = g.discard('x') # 删除一个集合中不存在的元素
  3. print(g1)   # 返回值
  4. print(g)  # 原集合

输出结果：

  1. None
  2. {'lisa', 'dark_knight', 'Miss_Jing', '老张'}

图示：

10、intersection()

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

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

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

例：交集运算

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.intersection(g2)
  4. # g = g1 & g2
  5. print(g)   # 返回值
  6. print(g1)  # 原集合

输出结果：

  1. {'老张', 'dark_knight'}
  2. {'老张', 'dark_knight', 'Miss_Jing', 'lisa'}

图示：

交集图示：

11、intersection_update()

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

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

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.intersection_update(g2)
  4. print(g)   # 返回值
  5. print(g1)  # 原集合

输出结果：

  1. None
  2. {'dark_knight', '老张'}

图示：

12、isdisjoint()

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

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

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'糖宝','老张','dark_knight','william','谢公子'}
  3. g = g1.isdisjoint(g2)
  4. print(g)   # 返回值

输出结果：

  1. False

图示：

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

  1. g1 = {'dark_knight','lisa','老张','Miss_Jing'}
  2. g2 = {'xxx','yyy','zzz'}
  3. g = g1.isdisjoint(g2)
  4. print(g)   # 返回值

输出结果：

  1. True

图示：

13、issubset()

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

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

例1：判断是否为子集

  1. g1 = {'dark_knight','pudding'}
  2. g2 = {'dark_knight','lisa','knight','pudding'}
  3. g = g1.issubset(g2)    # g1是g2的子集，所以返回True
  4. print(g)

输出结果：

  1. True

图示：

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

  1. g1 = {'dark_knight','lisa','knight','pudding'}
  2. g2 = {'dark_knight','lisa','knight','pudding'}
  3. g = g1.issubset(g2)    # g1和g2互为子集，所以返回True
  4. print(g)　

输出结果：

  1. True

图示：

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

  1. g1 = {'xxxx','yyyyy'}
  2. g2 = {'dark_knight','lisa','knight','pudding'}
  3. g = g1.issubset(g2)    # g1不是g2的子集，所以返回False
  4. print(g)　　

输出结果：

  1. False

图示：

14、issuperset()

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

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

例1：判断是否为父集

  1. g1 = {'dark_knight','pudding'}
  2. g2 = {'dark_knight','lisa','knight','pudding'}
  3. g = g1.issuperset(g2)    # g1不是g2的父集，所以返回True
  4. print(g)

输出结果：

  1. False

图示：

例2：判断是否为父集

  1. g1 = {'dark_knight','lisa','knight','pudding'}
  2. g2 = {'dark_knight','pudding'}
  3. g = g1.issuperset(g2)    # g1是g2的父集，所以返回True
  4. print(g)

输出结果：

  1. True

图示：

15、symmetric_difference()

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

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

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

例：对称差集运算

  1. g1 = {'dark_knight','pudding','Miss_Jing'}
  2. g2 = {'dark_knight','lisa','knight','pudding','糖宝','老张'}
  3. g = g1.symmetric_difference(g2)
  4. print(g)    # 返回值，得到两个集合中的不相同元的素
  5. print(g1)   # 原集合不改变

输出结果：

  1. {'knight', 'Miss_Jing', 'lisa', '老张', '糖宝'}
  2. {'pudding', 'dark_knight', 'Miss_Jing'}

图示：

对称差集图示：

16、symmetric_difference_update()

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

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

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

  1. g1 = {'dark_knight','pudding','Miss_Jing'}
  2. g2 = {'dark_knight','lisa','knight','pudding','糖宝','老张'}
  3. g = g1.symmetric_difference_update(g2)
  4. print(g)    # 返回值
  5. print(g1)   # 原集合　　

输出结果：

  1. None
  2. {'糖宝', 'knight', '老张', 'lisa', 'Miss_Jing'}

图示：

17、union()

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

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

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

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

  1. g1 = {'dark_knight','pudding','Miss_Jing'}
  2. g2 = {'dark_knight','lisa','knight','pudding','糖宝','老张'}
  3. g = g1.union(g2)
  4. print(g)    # 返回值
  5. print(g1)   # 原集合不会被改变

输出结果：

  1. {'dark_knight', 'pudding', 'lisa', '糖宝', 'knight', '老张', 'Miss_Jing'}
  2. {'dark_knight', 'pudding', 'Miss_Jing'}

图示：

并集运算图示：

Python3列表、元组、字典、集合的方法的更多相关文章

  1. python3笔记十八：python列表元组字典集合文件操作

    一:学习内容 列表元组字典集合文件操作 二:列表元组字典集合文件操作 代码: import pickle  #数据持久性模块 #封装的方法def OptionData(data,path):    # ...

  2. python中列表 元组 字典 集合的区别

    列表 元组 字典 集合的区别是python面试中最常见的一个问题.这个问题虽然很基础,但确实能反映出面试者的基础水平. (1)列表 什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单.比如,统计 ...

  3. **python中列表 元组 字典 集合

    列表 元组 字典 集合的区别是python面试中最常见的一个问题.这个问题虽然很基础,但确实能反映出面试者的基础水平. 1.列表 列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔. 列表的特 ...

  4. python_列表——元组——字典——集合

    列表——元组——字典——集合: 列表: # 一:基本使用# 1.用途:存放多个值 # 定义方式:[]内以逗号为分隔多个元素,列表内元素无类型限制# l=['a','b','c'] #l=list([' ...

  5. Day 07 数据类型的内置方法[列表,元组,字典,集合]

    数据类型的内置方法 一:列表类型[list] 1.用途:多个爱好,多个名字,多个装备等等 2.定义:[]内以逗号分隔多个元素,可以是任意类型的值 3.存在一个值/多个值:多个值 4.有序or无序:有序 ...

  6. python的学习笔记01_4基础数据类型列表 元组 字典 集合 其他其他（for，enumerate，range)

    列表 定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素 特性: 1.可存放多个值 2.可修改指定索引位置对应的值,可变 3.按照从左到右的顺序定义列表元素,下标从0开始顺序访问 ...

  7. python 中列表 元组 字典 集合的区别

    先看图片解释 (1)列表 什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单.比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单.由于我们买一种东西可能不止一次,所以清单中是允许有重复 ...

  8. Python 列表&元组&字典&集合

    列表(list) 有序性,可存储任意类型的值 通过偏移存取,支持索引来读取元素,第一个索引为0 ,倒数第一个索引为-1 可变性 ,支持切片.合并.删除等操作 可通过索引来向指定位置插入元素 可通过po ...

  9. python的列表元组字典集合比较

    定义 方法 列表 可以包含不同类型的对象,可以增减元素,可以跟其他的列表结合或者把一个列表拆分,用[]来定义的 eg:aList=[123,'abc',4.56,['inner','list'],7- ...

  10. Python列表,元组,字典,集合详细操作

    菜鸟学Python第五天 数据类型常用操作及内置方法 列表(list) ======================================基本使用====================== ...

随机推荐

  1. oracle 9i/10g/11g(11.2.0.3)安装包和PATCH下载地址汇总

    今天上PUB看见一位热心人汇总了这么个地址列表,转发来空间: 把下面的地址复制到讯雷里就可以下载. -------------------------------------------------- ...

  2. 我是一个线程 - IBM刘欣

    来自:码农翻身(微信号:coderising) 作者:IBM刘欣 我是一个线程,我一出生就被编了个号: 0×3704,然后被领到一个昏暗的屋子里, 这里我发现了很多和我一模一样的同伴. 我身边的同伴0 ...

  3. controller跳到另一个controller

    1.无参数: return "redirect:park/findByTag"; 2/有参数: public String addChild(Model model2) model ...

  4. Spring Boot修改Thymeleaf版本（从Thymeleaf2.0到3.0）

    Spring Boot默认选择的Thymeleaf是2.0版本的,那么如果我们就想要使用3.0版本或者说指定版本呢,那么怎么操作呢?在这里要说明下 3.0的配置在spring boot 1.4.0+才 ...

  5. EXTJS中整合tinymce的富文本编辑器，添加上传图片功能

    提供部分代码.Ext.create('Ext.window.Window', { id: 'wind', title: 'CRUD窗口', modal: true, height: 800, widt ...

  6. @Retention n. 保留

    @Retention n. 保留 学习了:https://blog.csdn.net/asdgbc/article/details/70196749 默认都是保留到class中,而在runtime中没 ...

  7. 万恶之源：C语言中的隐式函数声明

    1 什么是C语言的隐式函数声明 在C语言中,函数在调用前不一定非要声明.如果没有声明,那么编译器会自己主动依照一种隐式声明的规则,为调用函数的C代码产生汇编代码.以下是一个样例: int main(i ...

  8. Android调试工具_ Stetho

    Stetho是Facebook开源的一个Android平台调试工具. Stetho能实如今不root手机的情况下,通过Chrome查看App的布局,Sqlite,SharedPreference.Ne ...

  9. JS 省市区三级联动

    JS 省市区三级联动: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http:/ ...

  10. 【转载】TCP和TCP/IP的区别

    TCP/IP协议(Transmission Control Protocol/Internet Protocol)叫做传输控制/网际协议, 又叫网络通讯协议,这个协议是Internet国际互联网络的基 ...