Day8之列表、字典、元组、集合的内置方法

亦凉 2021-10-29 20:20 301阅读 0赞

今天一整天都没有拉屎，我很难受，一点状态都没有  
![timg?image&quality=80&size=b9999\_10000&sec=1565617749&di=a82d8cab8e8ccc4680d9684f2be328ce&imgtype=jpg&er=1&src=http%3A%2F%2Fwx2.sinaimg.cn%2Forj360%2F7a158a79gy1foy0kv19sdj20hs0icwg0.jpg][timg_image_quality_80_size_b9999_10000_sec_1565617749_di_a82d8cab8e8ccc4680d9684f2be328ce_imgtype_jpg_er_1_src_http_3A_2F_2Fwx2.sinaimg.cn_2Forj360_2F7a158a79gy1foy0kv19sdj20hs0icwg0.jpg]

还好学习没有阻塞。

今天的憨憨们有没有给自己打气呀，上图  
![o\_0%5D90O5AYLDR3C0%7DIE0IKG~G.jpg][o_0_5D90O5AYLDR3C0_7DIE0IKG_G.jpg]  
每天都要相信自己，一定要有相信的东西。

今日洗脑金句： 心若不狠，战意不稳，天天狂刷题，心停手不停。

# 一、列表类型内置方法 #

1.用途：多个东西，什么东西呢，多个女朋友啊，多个男朋友啊，多个乱七八糟的。

2.定义：\[\]内可以有多个任意类型的值，用逗号分隔每个元素

my_girl_friend = ['韩红', '凤姐', '钟源']
    print(f"my_girl_friend: {my_girl_friend}")

my\_girl\_friend: \['韩红', '凤姐', '钟源'\]

就这么回事，可以通过索引来取值，之前都讲过很多次了，你在不懂我就生气了。

## 1.1优先掌握 ##

1.  按索引取值（正向取值+反向取值），即可存也可以取
2.  切片
3.  长度len
4.  成员运算in和not in
5.  追加append
6.  删除del
7.  循环

1.按索引取值(正向取值+反向取值)，即可以存也可以取

# list之索引取值
    name_list = ['力哥', 'jason', 'tank', 'sean']
    name_list[0] = '力哥 炸帅'
    # name_list[1000] = 'tank sb'  # 报错
    
    print(f"name_list[0]: {name_list[0]}")

name\_list\[0\]: 力哥 炸帅

2.切片

# list之切片
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list[0:3:2]: {name_list[0:3:2]}")

name\_list\[0:3:2\]: \['nick', 'tank'\]

这个方法和字符串一样儿一样儿的，一毛一样，对。

3.长度

# list之长度
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"len(name_list): {len(name_list)}")

len(name\_list): 4

都是基本操作

4.成员运算in和not in

# list之成员运算in和not in
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"'tank sb' in name_list: {'tank sb' in name_list}")
    print(f"'nick handsome' not in name_list: {'nick handsome' not in name_list}")
    'tank sb' in name_list: False

'nick handsome' not in name\_list: True

基本基本~

5.追加值

# list之追加值
    name_list = ['nick', 'jason', 'tank', 'sean']
    name_list.append('tank sb')
    
    print(f"name_list: {name_list}")

name\_list: \['nick', 'jason', 'tank', 'sean', 'tank sb'\]

这个就是列表独有的内置方法了，这个方法有点好用哦，他是什么意思呢，就是你在这个方法体内写入一个参数，就会被追加到调用这个方法的对象的屁股上去，对，最后，屁股的位置![o\_1564572232(1).jpg][o_1564572232_1_.jpg]

6.删除

# list之删除
    name_list = ['nick', 'jason', 'tank', 'sean']
    del name_list[2]
    
    print(f"name_list: {name_list}")

name\_list: \['nick', 'jason', 'sean'\]

同样的，基本操作，注意，这是通过索引来删除的，如果你的索引超过了他的范围，就会报错。

7.循环

