本节导航：

• ：                 

• ：                                           

---

一、Dictionary 字典

　　字典（dict）是在列表后我们学到的第二种可变的容器模型，可以存储任意类型的对象。字典，顾名思义就像是我们经常使用的新华字典或英语词典一样，具有极快的查找速度，可以帮助我们快速的查找到所需要的东西。在Python中，字典是以键值对（‘key’-'value'）的形式表现的，每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号（{}）中。

　　在这里需要注意的是：dict是无序的；跟多变的 value 不同的是 key 具有唯一性；key 的数据类型必须是固定的不可变的，如：数字、字符串、元组等，而 value 就没有那么多的要求可以为任意的Python数据类型。演示实例如下：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathprint(math_score)           #{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}demo_1 = {
    'Madonna': 89, 1: 'iennvv', 1.34: {
    'Madonna': 89}, ("ifne", "fjie"): [1, 2, 3]}print(demo_1)               #{'Madonna': 89, 1: 'iennvv', 1.34: {'Madonna': 89}, ('ifne', 'fjie'): [1, 2, 3]}demo_2 = {
    'Madonna': 89, {
    'iem': "ofem"}:99}        #TypeError: unhashable type: 'dict'demp_3 = {[1, 2, 3]: 45}                            #TypeError: unhashable type: 'list'

　　这时候我们已经知道如何创建一个正确的字典了，虽然这个创建的这个字典的长度有点惨不容睹，但是它已经属于一个正常的字典了，可以实现索引字典该有的功能，接下来就让我们从“增”“删”“查”“改”四个方面进一步的接触它吧。

“增”：在Python中我们可以通过三种方法实现字典的添加功能：第一种是通过字典名加中括号的方式直接添加，需要用 = 连接 value 值（也可以实现通过 key 对 value 的修改）；第二种是通过 setdefault() ，如果输入的 key 存在于字典中，无论输入的 value 正确与否（也可不输），返回 key 的值，如果 key 不存在于字典之中时，将会把括号内的 key 与 value 自动添加成为字典中一对新的键值对（如果没有 value 的话默认值为 none ）；第三种方法是在有两个字典的前提下存在的，通过内置的 update() 实现将两个字典的合并（如果在两个字典中有相交的键值对就进行覆盖，如果没有就添加到原字典中）。具体演示实例如下：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathmath_score['Baade'] = 77                       #新增一个键值对 'Baade': 77print(math_score)                              #{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89, 'Baade': 77}print(math_score.setdefault('Madonna'))        #89print(math_score.setdefault('Madonna', 22))    #89math_score.setdefault('Aine')                  #'Aine' 不存在字典当中，新建键值对，由于没有设置value，默认为noneprint(math_score)          　　　　　　　　　　   #{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89, 'Baade': 77, 'Aine': None}math_score.setdefault('Mary', 100)             #'Mary' 不存在字典当中，新建键值对print(math_score)     　　　　　　　　　　　　　　　#{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89, 'Baade': 77, 'Aine': None, 'Mary': 100}g = {1:2, 3:4, 'Madonna': 89}                  #新建一个字典 gmath_score.update(g)                           #将新字典 g 并入原字典 math_score 中print(math_score)　　　　　　　　　　　　　　　　　　#{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89, 'Baade': 77, 'Aine': None, 'Mary': 100, 1: 2, 3: 4}

def setdefault(self, k, d=None): # real signature unknown; restored from __doc__        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """        pass    def update(self, E=None, **F): # known special case of dict.update        """        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v        In either case, this is followed by: for k in F:  D[k] = F[k]        """        pass

