下载掌阅APP，畅读海量书库
立即打开
Python中有列表、元组、字典、集合这4种可以存放多个数据元素的集合，它们在总体功能上都起着存放数据的作用，但却有着各自的特点。
序列是Python中最基本的数据结构。序列中的每个值都有对应的位置值，称为索引，第一个索引是0，第二个索引是1，以此类推。Python有6个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引、切片、加、乘、检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小元素的方法。列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型。创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
与字符串的索引一样，列表索引从0开始，第二个索引是1，以此类推。通过索引列表可以进行截取、组合等操作，效果如图1-9所示。
图1-9 列表索引
【例1-8】 访问列表中的值。
list=['red','green','blue','yellow','white','black']
print(list[0])
print(list[1])
print(list[2])
运行程序，输出如下：
red
green
blue
使用下标索引来访问列表中的值，同样也可以使用方括号[]的形式截取字符，如图1-10所示。
图1-10 截取字符
【例1-9】 使用负数索引值截取。
运行程序，输出如下：
list[1]: Runoob
list[1:-2]: ['Runoob','Zhihu']
可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，append()方法用于在列表末尾添加新的对象。其调用格式为：
list.append（obj）：obj为添加到列表末尾的对象。该方法无返回值，但是会修改原来的列表。
【例1-10】 更新列表操作实例。
运行程序，输出如下：
【例1-11】 定义两个函数：一个用extend()方法，一个用append()方法。
运行程序，输出如下：
在Python中，可以使用del语句来删除列表的元素。
【例1-12】 使用del语句删除列表元素。
运行程序，输出如下：
原始列表：['Google','Runoob',1997,2020]
删除第三个元素：['Google','Runoob',2020]
此外，还可以使用remove()函数移除列表中某个值的第一个匹配项。函数的语法格式为：
list.remove（obj）：obj为列表中要移除的对象。没有返回值但是会移除列表中的某个值的第一个匹配项。
【例1-13】 使用remove()函数删除列表的匹配项。
运行程序，输出如下：
列表现在为：['Google','Jingdong','Baidu']
列表现在为：['Google','Jingdong']
Python中的列表（list）提供了index()和count()方法，它们都可以用来查找元素。
（1）index()方法。
index()方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致ValueError错误，所以在查找之前最好使用count()方法判断一下。
index()的语法格式为：
listname.index（obj，start，end）：listname表示列表名称，obj表示要查找的元素，start表示起始位置，end表示结束位置。
· start和end参数用来指定检索范围；
· start和end可以都不写，此时会检索整个列表；
· 如果只写start不写end，表示检索从start到末尾的元素；
· 如果start和end都写，表示检索start和end之间的元素。
index()方法会返回元素所在列表中的索引值。
【例1-14】 应用index()方法查找列表元素。
运行程序，输出如下：
（2）count()方法。
count()方法用来统计某个元素在列表中出现的次数，基本语法格式为：
listname.count（obj）：listname代表列表名，obj表示要统计的元素。
如果count()返回0，就表示列表中不存在该元素，所以count()也可以用来判断列表中是否存在某个元素。
【例1-15】 使用count()方法统计某元素在列表中出现的次数。
运行程序，输出如下：
36出现了3次
列表中存在100这个元素
元组（tuple）是Python中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排列的元素组成。
元组和列表（list）的不同之处在于：
· 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
· 元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
元组也可以看作是不可变的列表，通常情况下，元组用于保存无须修改的内容。从形式上看，元组的所有元素都放在一对小括号()中，相邻元素之间用逗号“，”分隔，如下所示：
(element 1,element 2,...,element n)
其中element1~elementn表示元组中的各个元素，个数没有限制，只要是Python支持的数据类型就可以。
从存储内容来看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一元组中，元素的类型可以不同，例如：
("c.biancheng.net",1,[2,'a'],("abc",3.0))
在这个元组中，有多种类型的数据，包括整型、字符串、列表、元组。
另外，我们都知道，列表的数据类型是list，那么元组的数据类型是什么呢？不妨通过type()函数来查看一下：
>>> type(("c.biancheng.net",1,[2,'a'],("abc",3.0)))
<class'tuple'>
可以看到，元组是tuple类型，这也是很多教程中用tuple指代元组的原因。
Python提供了两种创建元组的方法，分别为使用()创建和使用tuple()函数创建。
1）使用()创建元组
使用()创建元组很简单，只需要在括号中添加元素，并使用逗号隔开即可，如图1-11所示。
例如，下面的元组都是合法的：
图1-11 元组创建图
>>> tup1=('Google','Runoob',1997,2000)
>>> tup2=(1,2,3,4,5)
>>> tup3="a","b","c","d" #不加括号也可以
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号“，”，否则Python解释器会将它视为字符串。
【例1-16】 元组的创建实例。
#最后加上逗号
a=("http://c.biancheng.net/cplus/",)
print(type(a))
print(a)
#最后不加逗号
b=("http://c.bi ancheng.net/socket/")
print(type(b))
print(b)
运行程序，输出如下：
<class'tuple'>
('http://c.biancheng.net/cplus/',)
<class'str'>
http://c.biancheng.net/socket/
2）使用tuple()函数创建元组
除了使用()创建元组外，Python还提供了一个内置的函数tuple()，用来将其他数据类型转换为元组类型。tuple()的语法格式如下：
tuple（data）：data表示可以转换为元组的数据，包括字符串、元组、range对象等。
【例1-17】 使用tuple()函数创建元组。
#将字符串转换成元组
tup1= tuple("hello")
print(tup1)
#将列表转换成元组
list1=['Python','Java','MATLAB','JavaScript']
tup2= tuple(list1)
print(tup2)
#将字典转换成元组
dict 1={'a':100,'b':42,'c':9}
tup3= tuple(dict 1)
print(tup3)
#将区间转换成元组
range1=range(1,6)
tup4= tuple(range1)
print(tup4)
#创建空元组
print(tuple())
运行程序，输出如下：
('h','e','l','l','o')
('Python','Java','MATLAB','JavaScript')
('a','b','c')
(1,2,3,4,5)
()
元组与字符串类似，下标索引从0开始，可以进行截取、组合等，如图1-12所示。
图1-12 元组的索引
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。
使用索引访问元组元素的格式为：
tuplename[i]：tuplename表示元组名字，i表示索引值。元组的索引可以是正数，也可以是负数。
使用切片访问元组元素的格式为：
tuplename[start：end：step]：start表示起始索引，end表示结束索引，step表示步长。
【例1-18】 使用两种方式访问元组元素。
url=tuple("https://hao.360.com/?a1004")
#使用索引访问元组中的某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引
#使用切片访问元组中的一组元素
print(url[9:18]) #使用正数切片
print(url[9:18:3]) #指定步长
print(url[-6:-1]) #使用负数切片
运行程序，输出如下：
p
1
('a','o','.','3','6','0','.','c','o')
('a','3','.')
('?','a','1','0','0')
在Python中，元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素。
【例1-19】 修改元组实例。
#对元组变量进行重新赋值:
tup=(100,0.5,-36,73)
print(tup)
#对元组进行重新赋值
tup=("首页","https://hao.360.com/?a1004")
print(tup)
#连接元组
tup1=(100,0.5,-36,73)
tup2=(3+12j,-54.6,99)
print(tup1+tup2)
print(tup1)
print(tup2)
运行程序，输出如下：
(100,0.5,-36,73)
('首页','https://hao.360.com/?a1004')
(100,0.5,-36,73,(3+12 j),-54.6,99)
(100,0.5,-36,73)
((3+12 j),-54.6,99)
元组中的元素是不允许删除的，但我们可以使用del语句来删除整个元组。
【例1-20】 删除元组操作实例。
tup=('Google','Runoob',1997,2020)
print(tup)
del tup
print("删除后的元组tup:")
print(tup)
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
('Google','Runoob',1997,2020)
删除后的元组tup：
Tr aceback(mostr ecen t ca l l l as t):
Fi l e"E:\BookEd i t\教材\2022.1.11\Python数据分析\examp l e\1\P1_20.py",l ine 5,in
<modu l e>
print(tup)
NameError:name'tup'is not defined
字典也是Python提供的一种常用的数据结构，它用于存放具有映射关系的数据。比如有份成绩表数据，语文：79，数学：80，英语：92，这组数据看上去像两个列表，但这两个列表的元素之间有一定的关联关系。如果单纯使用两个列表来保存这组数据，则无法记录两组数据之间的关联关系。
为了保存具有映射关系的数据，Python提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，称为key；另一组数据可通过key来访问，称为value。形象地看，字典中key和value的关联关系如图1-13所示。
图1-13 key和value的关联关系图
由于字典中的key是非常关键的数据，而且程序需要通过key来访问value，因此字典中的key不允许重复。
程序既可使用花括号语法来创建字典，也可使用dict()函数来创建字典。实际上，dict是一种类型，它就是Python中的字典类型。
在使用花括号语法创建字典时，花括号中应包含多个key-value对，key与value之间用英文冒号隔开；多个key-value对之间用英文逗号隔开。
【例1-21】 使用花括号创建字典。
#创建一个简单的dict,该dict的key是字符串,va l ue是整数
scores= {'语文':89,'数学':92,'英语':93}
print(scores)
#空的花括号代表空的dict
emp t y_dict={}
print(emp t y_dict)
#使用元组作为dict的key
dict 2={(20,30):'good',30:'bad'}
print(dict 2)
运行程序，输出如下：
{'语文':89,'数学':92,'英语':93}
{}
{(20,30):'good',30:'bad'}
需要指出的是，元组可以作为dict的key，但列表不能作为元组的key。这是由于dict要求key必须是不可变类型，但列表是可变类型，因此列表不能作为元组的key。
在使用dict()函数创建字典时，可以传入多个列表或元组参数作为key-value对，每个列表或元组将被当成一个key-value对，因此这些列表或元组都只能包含两个元素。
【例1-22】 使用dict()创建字典。
vege t ab l es=[('ce l e r y',1.58),('b r oco l i',1.39),('l e t t uce',2.19)]
#创建包含3组key-va l ue对的字典
dict 3=dict(vege t ab l es)
print(dict 3)
ca r s=[['BMW',8.4],['BENS',8.5],['AUDI',7.6]]
#创建包含3组key-va l ue对的字典
dict 4=dict(ca r s)
print(dict 4)
运行程序，输出如下：
{'ce l e r y':1.58,'b r oco l i':1.39,'l e t t uce':2.19}
{'BMW':8.4,'BENS':8.5,'AUDI':7.6}
如果不为dict()函数传入任何参数，则代表创建一个空的字典。例如：
#创建空的字典
dict 5=dict()
print(dict 5)
{}
还可通过为dict指定关键字参数创建字典，此时字典的key不允许使用表达式。例如：
#使用关键字参数来创建字典
dict 6=dict(spinach=1.39,cabbage=2.59)
print(dict 6)
{'sp inach':1.39,'cabbage':2.59}
在Python中，key是字典的关键数据，所以程序对字典的操作都是基于key的。基本操作如下：
· 通过key访问value。
· 通过key添加key-value对。
· 通过key删除key-value对。
· 通过key修改key-value对。
· 通过key判断指定key-value对是否存在。
· 通过key访问value使用的也是方括号语法，就像前面介绍的列表和元组一样，只是此
时在方括号中放的是key，而不是列表或元组中的索引。
【例1-23】 字典的基本用法实例。
scores= {'数学':92}
#通过key访问va l ue
print(scores['数学'])
如果要为dict添加key-value对，只需为不存在的key赋值即可：
#对不存在的key赋值，就是增加key-va l ue对
scores['数学']=92
scores[92]=5.7
print(scores) #{'语文':88,'数学':92,91:5.7}
如果要删除字典中的key-value对，则可使用del语句，例如：
#使用del语句删除key-va l ue对
del scores['语文']
del scores['数学']
print(scores)
如果对dict中存在的key-value对赋值，新赋的value就会覆盖原有的value，这样即可改变dict中的key-value对。例如：
ca r s={'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#对存在的key-va l ue对赋值，改变key-va l ue对
ca r s['BENS']=4.2
ca r s['AUDI']=4.8
print(ca r s)
{'BMW':8.5,'BENS':4.2,'AUDI':4.8}
如果要判断字典是否包含指定的key，则可以使用in或not in运算符。需要指出的是，对于dict而言，in或not in运算符都是基于key来判断的。例如：
#判断ca r s是否包含名为'AUDI'的key
print('AUDI'in ca r s)
Tr ue
#判断ca r s是否包含名为'PORSCHE'的key
print('PORSCHE'in ca r s)
Fa l se
print('LAMBORGHINI'not in ca r s)
Tr ue
通过上面内容可以看出，字典的key是它的关键。换个角度来看，字典的key就相当于它的索引，只不过这些索引不一定是整数类型，字典的key可以是任意不可变类型。
此外，还有一点需要指出，列表的索引总是从0开始、连续增大的；但字典的索引即使是整数类型，也不需要从0开始，而且不需要连续。因此，列表不允许对不存在的索引赋值：但字典却允许直接对不存在的key赋值，这样就会为字典增加一个key-value对。
字典由dict类代表，因此同样可使用dir（dict）来查看该类包含哪些方法。在交互式解释器中输入dir（dict）命令，将看到如下输出结果：
下面介绍dict的一些方法。
1）clear()方法
clear()方法用于清空字典中所有的key-value对，对一个字典执行clear()方法之后，该字典就会变成一个空字典。
【例1-24】 clear()方法的使用实例。
tinydict={'Name':'Liming','Age':8}
print("字典长度：%d"% l en(t i nydict))
tinydict.c l ea r()
print("字典删除后长度：%d"% l en(tinydict))
运行程序，输出如下：
字典长度:2
字典删除后长度：0
2）get()方法
get()方法其实就是根据key来获取value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的key时，字典会引发Key Error错误；但如果使用get()方法访问不存在的key，该方法会简单地返回None，不会导致错误。
【例1-25】 使用get()方法获取字典中的值。
tinydict={'Name':'Python','Age':25}
print("Age:",tinydict.ge t('Age'))
#没有设置Sex,也没有设置默认的值，输出None
print("Sex:",tinydict.ge t('Sex'))
#没有设置Salary,输出默认的值0.0
print('Salary:',tinydict.ge t('Salary',0.0))
Age: 25
Sex: None
Salary: 0.0
3）update()方法
update()方法可使用一个字典所包含的key-value对来更新已有的字典。在执行update()方法时，如果被更新的字典中已包含对应的key-value对，那么原value会被覆盖；如果被更新的字典中不包含对应的key-value对，则该key-value对被添加进去。
【例1-26】 使用update()方法更新字典中的值。
tinydict={'Name':'WangShan','Age':8}
tinydict 2={'Sex':'f ema l e'}
tinydict.upda t e(tinydict 2)
print("更新字典tinydict:",tinydict)
运行程序，输出如下：
更新字典tinydict: {'Name':'WangShan','Age':8,'Sex':'f ema l e'}
4）items()方法、keys()方法、values()方法
items()方法、keys()方法、values()方法分别用于获取字典中的所有key-value对、所有key、所有value。这三个方法依次返回dict_items、dict_keys和dict_values对象，Python不希望用户直接操作这几个方法，但可通过list()函数把它们转换成列表。
【例1-27】 items()方法、keys()方法、values()方法的用法实例。
ca r s={'BMW':8.8,'BENS':8.1,'AUDI':7.0}
#获取字典所有的key-va l ue对，返回一个dict_i t ems对象
ims=ca r s.i t ems()
print(type(ims))
#将dict_i t ems转换成列表
print(l is t(ims))
#访问第2个key-va l ue对
print(l is t(ims)[1])
#获取字典所有的key,返回一个dict_keys对象
kys=ca r s.keys()
print(type(kys))
#将dict_keys转换成列表
print(l is t(kys))
#访问第2个key
print(l is t(kys)[1])
#获取字典所有的va l ue,返回一个dict_va l ues对象
va l s=ca r s.va l ues()
#将dict_va l ues转换成列表
print(type(va l s))
#访问第2个va l ue
print(l is t(va l s)[1])
运行程序，输出如下：
<class'dict_i t ems'>
[('BMW',8.8),('BENS',8.1),('AUDI',7.0)]
('BENS',8.1)
<class'dict_keys'>
['BMW','BENS','AUDI']
BENS
<class'dict_va l ues'>
8.1
从例1-27可看出，程序调用字典的items()方法、keys()方法、values()方法之后，都需要调用list()函数将它们转换为列表，这样即可把这三个方法的返回值转换为列表。
5）pop()方法
pop()方法用于获取指定key对应的value，并删除这个key-value对。
【例1-28】 展示pop()方法的使用。
site={'name':'Python教程','a l exa':9999,'url':'www.r unoob.com'}
element=site.pop('name')
print('删除的元素为：',element)
print('字典为：',site)
运行程序，输出如下：
删除的元素为:Python教程
字典为：{'a l exa':9999,'url':'www.r unoob.com'}
6）popitem()方法
popitem()方法用于随机弹出字典中的一个key-value对。
此处的随机其实是假的，正如列表的pop()方法总是弹出列表中的最后一个元素，实际上字典的popitem()方法也是弹出字典中的最后一个key-value对。由于字典存储key-value对的顺序是不可知的，因此开发者感觉字典的popitem()方法是“随机”弹出的，但实际上字典的popitem()方法总是弹出底层存储的最后一个key-value对。
【例1-29】 展示popitem()方法的使用方法。
site={'name':'Python教程','a l exa':9999,'url':'www.r unoob.com'}
resul t=site.pop i t em()
print('返回值= ',resul t)
print('site=',site)
#插入新元素
site['ni ckname']= 'Runoob'
print('site=',site)
#现在('ni ckname','Runoob')是最后插入的元素
resul t=site.pop i t em()
print('返回值=',resul t)
print('site=',site)
运行程序，输出如下：
返回值= ('url','www.r unoob.com')
site= {'name':'Python教程','a l exa':9999}
site= {'name':'Python教程','a l exa':9999,'ni ckname':'Runoob'}
返回值= ('ni ckname','Runoob')
site= {'name':'Python教程','a l exa':9999}
由于实际上popitem()弹出的就是一个元组，因此程序完全可以通过序列解包的方式用两个变量分别接收key和value。
7）setdefault()方法
setdefault()方法也用于根据key来获取对应的value值。但该方法有一个额外的功能，即当程序要获取的key在字典中不存在时，该方法会先为这个不存在的key设置一个默认的value，然后再返回该key对应的value。
总之，setdefault()方法总能返回指定key对应的value；如果该key-value对存在，则直接返回该key对应的value；如果该key-value对不存在，则先为该key设置默认的value，然后再返回该key对应的value。
【例1-30】 展示setdefault()方法的使用方法。
tinydict={'Name':'Python','Age':6}
print("Age键的值为：%s"% tinydict.se t de f au l t('Age',None))
print("Sex键的值为：%s"% tinydict.se t de f au l t('Sex',None))
print("新字典为：",tinydict)
运行程序，输出如下：
Age键的值为:6
Sex键的值为:None
新字典为：{'Name':'Python','Age':6,'Sex':None}
8）fromkeys()方法
fromkeys()方法使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。该方法一般不会使用字典对象调用，通常会使用dict类直接调用。
【例1-31】 fromkeys()方法的使用方法。
运行程序，输出如下：
{'a':None,'b':None}
{13:None,17:None}
{13:'good',17:'good'}
Python的集合是一个无序且没有重复元素的序列，集合中的元素必须是可Hash对象。集合不记录元素位置和插入顺序，因此，也不支持索引、切片等其他序列类的操作。
定义集合可以使用{}或者set()，但定义空集合不能使用{}，因为{}是创建空字典的方法，定义空集合可以使用set()。
【例1-32】 创建集合的实例演示。
>>> s={1,2,4,5}
>>> print(type(s))
<class'se t'>
>>> s1={}
>>> print(type(s1)) ##空字典定义
<class'dict'>
>>> s1=se t([])
>>> print(type(s1)) ###空集合定义
<class'se t'>
集合之间也可进行数学集合运算（例如并集、交集等），可用相应的操作符或方法来实现。
1）子集
子集，为某个集合中一部分的集合，故亦称部分集合。使用操作符“<”执行子集操作，同样地，也可使用方法issubset()完成。
【例1-33】 子集的演示。
>>> A=se t('abcd')
>>> B=se t('cde f')
>>> C=se t("ab")
>>> C< A #C是A的子集
Tr ue
>>> C< A
Tr ue
>>> C.issubse t(A)
Tr ue
2）并集
一组集合的并集是这些集合的所有元素构成的集合，而不包含其他元素。使用操作符“|”执行并集操作，同样地，也可使用方法union()完成。
【例1-34】 并集实例演示。
>>> A|B
{'f','e','a','d','c','b'}
>>> A.intersection(B)
{'c','d'}
3）交集
两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素，而没有其他元素的集合。使用“&”操作符执行交集操作，同样地，也可使用方法intersection()完成。
【例1-35】 交集实例演示。
>>> A&B
{'c','d'}
>>> A.intersection(B)
{'c','d'}
4）差集
A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合。使用操作符“-”执行差集操作，同样地，也可使用方法difference()完成。
【例1-36】 差集实例演示。
>>> A-B
{'a','b'}
>>> A.difference(B)
{'a','b'}
>>> {'b','a'}
{'a','b'}
5）对称差
两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。使用“^”操作符执行对称差操作，同样地，也可使用方法symmetric_difference()完成。
【例1-37】 对称差实例演示。
>>> A^B
{'f','e','a','b'}
>>> A.symmetric_difference(B)
{'f','e','a','b'}
在Python中，相关的集合方法也提供相应的函数来实现，下面对各种方法进行介绍。
1）添加元素
在Python中，提供了add()方法向集合内增加元素，如果添加的元素已经存在，则不执行任何操作。
【例1-38】 使用add()方法向集合中添加元素。
t hisse t=se t(("Google","Runoob","Taobao"))
t hisse t.add("Facebook")
print(t hisse t)
{'Google','Facebook','Taobao','Runoob'}
还有一个方法也可以实现添加元素，且参数可以是列表、元组、字典等，其语法格式为：
s.upda t e(x)
x可以有多个，用逗号分开。
【例1-39】 使用update()方法添加集合元素。
>>> thisse t=set(("Google","Runoob","Taobao"))
>>> thisse t.update({1,3})
>>> print(thisset)
{'Google',1,3,'Runoob','Taobao'}
>>> t hisse t.update([1,4],[5,6])
>>> print(thisset)
{'Google',1,3,4,5,6,'Runoob','Taobao'}
2）移除元素
在Python中，提供了remove()方法实现集合移除元素。语法格式为：
s.remove（x）：将元素x从集合s中移除，如果元素不存在，则会发生错误。
【例1-40】 使用remove()方法移除集合元素。
>>> s={1,2,3,4,5,6}
>>> s.remove(3)
>>> s
{1,2,4,5,6}
>>> s.remove(8) %不存在会发生错误
Tr aceback(mostrecent call last):
Fi l e"<stdin>",line 1,in<module>
KeyError:8
此外还有一个方法也可以实现移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard(x)
【例1-41】 使用discard()方法删除集合元素。
>>> s={1,2,3,4,5,6}
>>> s.discard(7) #不存在不会发生错误
>>> s
{1,2,3,4,5,6}
我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop()
【例1-42】 使用pop()方法随机删除集合中的元素。
>>> fruits={"apple","banana","cherry"}
>>> x=fruits.pop()
>>> print(x)
cherry