# list之循环
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    for name in name_list:
        print(name)

nick  
jason  
tank  
sean

## 1.2需要掌握 ##

1.  insert
2.  pop
3.  remove
4.  count
5.  index
6.  clear
7.  copy
8.  extend
9.  reverse
10. sort

好了让我们来看看这些需要掌握的方法都是些什么玩意儿

![u=3692908877,226061635&fm=15&gp=0.jpg][u_3692908877_226061635_fm_15_gp_0.jpg]

1.insert()

# list之insert()
    name_list = ['nick', 'jason', 'tank', 'sean']
    name_list.insert(1, 'handsome')
    
    print(f"name_list: {name_list}")

name\_list: \['nick', 'handsome', 'jason', 'tank', 'sean'\]

音色特方法，插入一个数据，这可不是随便插哦，这个要找对地方插（斜眼笑），你要明确要插入数据的索引， 诶有人就开始bb了，’那个索引上已经有数据了呢？‘，有数据了就让他往后稍稍啊，插，什么是插，插队啊，后面所有数据的索引值全都加1

下一题！

2.pop()

# list之pop()，pop()默认删除最后一个元素
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list.pop(1): {name_list.pop(1)}")
    print(f"name_list: {name_list}")

name\_list.pop(1): jason

name\_list: \['nick', 'tank', 'sean'\]

和del的区别在哪里，有，你不写索引的话默认删除最后一个，并且他有返回值，就是被删除的元素。

3.remove()

# list之remove()
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list.remove('nick'): {name_list.remove('nick')}")
    print(f"name_list: {name_list}")

name\_list.remove('nick'): None

name\_list: \['jason', 'tank', 'sean'\]

remove方法呢，他也有返回值，他会在删除成功后返回一个None，如果删除的对象不存在会报错，通过数据来删除，而不是通过索引了。

4.count()

# list之count()
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list.count('nick'): {name_list.count('nick')}")

name\_list.count('nick'): 1

这个就是来看你的列表里有几个目标对象

5.index()

# list之index()
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list.index('nick'): {name_list.index('nick')}")

name\_list.index('nick'): 0

通过输入对象来返回对象的下标

6.clear()

# list之clear()
    name_list = ['nick', 'jason', 'tank', 'sean'] 
    name_list.clear()
    
    print(f"name_list: {name_list}")

name\_list: \[\]

科利尔，顾名思义，清空，clear（你的脑子），你脑袋里就什么都没了，同样的，列表里面全都会被删除掉

7.copy()

# list之copy()
    name_list = ['nick', 'jason', 'tank', 'sean']
    
    print(f"name_list.copy(): {name_list.copy()}")

name\_list.copy(): \['nick', 'jason', 'tank', 'sean'\]

扣鼻方法，就是重新开辟出一块内存空间用来放一毛一样的数据，元数据改变，copy的内容不会变。

8.extend()

# list之extend()
    name_list = ['nick', 'jason', 'tank', 'sean']
    name_list2 = ['nick handsome']
    name_list.extend(name_list2)
    
    print(f"name_list: {name_list}")

name\_list: \['nick', 'jason', 'tank', 'sean', 'nick handsome'\]

伊克斯谈得，扩张的意思，你写个东西，他就给你整到列表后头去了吗，

9.reverse()

# list之reverse()
    name_list = ['nick', 'jason', 'tank', 'sean']
    name_list.reverse()
    
    print(f"name_list: {name_list}")

name\_list: \['sean', 'tank', 'jason', 'nick'\]

这个没办法空耳出来啊。。。。。。![o\_KEYAJAF(A77ETSR)ECCQZA0.jpg][o_KEYAJAF_A77ETSR_ECCQZA0.jpg]

这个的作用就是把列表的全部元素给倒置了。懂吗，你的头和脚对换了，全部翻转。

10.sort()

# list之sort()，使用sort列表的元素必须是同类型的
    name_list = ['nick', 'jason', 'tank', 'sean']
    name_list.sort()
    
    print(f"name_list: {name_list}")
    
    name_list.sort(reverse=True)
    print(f"name_list_reverse: {name_list}")