“删”：与列表相同的是字典当中也提供了多种的“删”方法，只不过具体的内容有所不同。pop()  删除指定的键并返回相应的值，如果字典中没有该键则显示 KeyError 错误；popitem() 打印删除的键值对（以元组的形式返回），随机返回并删除字典中的一对键和值(一般删除末尾对)；clear() 清空字典；del 可以删除字典中的内容或是直接删除字典（参照列表）。具体演示实例如下：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathprint(math_score.pop('Cory'))     #99                   打印删除指定键的值print(math_score)                 #{'Madonna': 89, 'Annie': 65, 'Nelly': 89}print(math_score.popitem())       #('Nelly', 89) 　　　　打印删除的键值对（以元组的形式返回）随机返回并删除字典中的一对键和值(一般删除末尾对)print(math_score)                 #{'Madonna': 89, 'Annie': 65, 'Nelly': 89}math_score.clear()                #清空字典print(math_score)                 #{}math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}del math_score['Madonna']         #删除字典中的 'Madonna'print(math_score)                 #{'Cory': 99, 'Annie': 65, 'Nelly': 89}del math_score                    #直接删除字典 math_scoreprint(math_score)                 #NameError: name 'math_score' is not defined

def pop(self, k, d=None): # real signature unknown; restored from __doc__        """        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.        If key is not found, d is returned if given, otherwise KeyError is raised        """        pass    def popitem(self): # real signature unknown; restored from __doc__        """        D.popitem() -> (k, v), remove and return some (key, value) pair as a        2-tuple; but raise KeyError if D is empty.        """        pass    def clear(self): # real signature unknown; restored from __doc__        """ D.clear() -> None.  Remove all items from D. """        pass

“查”：在字典中我们可以通过 key 查询所对应的 value 值，这也是它最主要的功能之一，这时候有两种方法以供选择：第一种是直接通过字典名加中括号的方式查询，如果 key 值存在则返回其 value 值，如果不存在则报 KeyError 错误；另外一种是直接使用内置的 get() ，在括号内输入 key ，如果 key 存在返回 value 值，否之返回 none 。还有另外两种需求，当我们想要获得字典中所有的 key 时需要用到内置的 key() ，打印字典中的所有 key ，也可以通过 value() 获取字典中所有的 value 值。具体演示实例如下：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathprint(math_score['Madonna'])        #89print(math_score['amd'])         　 #KeyError: 'amd'print(math_score.get('Madonna'))    #89print(math_score.get('Madon'))      #Noneprint(math_score.keys())            #dict_keys(['Madonna', 'Cory', 'Annie', 'Nelly'])print(math_score.values())          #dict_values([89, 99, 65, 89])

def get(self, k, d=None): # real signature unknown; restored from __doc__        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """        pass    def keys(self): # real signature unknown; restored from __doc__        """ D.keys() -> a set-like object providing a view on D's keys """        pass    def values(self): # real signature unknown; restored from __doc__        """ D.values() -> an object providing a view on D's values """        pass

注：还可以用 in 直接判断，key 是否在字典中，但是它只会返回True or False 。

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathprint('Madonna' in math_score)        #True

“改”：字典中的只能通过字典名加中括号的方式进行修改，如果 key 输入出错，则会新建一对键值对。

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathmath_score['Madonna'] = 100         #修改字典中 'Madonna' 对应的 value 值print(math_score)                   #{'Madonna': 100, 'Cory': 99, 'Annie': 65, 'Nelly': 89}math_score['Madna'] = 88            #'Madna' 不在字典中，在字典中创建一个一个新的键值对 'Madna'：88print(math_score)                   #{'Madonna': 100, 'Cory': 99, 'Annie': 65, 'Nelly': 89, 'Madna': 88}

其他：item() 把一个字典转换为列表 ；copy()  浅copy 和在列表中的功能相似，在这里就不做具体陈述了；fromkeys() 返回一个新的命令，它具有可迭代的键值和与值相等的值，简单的来讲就是创建了一个新的字典，逗号前面的为新字典的 key ，后面为每个新字典赋予的 value 值。具体实例如下：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 mathd = math_score.items()        #转换为列表print(d)                      #dict_items([('Madonna', 89), ('Cory', 99), ('Annie', 65), ('Nelly', 89)])b = math_score.copy()         #浅copyprint(b)                      #{'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}c = math_score.fromkeys([1, 2, 3], 'text')        #生产一个新的字典print(c)                      #{1: 'text', 2: 'text', 3: 'text'}e = math_score.fromkeys([1, 2, 3], ['111', 'ss', 'sss'])print(e)                      #{1: ['111', 'ss', 'sss'], 2: ['111', 'ss', 'sss'], 3: ['111', 'ss', 'sss']}

def items(self): # real signature unknown; restored from __doc__        """ D.items() -> a set-like object providing a view on D's items """        pass    def copy(self): # real signature unknown; restored from __doc__        """ D.copy() -> a shallow copy of D """        pass    def fromkeys(*args, **kwargs): # real signature unknown        """ Returns a new dict with keys from iterable and values equal to value. """        pass

注：在 fromkeys() 中有一个小坑，当前面列表中的 key 值有重复的时候它会默认删除多余的（ key 具有唯一性），不会报错。当然这个怎么会属于一个坑呢，这只是 Python 中内部优化的一个体现，在这里我所说的坑是,当使用 fromkeys() 生产一个新的字典时，它的 value 值也属于一种“浅 copy ”，修改一个键值对中的 value 值，其他的 value 值也会随着一起发生变化。

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 matha = math_score.fromkeys([1, 2, 3], ['math', {
    'name':'Nelly'}, 120])     #使用 fromkeys() 在原有的字典中声明一个新的字典 print(a)                #{1: ['math', {'name': 'Nelly'}, 120], 2: ['math', {'name': 'Nelly'}, 120], 3: ['math', {'name': 'Nelly'}, 120]}a[1][0] = 'English'     #修改新字典键为 1 的 value 值print(a)                #{1: ['English', {'name': 'Nelly'}, 120], 2: ['English', {'name': 'Nelly'}, 120], 3: ['English', {'name': 'Nelly'}, 120]}

　　我们在列表中知道可以通过切片或是通过 for 循环的方式进行列表的循环打印，那么在字典中我们该如何来做呢？在这里我就不卖关子了，我们可以通过两种简单的 for 来进行循环打印。与列表不同的是，在打印的时候我们要加上 value 值，不然它只会打印 key 。我就不进行语言的陈述了，直接利用例子来进行展示：

math_score = {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}         #创建一个班级数学成绩字典 math#第一种方法for i in math_score:                #循环打印出字典的 key    print(i)                        #Madonna    Cory    Annie   Nellyfor i in math_score:                #循环打印出字典的 键值对    print(i, math_score[i])         #Madonna 89     Cory 99     Annie 65     Nelly 89#第二种方法for k, v in math_score.items():     #循环打印出字典的 键值对    print(k, v)                     #Madonna 89     Cory 99     Annie 65     Nelly 89

区别：上面一个比下面一个高效很多，因为上面直接通过索引把value值取出来，而下面一个在运算的过程中有把字典转换为列表的过程，明显会造成它的效率降低。

　　在最好我们来学习下字典中最为重要的一个点，那就是字典是可以层层嵌套的（层数无限，相信你也不会闲着无聊建那么多层）。