name\_list: \['jason', 'nick', 'sean', 'tank'\]

name\_list\_reverse: \['tank', 'sean', 'nick', 'jason'\]

sort，把你排序了，字符串的话，按首字母来排，一样的话按第二个来，数字就不用讲了。

4.存一个值or多个值：多个值

5.有序or无序：有序

hobby_list = ['read', 'run', 'girl']
    print(f'first:{id(hobby_list)}')
    hobby_list[2] = ''
    print(f'second:{id(hobby_list)}')
    first:4522187016
    second:4522187016

6.可变or不可变：可变数据类型

# 二、元组类型内置方法(tuple) #

元组说白了就是他娘的一个列表，不可变的列表，你改他东西，他就变id了，变id了代表什么不要我说了，不懂的人找面墙，头拿去咚两下就懂了。

1.用途：和列表一样一样啊，可以存好多妹子

2.定义：用（）来存放了。这个是和列表的区别。

ame_str = ('egon')  # ()只是普通包含的意思
    name_tuple = ('egon',)
    
    print(f"type(name_str): {type(name_str)}")
    print(f"type(name_tuple): {type(name_tuple)}")

type(name\_str): <class 'str'>  
type(name\_tuple): <class 'tuple'>

## 1.1优先掌握 ##

1.  索引取值
2.  切片（顾头不顾尾，步长）
3.  长度len
4.  成员运算in和not in
5.  循环
6.  count
7.  index

1.索引取值

# tuple之索引取值
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    # name_tuple[0] = 'nick handsom'  # 报错
    
    print(f"name_tuple[0]: {name_tuple[0]}")
    name_tuple[0]: nick

没啥好讲的![timg?image&quality=80&size=b9999\_10000&sec=1565020026886&di=560e96be54a9a4451e4815b360cc376f&imgtype=0&src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201707%2F16%2F20170716193948\_nBHPW.jpeg][timg_image_quality_80_size_b9999_10000_sec_1565020026886_di_560e96be54a9a4451e4815b360cc376f_imgtype_0_src_http_3A_2F_2Fb-ssl.duitang.com_2Fuploads_2Fitem_2F201707_2F16_2F20170716193948_nBHPW.jpeg]

2.切片（顾头不顾尾，步长）

# tuple之切片
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
    name_tuple[1:3:2]: ('jason',)

切片不就额、也那么回事儿吗？![timg?image&quality=80&size=b9999\_10000&sec=1565614805&di=b53d490f286c1136ae425c596ffbcb22&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.thehour.cn%2F2018%2F11%2F29%2F15434724668576470643135652283938.jpeg%3Fw%3D559%26amp%3Bh%3D314][timg_image_quality_80_size_b9999_10000_sec_1565614805_di_b53d490f286c1136ae425c596ffbcb22_imgtype_jpg_er_1_src_http_3A_2F_2Fimg.thehour.cn_2F2018_2F11_2F29_2F15434724668576470643135652283938.jpeg_3Fw_3D559_26amp_3Bh_3D314]

3.长度

# tuple之长度
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    print(f"len(name_tuple): {len(name_tuple)}")
    len(name_tuple): 4

等一下，这种东西还需要讲吗？

![timg?image&quality=80&size=b9999\_10000&sec=1565614897&di=b023d1b6eb96211872922257e29b88ae&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.mp.itc.cn%2Fq\_mini%2Cc\_zoom%2Cw\_640%2Fupload%2F20170714%2F2965fefa85614f9fb777e818389a4abc\_th.jpg][timg_image_quality_80_size_b9999_10000_sec_1565614897_di_b023d1b6eb96211872922257e29b88ae_imgtype_jpg_er_1_src_http_3A_2F_2Fimg.mp.itc.cn_2Fq_mini_2Cc_zoom_2Cw_640_2Fupload_2F20170714_2F2965fefa85614f9fb777e818389a4abc_th.jpg]