class_exam_score = {                                #就简单的创建了一个三层的字典，具体的内容有点重复，就凑合看吧    'class_one': {        'math': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'English': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'Chinese': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}    },    'class_two': {        'math': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'English': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'Chinese': {            'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}    },    'class_three': {        'math': {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'English': {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89},        'Chinese': {
    'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}    }}print(class_exam_score)         #{'class_one': {'math': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'English': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'Chinese': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}}, 'class_two': {'math': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'English': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'Chinese': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}}, 'class_three': {'math': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'English': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}, 'Chinese': {'Madonna': 89, 'Cory': 99, 'Annie': 65, 'Nelly': 89}}}print(class_exam_score['class_three']['English']['Madonna'])        #打印三班英语考试中'Madonna'的成绩

二、Sets 集合

 　　写到这里终于快结束了，容我先歇口气！在前面我们一口气学完了列表、元组、字典，是不是感觉自己快炸了，方括号、括号、大括号什么的两脸懵逼，不怂不怕，让暴风雨来的更猛烈些吧！！！接下来进入集合的学习吧：

　　首先需要了解下如何去建立一个新的集合：第一种方法是我们可以通过大括号 {} 内加内容用逗号( , ) 隔开的方式直接创建一个集合；第二种可以使用 set() 方法将已有的列表（或元组）构建成一个无序的集合。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1print(type(list_1))                         #
     
      set_1 = set(list_1)                         #把列表 list_1 转换为集合 set_1print(type(set_1))                          #
      
       print(set_1)                                #{1, 2, 3, 4, 5, 6, 66, 22}print(set((1, 2, 3, 4, 4)))                 #{1, 2, 3, 4}　　　　由元组创建集合set_2 = {1, 3, 3, 4, 4, 77}                 #直接创建一个集合 set_2print(type(set_2))                          #
       
        print(set_2)                                #{1, 3, 4, 5, 77}
       
      
     

　　啊！特么我的值怎么被吃了？怎么变短了那么多？？系统还我的值啊！！！别激动，别激动，冷静下。

　　冷静下来后仔细观察我们就会发现，被“吃”的值是列表（或元组）中重复的东西，这时候我们似乎发现了集合中一个不可告人的大秘密，它好像具有“去重”的功能，是不是很熟悉？对，你猜对了。这点集合跟字典类似，具有“天生去重”（自动把集合内部重复的部分删除）的功能，我们可以理解集合是一个无序的、不重复的数据组合，但是集合与字典也存在明显的不同，我们可以形象的把集合看成只有 key ，不具备存储 value 的功能。

def __init__(self, seq=()): # known special case of set.__init__        """        set() -> new empty set object        set(iterable) -> new set object                Build an unordered collection of unique elements.        # (copied from class doc)        """        pass

注：集合和字典一样是无序的（无法通过数字进行索引），而且内部的数据类型必须是固定的不可变的。

　　除了“天生去重”，集合还可以测试两组数据之间的交集、并集、差集、子集等，与我们初中所学习的集合知识有很大的相同部分，接下来让我一一道来。

交集：交集，顾名思义就是取两个（或多个）集合相交（相同）的部分，然后生成一个新集合。我在这里提供两种求交集的方法：第一我们可以使用内置的 intersection() 方法求取两个集合的交集；还可以直接通过位运算符 & （且）连接两个集合，求取交集。骚年，老夫看你骨骼奇异，再免费送你一种可以判断两个集合是否有交集的办法 isdisjoint() ，不过它有个不好的地方是，它是在两个集合有一个空的交集的时候返回 True ，即当有交集的时候返回 False ，这点可不要弄混了哦。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print(set_1.intersection(set_2))            #{1, 3, 4}      将两个集合的交集作为一个新集合返回。(即两个集合中的相同的部分)print(set_1 & set_2)                        #{1, 3, 4}print(set_1.isdisjoint(set_2))              #False          两个集合有相同的部分。

def intersection(self, *args, **kwargs): # real signature unknown        """        Return the intersection of two sets as a new set.                (i.e. all elements that are in both sets.)        """        pass    def isdisjoint(self, *args, **kwargs): # real signature unknown        """ Return True if two sets have a null intersection. """        pass

差集：将两个或多个集合的差值作为一个新集合返回，我们可以通过 difference() 方法 可以实现这一功能；和交集相同，也可以使用运算符 - 来实现。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print('set_2:', set_2)                      #set_2: {1, 3, 4, 77}print(set_1.difference(set_2))              #{66, 5, 6}print(set_2.difference(set_1))              #{77}print(set_1 - set_2)                        #{66, 5, 6}print(set_2 - set_1)                        #{77}

def difference(self, *args, **kwargs): # real signature unknown        """        Return the difference of two or more sets as a new set.                (i.e. all elements that are in this set but not the others.)        """        pass

注：与交集不同的是，差集中的两个集合前后有顺序关系，可以理解为到底是谁减谁，前后顺序不同会导致结果的差异。

并集：与交集相同，并集中没有前后集合的位置关系，即无论哪个在前哪个在后结果相同。Python中也提供了两种方法来求集合的并集，union() 返回不同集合的所有元素形成一个新集合；也可以使用位运算符 | （并）来实现。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print('set_2:', set_2)                      #set_2: {1, 3, 4, 77}print(set_1.union(set_2))                   #{1, 66, 3, 4, 5, 6, 77}print(set_2.union(set_1))                   #{1, 66, 3, 4, 5, 6, 77}print(set_1 | set_2)                        #{1, 66, 3, 4, 5, 6, 77}

def union(self, *args, **kwargs): # real signature unknown        """        Return the union of sets as a new set.                (i.e. all elements that are in either set.)        """        pass

子集：可以通过 issubset() 方法确定另外一个集合是否包含此集合（括号内的元素是否包含前一个元素内），如果包含返回 True 。形象记忆：在前面一个是“儿子”后面一个是“爸爸”的情况下返回 True 。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print('set_2:', set_2)                      #set_2: {1, 3, 4, 77}set_3 = {1, 3}print(set_1.issubset(set_2))                #Falseprint(set_3.issubset(set_1))                #Trueprint(set_1.issubset(set_3))                #False

def issubset(self, *args, **kwargs): # real signature unknown        """ Report whether another set contains this set. """        pass

父集：通过 issuperset() 来确定这个集合是否包含另外一个集合，即当前面一个是“爸爸”后面一个是“儿子”的情况下返回 True 。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print('set_2:', set_2)                      #set_2: {1, 3, 4, 77}set_3 = {1, 3}print(set_1.issuperset(set_2))              #False         print(set_1.issuperset(set_3))              #True

def issuperset(self, *args, **kwargs): # real signature unknown        """ Report whether this set contains another set. """        pass

对称差集：将两个集合的对称差作为一个新集合返回。是不是感觉很懵逼，别怕，还有我在，说白了对称差集就是把两个集合中不同的部分拿出来形成一个新的集合。可以使用 symmetric_difference() 或运算符 ^ 来实现对称差集，集合放置没有前后顺序。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)set_2 = {1, 3, 3, 4, 4, 77}                 #直接定义一个集合 set_2print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print('set_2:', set_2)                      #set_2: {1, 3, 4, 77}print(set_1.symmetric_difference(set_2))            #{66, 5, 6, 77}print(set_1 ^ set_2)                                #{66, 5, 6, 77}