4.成员运算

# tuple之成员运算
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    print(f"'nick' in name_tuple: {'nick' in name_tuple}")
    'nick' in name_tuple: True

这个难道有难度吗？

![u=1543109547,921710167&fm=26&gp=0.jpg][u_1543109547_921710167_fm_26_gp_0.jpg]

5.循环

# tuple之循环
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    for name in name_tuple:
        print(name)
    nick
    jason
    tank
    sean

6.count()

# tuple之count()
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
    name_tuple.count('nick'): 1

7.index()

# tuple之index()
    name_tuple = ('nick', 'jason', 'tank', 'sean')
    
    print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
    name_tuple.index('nick'): 0

4.存一个值or多个值：多个值

5.有序or无序：有序

name_tuple = ('nick',)
    print(f'first:{id(name_tuple)}')
    first:4394454152

6.可变or不可变：不可变数据类型

![timg?image&quality=80&size=b9999\_10000&sec=1565020314282&di=c29d116dbf90fbd9b32a969332783be5&imgtype=0&src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201707%2F16%2F20170716193953\_uaSwZ.thumb.700\_0.jpeg][timg_image_quality_80_size_b9999_10000_sec_1565020314282_di_c29d116dbf90fbd9b32a969332783be5_imgtype_0_src_http_3A_2F_2Fb-ssl.duitang.com_2Fuploads_2Fitem_2F201707_2F16_2F20170716193953_uaSwZ.thumb.700_0.jpeg]

恕我直言，元组在列表面前，就是一个弟弟。过！！！

# 三、字典类型内置方法（dict） #

1.用途：存多个值啊，每一个值都有一个key与之对应。这些key具有描述的功能，比如说身材好的，长得漂亮的。。。。

2.定义：\{\}内用逗号隔开每一对键值对，每一个元素都是key：value的形式。value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。

## 1.1优先掌握 ##

1.  按key存取值：可存可取
2.  长度len
3.  成员运算in和not in
4.  删除del
5.  键keys()、值values()、键值对items()
6.  循环

1.按key存取值：可存可取

# dic之按key存取值
    dic = {'a': 1, 'b': 2}
    
    print(f"first dic['a']: {dic['a']}")
    
    dic['a'] = 3
    
    print(f"second dic['a']: {dic['a']}")

first dic\['a'\]: 1  
second dic\['a'\]: 3

..........这也没什么可以讲得吧

2.长度len

# dic之长度len
    dic = {'a': 1, 'b': 2}
    
    print(f"len(dic): {len(dic)}")

len(dic): 2

..........这也没什么可以讲得吧\*2

3.成员运算in和not in

# dic之成员运算in和not in
    dic = {'a': 1, 'b': 2}
    
    print(f"'a' in dic: {'a' in dic}")
    print(f"1 in dic: {1 in dic}")

'a' in dic: True  
1 in dic: False

..........这也没什么可以讲得吧\*3 哦这个可以讲一下，这里可以判断key也可以判断value是不是in这个字典。

4.删除

# dic之删除del
    dic = {'a': 1, 'b': 2}
    del dic['a']
    
    print(f"dic.get('a'): {dic.get('a')}")

dic.get('a'): None

以key的形式去删除一个键值对

# dic之删除pop()
    dic = {'a': 1, 'b': 2}
    dic.pop('a')  # 指定元素删除

print(f"dic.pop('b'): \{dic.pop('b')\}")  
print(f"dic.get('a'): \{dic.get('a')\}")

pop和del的区别就是如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

并且pop有返回值，是删除的那个键值对应的value

# dic之删除popitem()
    dic = {'a': 1, 'b': 2}
    
    print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。

dic.popitem(): ('b', 2)

这个就是随机删除一个键值对。我在这上面犟过一些时间，后来被告知是python的底层做了优化，让我们看上去字典像是有序的一样，删除了最后一个，其实是无序的。

5.键keys()、值values()、键值对items()

# dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
    dic = {'a': 1, 'b': 2}
    
    print(f"dic.keys(): {dic.keys()}")
    print(f"dic.values(): {dic.values()}")
    print(f"dic.items(): {dic.items()}")

dic.keys(): dict\_keys(\['a', 'b'\])  
dic.values(): dict\_values(\[1, 2\])  
dic.items(): dict\_items(\[('a', 1), ('b', 2)\])

![timg?image&quality=80&size=b9999\_10000&sec=1565616045&di=48ccda75a8df55005ab6ffaec887d966&imgtype=jpg&er=1&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fq\_70%2Cc\_zoom%2Cw\_640%2Fimages%2F20181129%2F85c9e5d6071948ee8e5a0da16d5152c3.jpeg][timg_image_quality_80_size_b9999_10000_sec_1565616045_di_48ccda75a8df55005ab6ffaec887d966_imgtype_jpg_er_1_src_http_3A_2F_2F5b0988e595225.cdn.sohucs.com_2Fq_70_2Cc_zoom_2Cw_640_2Fimages_2F20181129_2F85c9e5d6071948ee8e5a0da16d5152c3.jpeg]

这个不弱。。。这个有用。 之前帮后排同学实现过一个功能，很麻烦，定义了两个变量来存拿出来的东西，当我后来学了这个方法的时候我。。。。![o\_4ac45e6f70aa68fae6598706359dd44e%20(3).gif][o_4ac45e6f70aa68fae6598706359dd44e_20_3_.gif]

6.循环

# dic之循环
    # dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
    dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    
    for k, v in dic.items():  # items可以换成keys()、values()
        print(k, v)

a 1  
b 2  
c 3  
d 4

这个就那么回事儿。

# 四、集合类型内置方法（set） #

集合就像是列表和字典生下来的孩子，不男不女的，表现形式是怎么样呢？

\{1,2,3,4,4,5,6\}，这样的，变态吗？ 用着他妈妈的中括号，却用着他爸的存数据方式。

1.用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

2.定义：\{\}内用逗号分隔开多个元素，每个元素必须是不可变类型。

## 1.1优先掌握 ##

1.  长度len
2.  成员运算in和not in
3.  |并集、union
4.  &交集、intersection
5.  \-差集、difference
6.  ^对称差集、symmetric\_difference
7.  ==
8.  父集：>、>= 、issuperset
9.  子集：<、<= 、issubset

![u=445522417,2837560825&fm=26&gp=0.jpg][u_445522417_2837560825_fm_26_gp_0.jpg]

1.长度len

# set之长度len
    s = {1, 2, 'a'}
    
    print(f"len(s): {len(s)}")

len(s): 3

2.成员运算in和not in

# set之成员运算in和not in
    s = {1, 2, 'a'}
    
    print(f"1 in s: {1 in s}")

1 in s: True

[![集合类型内置运算-集合运算英文.jpg?x-oss-process=style/watermark][-_.jpg_x-oss-process_style_watermark]][-_.jpg_x-oss-process_style_watermark]

3.|并集

# str之|并集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners|linuxers: {pythoners|linuxers}")
    print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

pythoners|linuxers: \{'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'\}  
pythoners.union(linuxers): \{'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'\}

4.&交集

# str之&交集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners&linuxers: {pythoners&linuxers}")
    print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")

pythoners&linuxers: \{'nick'\}  
pythoners.intersection(linuxers): \{'nick'\}

5.-差集

# str之-差集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners-linuxers: {pythoners-linuxers}")
    print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")

pythoners-linuxers: \{'tank', 'jason', 'sean'\}  
pythoners.difference(linuxers): \{'tank', 'jason', 'sean'\}

6.^对称差集