def symmetric_difference(self, *args, **kwargs): # real signature unknown        """        Return the symmetric difference of two sets as a new set.                (i.e. all elements that are in exactly one of the sets.)        """        pass

“增”：add() 向集合中添加单个元素，如果如果元素已经存在，则没有效果；update() 向集合中添加多个元素，效果和add() 类似。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}set_1.add(7777)                             #添加元素 7777print(set_1)                                #{1, 66, 3, 4, 5, 6, 7777}set_1.add(66)                               #添加元素 66print(set_1)                                #{1, 66, 3, 4, 5, 6, 7777}set_1.update([1, 222, 3333])                # 添加多项print(set_1)                                #{1, 66, 3, 4, 5, 6, 7777, 3333, 222}

def add(self, *args, **kwargs): # real signature unknown        """        Add an element to a set.                This has no effect if the element is already present.        """        pass    def update(self, *args, **kwargs): # real signature unknown        """ Update a set with the union of itself and others. """        pass

“删”：集合中我们可以选择好多种不同的删除的方法，remove() 删除括号内的指定元素，如果该元素不在集合内，则报错；pop()  随意删除一个集合内的元素，并返回其删除的值；discard() 删除括号内的指定元素，如果该元素是集合的一个成员，从集合中移除这个元素，否则什么都不做，返回None；剩下的就是clear() 和 del 了，用法和前面相同就不具体描述了。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)                         #将列表转换为集合print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}set_1.remove(1)                    　　　　　#指定删除一个元素，如果不出在会报错print(set_1)                   　　　　      #{66, 3, 4, 5, 6}print(set_1.pop())              　          #66     #随意删除一个并返回删除的值，括号内不需要输入内容print(set_1)                      #{3, 4, 5, 6}print(set_1.discard(1))           #None       #删除指定值，如果指定值在不在它都不会报错，打印的话只会返回noneprint(set_1)                      #{3, 4, 5, 6}print(set_1.discard(3))           #Noneprint(set_1)                      #{3, 4, 5, 6}set_1.clear()                     #清空集合print(set_1)                      #set()del set_1                         #删除集合print(set_1)                      #NameError: name 'set_1' is not defined

def remove(self, *args, **kwargs): # real signature unknown        """        Remove an element from a set; it must be a member.                If the element is not a member, raise a KeyError.        """        pass    def pop(self, *args, **kwargs): # real signature unknown        """        Remove and return an arbitrary set element.        Raises KeyError if the set is empty.        """        pass    def discard(self, *args, **kwargs): # real signature unknown        """        Remove an element from a set if it is a member.                If the element is not a member, do nothing.        """        pass    def clear(self, *args, **kwargs): # real signature unknown        """ Remove all elements from this set. """        pass

“查”：在集合中我们只能通过in 或是 not  in 来判断，一个元素是否在集合中。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)                         #将列表转换为集合print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print(1 in set_1)                           #Trueprint(3 not in set_1)                       #False

集合的比较：通过运算符 < > == 比较两个集合的关系，返回True 或False。与判断子、父集类似，可以用来判断子集和父集。

set_1 = {1, 3, 5, 777}set_2 = {1, 3}print(set_1 < set_2)            # False           print(set_1 == set_2)           # False      print(set_1 > set_2)            # True

“其他”：len() 获取集合的长度（集合内元素的个数）；copy() 浅copy。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)                         #将列表转换为集合print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}print(len(set_1))                           #6set_2 = set_1.copy()                        #浅copyprint(set_2)                                #{1, 66, 3, 4, 5, 6}

未知的三个东东：哎，这三个真是不怎么在干嘛，无论怎么的蹂躏他们，要么返回 None，要么报错，关键就是它不跟我们玩，实在不知道用在什么地方，欢迎一起探讨。

list_1 = [1, 3, 4, 5, 6, 66, 3, 6]          #创建一个列表 list_1set_1 = set(list_1)                         #将列表转换为集合print('set_1:', set_1)                      #set_1: {1, 66, 3, 4, 5, 6}set_2 = {1, 3, 3, 4, 4, 77}print(set_1.intersection_update(set_2))             #Noneprint(set_1.difference_update(set_2))               #Noneprint(set_1.symmetric_difference_update(set_1))     #None

def intersection_update(self, *args, **kwargs): # real signature unknown        """ Update a set with the intersection of itself and another. """        pass    def difference_update(self, *args, **kwargs): # real signature unknown        """ Remove all elements of another set from this set. """        pass    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown        """ Update a set with the symmetric difference of itself and another. """        pass

延伸：当面海量列表数据时，怎样做才能删除列表中重复的元素呢？这里就提供一种解决的方法，具体演示代码如下：

a = [1, 2, 3, 43, 31, 2]         　　 #新建一个列表b = set(a)                           #将列表转为集合print(b)                             #{1, 2, 3, 43, 31}c = [i for i in b]                   #循环集合print(c)                             #[1, 2, 3, 43, 31]