# str之^对称差集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners^linuxers: {pythoners^linuxers}")
    print(
        f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")

pythoners^linuxers: \{'egon', 'tank', 'kevin', 'jason', 'sean'\}  
pythoners.symmetric\_difference(linuxers): \{'egon', 'tank', 'kevin', 'jason', 'sean'\}

7.==

# str之==
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    javers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners==linuxers: {pythoners==linuxers}")
    print(f"javers==linuxers: {javers==linuxers}")

pythoners==linuxers: False  
javers==linuxers: True

8.父集：>、>=

# str之父集：>、>=
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    javaers = {'jason', 'nick'}
    
    print(f"pythoners>linuxers: {pythoners>linuxers}")
    print(f"pythoners>=linuxers: {pythoners>=linuxers}")
    print(f"pythoners>=javaers: {pythoners>=javaers}")
    print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")

pythoners>linuxers: False  
pythoners>=linuxers: False  
pythoners>=javaers: True  
pythoners.issuperset(javaers): True

9.子集：<、<=

# str之子集：<、<=
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    javaers = {'jason', 'nick'}
    
    print(f"pythoners<linuxers: {pythoners<linuxers}")
    print(f"pythoners<=linuxers: {pythoners<=linuxers}")
    print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")

pythoners<linuxers: False  
pythoners<=linuxers: False  
javaers.issubset(javaers): True

讲真，这些方法都很带劲啊，当你要比较两个列表内的元素是否都相同的时候，就不需要在写两个循环了呀，直接强制转换成集合类型，然后用集合类内置方法来比较一下啊就完事儿了啊，其他的方法也是适合各种时候的需求的。

对不起，刚才骂你是变态。

![u=918974442,2452681222&fm=26&gp=0.jpg][u_918974442_2452681222_fm_26_gp_0.jpg]

## 1.2需要掌握 ##

1.  add
2.  remove
3.  difference\_update
4.  discard
5.  isdisjoint

1.add()

# set之add()
    s = {1, 2, 'a'}
    s.add(3)
    
    print(s)

\{1, 2, 3, 'a'\}

2.remove()

# set之remove()
    s = {1, 2, 'a'}
    s.remove(1)
    
    print(s)

\{2, 'a'\}

3.difference\_update()

# str之difference_update()
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    pythoners.difference_update(linuxers)
    
    print(f"pythoners.difference_update(linuxers): {pythoners}")

pythoners.difference\_update(linuxers): \{'tank', 'jason', 'sean'\}

4.discard()

# set之discard()
    s = {1, 2, 'a'}
    # s.remove(3)  # 报错
    s.discard(3)
    
    print(s)

\{1, 2, 'a'\}

5.isdisjoint()

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    pythoners.isdisjoint(linuxers)
    
    print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")

pythoners.isdisjoint(linuxers): False

以上的方法就只用做了解一下，说实话集合用到的机会不多，比较冷。

转载于:https://www.cnblogs.com/chanyuli/p/11305792.html

[timg_image_quality_80_size_b9999_10000_sec_1565617749_di_a82d8cab8e8ccc4680d9684f2be328ce_imgtype_jpg_er_1_src_http_3A_2F_2Fwx2.sinaimg.cn_2Forj360_2F7a158a79gy1foy0kv19sdj20hs0icwg0.jpg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565617749&di=a82d8cab8e8ccc4680d9684f2be328ce&imgtype=jpg&er=1&src=http%3A%2F%2Fwx2.sinaimg.cn%2Forj360%2F7a158a79gy1foy0kv19sdj20hs0icwg0.jpg
[o_0_5D90O5AYLDR3C0_7DIE0IKG_G.jpg]: /images/20211029/c81a48a82bfa47e28d0668ea00598c47.png
[o_1564572232_1_.jpg]: /images/20211029/cd18e968f40846cf9494ee9711da4bcc.png
[u_3692908877_226061635_fm_15_gp_0.jpg]: /images/20211029/164ded96dd664b5888c9d11dec74c0ae.png
[o_KEYAJAF_A77ETSR_ECCQZA0.jpg]: /images/20211029/0a670a1abad442fd8242ca9c949b225f.png
[timg_image_quality_80_size_b9999_10000_sec_1565020026886_di_560e96be54a9a4451e4815b360cc376f_imgtype_0_src_http_3A_2F_2Fb-ssl.duitang.com_2Fuploads_2Fitem_2F201707_2F16_2F20170716193948_nBHPW.jpeg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565020026886&di=560e96be54a9a4451e4815b360cc376f&imgtype=0&src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201707%2F16%2F20170716193948_nBHPW.jpeg
[timg_image_quality_80_size_b9999_10000_sec_1565614805_di_b53d490f286c1136ae425c596ffbcb22_imgtype_jpg_er_1_src_http_3A_2F_2Fimg.thehour.cn_2F2018_2F11_2F29_2F15434724668576470643135652283938.jpeg_3Fw_3D559_26amp_3Bh_3D314]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565614805&di=b53d490f286c1136ae425c596ffbcb22&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.thehour.cn%2F2018%2F11%2F29%2F15434724668576470643135652283938.jpeg%3Fw%3D559%26amp%3Bh%3D314
[timg_image_quality_80_size_b9999_10000_sec_1565614897_di_b023d1b6eb96211872922257e29b88ae_imgtype_jpg_er_1_src_http_3A_2F_2Fimg.mp.itc.cn_2Fq_mini_2Cc_zoom_2Cw_640_2Fupload_2F20170714_2F2965fefa85614f9fb777e818389a4abc_th.jpg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565614897&di=b023d1b6eb96211872922257e29b88ae&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.mp.itc.cn%2Fq_mini%2Cc_zoom%2Cw_640%2Fupload%2F20170714%2F2965fefa85614f9fb777e818389a4abc_th.jpg
[u_1543109547_921710167_fm_26_gp_0.jpg]: /images/20211029/f58b2504374e4d1080d4ccfdd4da4dde.png
[timg_image_quality_80_size_b9999_10000_sec_1565020314282_di_c29d116dbf90fbd9b32a969332783be5_imgtype_0_src_http_3A_2F_2Fb-ssl.duitang.com_2Fuploads_2Fitem_2F201707_2F16_2F20170716193953_uaSwZ.thumb.700_0.jpeg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565020314282&di=c29d116dbf90fbd9b32a969332783be5&imgtype=0&src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201707%2F16%2F20170716193953_uaSwZ.thumb.700_0.jpeg
[timg_image_quality_80_size_b9999_10000_sec_1565616045_di_48ccda75a8df55005ab6ffaec887d966_imgtype_jpg_er_1_src_http_3A_2F_2F5b0988e595225.cdn.sohucs.com_2Fq_70_2Cc_zoom_2Cw_640_2Fimages_2F20181129_2F85c9e5d6071948ee8e5a0da16d5152c3.jpeg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1565616045&di=48ccda75a8df55005ab6ffaec887d966&imgtype=jpg&er=1&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fq_70%2Cc_zoom%2Cw_640%2Fimages%2F20181129%2F85c9e5d6071948ee8e5a0da16d5152c3.jpeg
[o_4ac45e6f70aa68fae6598706359dd44e_20_3_.gif]: /images/20211029/744bb72658344610839196ee8828373e.png
[u_445522417_2837560825_fm_26_gp_0.jpg]: /images/20211029/ad24e06270be4b93bd4498ffc1579ec0.png
[-_.jpg_x-oss-process_style_watermark]: http://www.chenyoude.com/Python%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E6%94%BE%E5%BC%83/%E9%9B%86%E5%90%88%E7%B1%BB%E5%9E%8B%E5%86%85%E7%BD%AE%E8%BF%90%E7%AE%97-%E9%9B%86%E5%90%88%E8%BF%90%E7%AE%97%E8%8B%B1%E6%96%87.jpg?x-oss-process=style/watermark
[u_918974442_2452681222_fm_26_gp_0.jpg]: /images/20211029/aae30a0a8e6c4493bc219a3e43913810.png