Python 序列、集合和字典

可变类型和不可变类型

可变类型

即可以对该类型对象中保存的元素值做修改，如列表、字典都是可变类型。

不可变类型

即该类型对象所保存的元素值不允许修改，只能通过给对象整体赋值来修改对象保存的数据。但此时实际上就是创建了一个新的不可变类型的对象、而不是修改原对象的值，如数字、字符串、元组都是不可变类型。

例：可变类型对象和不可变类型对象示例

n1,n2=1,1#定义两个整型变量n1，n2，都赋值为1
print('第2行n1和n2的内存地址分别为：',id(n1),id(n2))
n2=3#将n2重新赋值为3
print('第4行n1和n2的内存地址分别为：',id(n1),id(n2))
n1=3#将n1重新赋值为3
print('第6行n1和n2的内存地址分别为：',id(n1),id(n2))
s1,s2='Python','Python'#定义两个字符串变量s1和s2，都赋值为'Python'
print('第8行s1和s2的内存地址分别为：',id(s1),id(s2))
s2='C++'#将s2重新赋值为'C++'
print('第10行s1和s2的内存地址分别为：',id(s1),id(s2))
s1='C++'#将s1重新赋值为'C++'
print('第12行s1和s2的内存地址分别为：',id(s1),id(s2))
t1,t2=(1,2,3),(1,2,3)#定义两个元组变量t1和t2，都赋值为(1,2,3)
print('第14行t1和t2的内存地址分别为：',id(t1),id(t2))
ls1,ls2=[1,2,3],[1,2,3]#定义两个列表变量ls1和ls2，都赋值为[1,2,3]
print('第18行ls1和ls2的内存地址分别为：',id(ls1),id(ls2))
ls2[1]=5#将列表ls2中下标为1的元素值重新赋值为[1,2,3]
print('第22行ls1和ls2的内存地址分别为：',id(ls1),id(ls2))

注：可变类型的对象和不可变类型的对象的区别在于是否可修改对象的元素值。对于可变类型的对象，如果对可变类型对象中的元素做修改，则不会创建新对象；而如果直接对其赋值，则也会创建一个新的对象。

创建列表和拼接列表

创建列表

1、列表就是用一对中括号起来的多个元素的有序集合，各元素之间用逗号分隔。
2、如果一个列表中不包含任何元素（即只有一对中括号），则该列表就是一个空列表。

例：使用[]创建列表对象。

ls1=[1,'one','——']#创建列表对象并将赋给变量ls1，其包含3个元素
ls2=[]#创建列表对象并将其赋给变量ls2，其不包含任何元素、因此是一个空列表
print('ls1的值为：',ls1)
print('ls2的值为:',ls2)

使用内置方法list创建列表对象

ls=list((1,'one','——'))#使用list方法根据元组创建列表对象，并赋给ls变量
print('ls的值为：',ls)
print('ls的第一个元素和最后一个元素的值分别为：',ls[0],ls[-1])
print('ls的前两个元素的值为：',ls[0:-1])

注：ls=list((1,‘one’,‘——’))也可以分成两条语句：
t=(1,‘one’,‘——’)#创建元组对象并赋给t
ls=list(t)#根据元组t创建列表对象并赋给ls

拼接列表示例

ls1=[1,2,3]#创建列表对象并赋给变量ls1
ls2=['Python','C++']#创建列表对象并赋给变量ls2
ls3=ls1+ls2#通过拼接运算"+"将ls1和ls2连接生成一个新的列表对象赋给ls3
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls3的值为：',ls3)

注：除了拼接运算"+“外，Python中的序列还支持重复运算”*"。

复制列表元素

1、Python中，通过赋值运算实际上是将两个变量指向同一个对象，而不是将一个变量的值赋给另一个变量。
2、两个变量指向同一个对象后，我们通过一个变量修改对象中元素的值，那么通过另一个变量访问对象时，访问到的对象中的元素值也是修改后的值。

例：列表对象赋值示例

ls1=[1,2,3]#创建列表对象并赋给变量ls1
ls2=ls1#通过赋值运算ls2和ls1指向同一个对象
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls1和ls2的内存地址分别为：',id(ls1),id(ls2))
ls1[1]=5#将ls1中下标为1的元素值修改为5
print('ls1和ls2的值分别为：',ls1,ls2)

注：通过赋值运算，ls1和ls2对应了同一个列表。

通过元素截取实现列表元素复制

例：利用元素截取方法，实现修改一个对象中的元素值不会影响另一个对象。

ls1=[1,2,3]#创建列表对象并赋给变量ls1
ls2=ls1[:]#通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls1和ls2的内存地址分别为：',id(ls1),id(ls2))
ls1[1]=5#将ls1中下标为1的元素值修改为5
print('ls1和ls2的值分别为：',ls1,ls2)

利用元素截取方法，实现列表元素复制的问题。

ls1=[1,[2,3]]#创建列表对象并赋给变量ls1
ls2=ls1[:]#通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls1和ls2的内存地址分别为：',id(ls1),id(ls2))
print('ls1[1]和ls2[1]的内存地址分别为：',id(ls1[1]),id(ls2[1]))
ls1[1][0]=5#将ls1下标为1的列表元素（即ls[1])中下标为0的元素值修改为5
print('ls1和ls2的值分别为：',ls1,ls2)

通过deepcopy函数实现列表元素复制

例：使用copy模块中的deepcopy函数，实现列表复制操作。

import copy#导入copy模块
ls1=[1,[2,3]]#创建列表对象并赋给变量ls1
ls2=copy.deepcopy(ls1)#通过调用deepcopy函数复制ls1生成新对象并赋给ls2
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls1和ls2的内存地址分别为：',id(ls1),id(ls2))
print('ls1[1]和ls2[1]的内存地址分别为：',id(ls1[1]),id(ls2[1]))
ls1[1][0]=5#将ls1下标为1的列表元素(即ls[1])中下标为0的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)

列表元素的查找、插入和删除

查找列表元素

通过列表中的index方法可以根据指定值查找第一个匹配的列表元素的位置。
语法格式：
ls.index(x),其中，ls是要进行元素查找操作的列表对象，x是要查找的元素值，返回值是ls中第一个值为x的元素的位置。

查找列表元素示例。

ls=[1,3,5,3]#创建列表对象，并赋给ls变量
print('ls的值为3的元素第一次出现的位置为：',ls.index(3))

插入列表元素

通过列表中的insert方法可以将一个元素插入到列表的指定位置，语法格式为：
ls.insert(index,x),其作用是将元素x插入到ls列表下标为index的位置上。
在列表的最后添加新元素，可以直接使用列表的append方法，语法格式为： ls.append(x)

例：插入列表元素示例。

ls=[1,2,3]#创建列表对象并赋给ls
ls.insert(0,'Python')#在ls列表下标为0的位置插入新元素'Python'
print(ls)#输出"['Python',1,2,3]"
ls.insert(2,Ture)#在ls列表下标为2的位置插入新元素True
print(ls)#输出"['Python',1,True,2,3]"
ls.append([5,10])#在ls列表最后添加新元素[5,10]
print(ls)#输出"['Python',1,Ture,2,3,[5,10]]"

删除列表元素

使用del语句可以删除某个变量或列表的某个元素。
如果要删除列表中的连续多个元素，也可以截取列表中的连续多个元素并将其赋为空列表。

例：删除列表元素示例。

ls=[0,1,2,3,4,5,6,7,8,9]#创建列表对象并赋给ls
del ls[8]#使用del将ls中下标为8的元素删除
print(ls)#输出ls
ls[1:6]=[]#将ls中下标为1至5的元素删除
print(ls)#输出ls

列表元素的最大值、最小值、出现次数和列表长度

获取列表中最大元素和最小元素

使用max和min可以分别获取一个列表中最大元素和最小元素的值，语法格式如下：
max(ls),min(ls)

例：获取列表中最大元素和最小元素示例。

ls=[23,56,12,37,28]#创建列表对象并赋给ls
print('ls中的最大元素值为：',max(ls))#输出ls中最大元素的值
print('ls中的最小元素值为：',min(ls))#输出ls中最小元素的值

统计元素出现次数

使用列表中的count方法可以统计某个值在列表中出现的次数，count方法的语法格式如下：
ls.count(x)
其作用是统计值x在列表ls中出现的次数。

ls=[23,37,12,37,28]#创建列表对象并赋给ls
print('ls中值为37的元素个数为：',ls.count(37))
print('ls中值为28的元素个数为：',ls.count(28))
print('ls中值为56的元素个数为：',ls.count(56))

计算列表长度

使用len方法可以获取一个列表中包含的元素数量（即列表长度），len方法的语法格式如下：
len(ls)

例：计算列表长度示例。

ls=[23,56,12,37,28]#创建列表对象并赋给ls
print('ls的列表长度为：',len(ls))#输出ls中元素的数量

列表元素排序

使用列表中的sort方法可以对列表中的元素按照指定规则进行排序，sort方法的语法格式如下：
ls.sort(key=None,reverse=False)
其中，key接收一个函数，通过该函数获取用于排序时比较大小的数据；reverse指定是将列表中的元素按升序(False,默认值)还是按降序(True)排列。

例：列表中元素排序示例。

class Student:#定义学生类
   def __init__(self,sno,name):#定义构造方法
      self.sno=sno#将self对象的sno属性赋为形参sno的值
      self.name=name#将self对象的name属性赋为形参name的值
   def __str__(self):#定义内置方法__str__
      return '学号：'+self.sno+',姓名：'+self.name
if __name__=='__main__':
   ls1=[23,56,12,37,28]#创建列表对象并赋给变量ls1
   ls1.sort()#将ls1中的元素按升序排序
   print('ls1升序排序后的结果：',ls1)
   ls.sort(reverse=Ture)#将ls1中的元素按排序降序排序
   print('ls1降序排序后的结果：',ls1)
   ls2=[Student('1810101','小明'),Student('1810100','小红'),Student('1810102','张刚')]#创建包含3个Student类对象的列表并赋给变量ls2
   ls2.sort(key=lambda stu:stu.sno)#按学号升序排序
   print('ls2按学号升序排序后的结果：')
   for stu in ls2:#遍历ls2中的每名学生并输出
      print(stu)
   ls2.sort(key=lambda stu:stu.sno,reverse=Ture)#按学号降序排序
   print('ls2按学号降序排序后的结果：')
   for stu in ls2:#遍历ls2中的每名学生并输出
     print(stu)

注：sort方法的位置参数"key=lambda stu:stu.sno"表示将lambda函数传入对象的sno属性作为返回值。也先可以定义一个函数，如：

def GetStuSno(stu):#定义GetStuSno函数
    return stu.sno#返回stu的sno属性

元组的操作

创建元组

1、元组就是用一对小括号起来的多个元素的有序集合，各元素之间用逗号分隔。
2、如果一个元组不包含任何元素（即只有一对小括号），则该元组就是一个空元组。

例：使用（）创建元组对象示例。

t1=(1,'one','——')#创建元组对象并将其赋给变量t1，其包含3个元素
t2=()#创建元组并将其赋给变量t2，其不包含任何元素、因此是一个空元组
print('t1的值为：',t1)
print('t2的值为：',t2)

例：使用内置方法tuple创建元组对象示例。

t=tuple([1,'one','——'])#使用tuple方法根据列表创建元组对象，并赋给t变量
print('t的值为：',t)
print('t的第一个元素和最后一个元素的值分别为：',t[0],t[-1])
print('t的前两个元素的值为：',t[0:-1])

注：如果使用（）创建的元组中只包含单个元素，则需要在这唯一的一个元素后面添加逗号，否则小括号会被系统认为是括号运算符、而不会被认为是在创建元组。

例：使用（）创建具有单个元素的元组对象示例。

t1=(15)#不加逗号，则t1是一个整型变量
t2=(15,)#加逗号，则t2是一个元组
print('t1的类型为：',type(t1))
print('t2的类型为：’，type(t2))

注：虽然元组中的元素值不允许修改，但通过拼接运算可以两个元组连接、生成一个新元组。

例：拼接元组示例。

t1=(1,2,3)#创建元组的对象并赋给变量t1
t2=('Python','C++')#创建元组对象并赋给变量t2
t3=t1+t2#通过拼接运算"+"将t1和t2连接生成通过新的元组对象并赋给t3
print('t1和t2的值分别为：',t1,t2)
print('t3的值为：',t3)

注：使用max和min方法可以分别获取一个元组中最大元素和最小元素的值，语法格式如下：
max(t),min(t)

例：获取元组中最大、最小元素示例。

t=(23,56,12,37,28)#创建元组对象并赋给t
print('t中的最大元素值为：',max(t))#输出t中最大元素的值
print('t中的最小元素值为：',min(t))#输出t中最小元素的值

集合的创建和插入元素

集合的创建

可以使用一对大括号{}或set函数创建集合，如果要创建空集合则只能使用set函数。
集合中不能包含有重复值的元素。如果创建集合或向集合中插入元素时，指定的元素具有重复值，则集合会自动过滤掉重复值的元素、使得每种取值的元素只保留一个。

例：创建集合示例。

s=set([23,37,12,37,28])#创建集合对象并赋给s
print('s的值为：',s)#输出s

插入集合元素

1、集合中提供了两种插入元素的方法，分别是add和update。add和update。add方法的语法格式为：
s.add(x)
其作用是把x作为一个新的元素插入到集合s中，其中x必须是一个可哈希对象。
update方法的语法格式为：
s.update(x)
其作用是把x拆分成多个元素后再将这多个元素插入到集合中，其中x必须是一个可迭代对象。

例：add方法和update方法使用示例。

s1=set([1,2])#创建集合对象并赋给变量s1
s2=set([1,2])#创建集合对象并赋给变量s2
s1.add('Python')#使用add方法向s1中插入元素'Python'
s2.update('Python')#使用update方法将'Python'拆分成多个元素再插入到s2中
print('s1的值为：',s1)
print('s2的值为：',s2)
#s1.add([4,5])#取消前面的注释则会报错
s2.update([4,5])#使用update方法将[4,5]拆分成多个元素再插入到s2中
print('s1的值为：',s1)
print('s2的值为：',s2)
s1.add(3)#使用add方法向s1中插入元素3
#s2.update(3)#取消前面的注释则会报错

注：定义第7行代码，因为add方法要求插入到集合中的元素必须是可哈希的，而列表是不可哈希的、所以如果取消前面的注释则会报错。
对于第12行代码，因为update方法要求传入的参数必须是可迭代的，而整数是不可迭代的、所以如果取消前面的注释则会报错。

集合运算

交集和并集

集合中的intersection方法可以用于计算一个集合与另一个集合的交集，语法格式为：
s1.intersection(s2)
其作用是计算s1和s2的交集并返回。intersection方法不会修改s1和s2本身的值。
集合中的union方法可以用于计算一个集合与另一个集合的并集，语法格式为：
s1.union(s2)
其作用是计算s1和s2的并集并返回。union方法不会修改s1和s2本身的值。

差集

集合中的difference方法可以用于计算一个集合与另一个集合差集，语法格式为：
s1.difference(s2)
其作用是计算s1和s2的差集并返回，差集是指由包含在s1中但不包含在s2中的元素组成的集合。difference方法不会修改s1和s2的本身的值。

对称差集

集合中的symmetric_difference方法可以用于计算一个集合与另一个集合的对称差集，语法格式为：
s1.symmetric_difference(s2)
其作用是计算s1和s2的对称差集并返回，对称差集是指由包含在s1或包含在s2中的元素组成的集合。symmetric_difference方法不会修改s1和s2本身的值。

例：集合的交、并、差、对称差示例。

s1=set([1,2,3])
s2=set([2,3,4])
s3=s1.intersection(s2)#{2,3}
s4=s1.union(s2)#{1,2,3,4}
s5=s1.difference(s2)#{1}
s6=s1.symmetric_difference(s2)#{1,4}
print('s1和s2的值分别为：',s1,s2)
print('s1和s2的交集为：',s3)
print('s1和s2的并集为：',s4)
print('s1和s2的差集为：',s5)
print('s1和s2的对称差集为：',s6)

子集和父集

集合中的issubset方法用于判断一个集合是否是另一个集合的子集，语法格式为：
s1.issubset(s2)
其作用是判断s1是否是s2的子集。如果s1是s2的子集，则返回True；否则，返回False。
集合中的issuperset方法可以用于判断一个集合是否是另一个集合的父集，语法格式为：
s1.issuperset(s2)
其作用是判断s1是否是s2的父集（即判断s2是否是s1的子集）。如果s1是s2的父集，则返回True；否则，返回False。

s1=set([1,2,3,4])#创建集合对象并赋给变量s1
s2=set([2,3,4,5])#创建集合对象并赋给变量s2
s3=set([1,3])#创建集合对象并赋给变量s3
print('s3是s1的子集：',s3.issubset(s1))
print('s1是s3的父集：',s1.issuperset(s3))
print('s3是s2的子集：',s3.issubset(s2))
print('s2是s3的父集：',s3.issuperset(s2))

字典的创建和初始化

创建字典

1、与集合类似，字典（dictionary）也是由若干无序的元素组成。
2、但与集合不同的是，字典是一种映射类型，字典中的每个元素都是键（key）：值（value）对的形式。
3、字典中每个元素键的取值必须唯一（即集合中不能包含键相同的元素）且必须是可哈希类型的数据，但对于每个元素的取值则没有任何限制。
4、字典的主要应用是做数据的快速检索。实际使用字典时，将要查询的数据作为键，将其他数据作为值。例如，在进行学生信息管理时，经常要根据学号进行学生信息的查询，此时就可以将学号作为键、而将其他信息作为值。
5、可以使用一对大括号{}或dict函数创建字典，如果要创建空字典可以使用{}或dict()。

fromkeys方法的语法格式为：

d.fromkey(seq,value)
其中，d是一个已创建的字典对象；seq是一个包含了字典所有键名的序列；value是一个可选参数，其指定了个元素的初始值，默认情况下所有元素的值都被赋为None。

d1={}.fromkeys(['sno','name','major'])
d2=dict().fromkeys(['sno','name','major'],'Unknown')
print('d1的值为：',d1)
print('d2的值为：',d2)

注：如果使用的字典对象中原来已经有其他元素，则调用fromkeys方法后原有的元素都会被清除。

d1=dict(age=18)
print('d1的值为：',d1)
d2=d1.fromkeys(['sno','name','major'])
print('d2的值为：',d2)

字典元素的修改、插入和删除

字典元素的修改和插入

给指定键的元素赋值时，如果该键在字典中已存在，则会将该键对应的元素值做修改；如果该键在字典中不存在，则会在字典中插入一个新元素。
另外，也可以使用字典中的update方法一次修改或插入多个元素，update方法的语法格式为：
d.update(d2)#用另一个字典对象d2的元素修改或插入字典对象d的元素
或
d.update(键1=值1，键2=值2,…,键N=值N)#用键值列表修改或插入字典对象d的元素

例：修改/插入字典元素示例

stu=dict(sno='1810101')#创建字典对象并赋给变量stu
print(stu)#输出"{'sno':'1810101'}"
stu['sno']='1810100'#将键为'sno'的元素的值修改为'1810100'
print(stu)#输出"{'sno','1810100'}"
stu['name']='小明'#插入一个键为'name'的元素，其值为'小明'
print(stu)#输出"{'sno':'1810100','name':'小明'}"
stu.update({'name':'小红','age':19})
print(stu)#输出"{'sno':'1810100','name':'小红','age':19}"
stu.update(name='张刚',major='计算机')
print(stu)#输出"{'sno','1810100','name':'张刚','age':19,'major':'计算机'}"

字典元素的删除

使用del可以删除某个元素，也可以使用字典中的pop方法删除指定键的元素。pop方法的语法格式为：
d.pop(key,default)
其作用是从字典d中删除键为key的元素并返回该元素的值；如果d中不存在键为key的元素，则返回default参数的值。

例：删除字典元素示例。

d=dict(sno='1810100',name='小明',age=19)#创建字典对象并赋给变量d
print('第2行输出的字典d：',d)#输出d的值
del d['age']#使用del删除d中键为'age'的元素
name=d.pop('name')#使用pop删除d中键为'name'的元素，并将返回的元素值赋给name
print('name的值为：',name)
print('第6行输出的字典d：',d)
major=d.pop('major','Not found')
print('major的值为：',major)

字典的浅拷贝和深拷贝

浅拷贝

使用字典中的copy方法可以实现一个字典的浅拷贝。copy方法的语法格式为：
d.copy()
其作用是返回一个对字典d进行浅拷贝而得到的字典。

例：浅拷贝示例。

stu1={'name':'小明','age':19,'score':{'Python':95,'math':92}}
stu2=stu1#直接赋值，此时stu2和stu1指向同一个字典对象
stu3=stu1.copy()#使用copy方法进行浅拷贝
print('stu1、stu2和stu3的内存地址分别为：'id(stu1),id(stu2),id(stu3))
stu1['name']='小红'#将stu1中键为name的元素的值修改为'小红'
print('stu1的值为：',stu1)
print('stu2的值为：',stu2)
print('stu3的值为：',stu3)
print("stu1['score']和stu3['score']的内存地址分别为：",id(stu1['score']),id(stu3['score']))
stu1['score']['Python']=100
print('stu1的值为：',stu1)
print('stu3的值为：',stu3)

深拷贝

使用copy模块的deepcopy方法可以实现深拷贝，deepcopy方法的语法格式为：copy.deepcopy(d)
其作用是根据字典d进行深拷贝创建一个新的字典对象并返回。
深拷贝不仅使得原有字典对象和生成的字典对应不同的内存空间，而且使得两个字典对象中的可变类型元素对应不同的内存空间，从而使得两个字典对象完全独立。

import copy#导入copy模块
stu1={'name':'小明','age':19,'score':{'Python':95,'math':92}}
stu2=copy.deepcopy(stu1)#使用deepcopy方法进行深拷贝
print("stu1和stu2的内存地址分别为：",id(stu1),id(stu2))
print("stu1['score']和stu2['score']的内存地址分别为：",id(stu1['score']),id(stu2['score']))
stu1['score']['Python']=100
print('stu1的值为：',stu1)
print('stu2的值为：',stu2)

判断字典中是否存在键及拼接两个字典

判断字典中是否存在键

我们可以使用两种方法判断字典中是否存在某个键。一种是使用字典中的get方法，其语法格式为：
d.get(key,default=None)
其作用是从字典d中获取键为key的元素的值并返回。如果在字典d中不存在键为key的元素，则返回default参数的值（默认为None）。
另一种方法是使用成员运算符in。

例：判断字典中是否存在键示例

d=dict(sno='1810100',name='小明')
if d.get('sno')!=None:如果get方法返回的不是None
   print('字典d中存在键为sno的元素')
else:
   print('字典d中不存在键为sno的元素')
if 'name'in d:#如果字典d中有键位'name'的元素
   print('字典d中存在键为name的元素')
else:
   print('字典d中不存在键为name的元素')
if d.get('age')!=None:#如果get方法返回的不是None
   print('字典d中存在键为age的元素')
else:
   print('字典d中不存在键为age的元素')

拼接两个字典

两种方法：
第一种：

dMerge=dict(d1,**d2)

第二种：

dMerge=d1.copy()
dMerge.update(d2)

注：其中，d1和d2是待拼接的两个字典，dMerge用于保存拼接后的字典。

例：拼接两个字典示例

d1=dict(sno='1810100',name='小明')#创建字典对象并赋给变量d1
d2=dict(age=19)#创建字典对象并赋给变量d2
dMerge1=dict(d1,**d2)
print('dMerge1的值为：',dMerge1)
dMerge2=d1.copy()#使用copy方法复制d1生成新的字典对象并赋给dMerge2
dMerge2.update(d2)#根据d2中的元素对dMerge2进行修改/插入操作
print('dMerge2的值为：',dMerge2)

字典的其他常用操作

计算字典中元素个数

使用Python提供的len方法可以计算字典中的元素个数，len方法的语法格式为：
len(d)
其中，d为要计算元素个数的字典

例

d=dict(sno='1810100',name='小明',age=19)#创建字典对象并赋给变量d
print('字典d中的元素个数为：',len(d))

清除字典中的所有元素

使用字典中的clear方法可以一次将一个字典中的所有元素都清除，clear方法的语法格式为：
d.clear()
其中，d为要清除元素的字典。

例

d=dict(sno='1810100',name='小明',age=19)#创建字典对象并赋给变量d
print('字典d中的元素个数为：',len(d))#输出3
d.clear()#调用方法清除d中的所有元素
print('字典d中的元素个数为：',len(d))#输出0

获取字典中键集合

使用字典中的keys方法可以获取一个字典所有的键，keys方法的语法格式为：
d.keys()
其作用是返回一个包含d中所有键的对象。

例

d=dict(sno='1810100',name='小明')#创建字典对象并赋给变量d
print('d中的键为：',d.keys())

获取字典中值集合

使用字典中的values方法可以获取一个字典所有的值，values方法的语法格式为：
d.values()
其作用是返回一个包含d中所有值的对象。

例

d=dict(sno='1810100',name='小明')#创建字典对象并赋给变量d
print('d中的值为：',d.values())

获取字典中元素数组

使用字典中的items方法可以返回一个可按（键，值）方式遍历的对象，items语法格式为：
d.items()

例

d=dict(sno='1810100',name='小明')#创建字典对象并赋给变量d
for key,value in d.items():
    print(key,value)

注：如果直接在字典上做遍历，则每次只能获取一个元素的键，然后再通过键去获取该元素的值。

切片和列表生成表达式

切片

1、从一个序列对象中获取部分元素形成一个新的序列对象是一个非常常用的操作，这个操作被称作切片（slice）。
2、切片操作除了可以取指定范围中的多个连续元素，还可以固定步长取指定范围中的多个不连续元素。

ls1=list(range(0,20))#创建包含20个元素（0至19）的列表对象并赋给ls
print('ls1:',ls1)#输出ls1
ls2=ls1[3:10:2]#从ls1下标从3至9的元素中以步长2取元素生成一个新列表赋给ls2
print('ls2:',ls2)#输出ls2
ls3=ls1[-10::3]#从倒数第10个元素开始到最后一个元素以步长3取元素生成一个新列表
print('ls3:',ls3)#输出ls3
ls4=ls1[-1:-11:-3]#从最后一个元素到倒数第10个元素以步长-3取元素生成一个新元素
print('ls4:',ls4)#输出ls4

列表生成表达式

当我们创建一个列表对象时，除了前面介绍的方法，还可以用列表生成表达式。
在列表生成表达式中，可以使用for、if以及一些运算生成列表中的元素。

例：

ls=[x*x for x in range(10)]#创建包含10个元素的列表对象并赋给ls
print(ls)#输出ls

注：即通过for使得x在0至9范围内依次取值，对于每一个x，将x*x的计算结果作为列表对象中的元素。

还可以在for后面加上if判断。

ls=[x*x for x in range(10)if x%2!=0]#创建由0至9中所有奇数的平方组成的列表对象
print(ls)#输出ls

另外，列表生成表达式中也支持多层循环的形式，这里只给出两层循环的例子。

snolist=['1810101','1810102','1810103']
namelist=['小明','小红','张刚']
ls=['学号：'+sno+',姓名:'+name for sno in snolist for name in namelist]
for stu in ls:
   print(stu)

生成器

1、当一个列表中包含大量元素时，如果一次性生成这些元素并保存在列表中，将占用大量的内存空间（有的情况下可用内存甚至无法满足存储需求）。
2、对于这个问题，我们可以通过生成器（generator）来解决，即根据需要进行计算并获取列表中某个元素的值。
3、将列表生成表达式中的一对中括号改为一对小括号即可得到生成器，对于生成器对象，也可以像其他可迭代对象一样使用for循环遍历对象中的每一个元素。

g=(x*x for x in range(10))#创建一个生成器对象并赋给g
print('g的类型为：',type(g))
for i in g:
  print(i,end='')

如果生成元素的方法比较复杂，不适合用for循环方式实现，我们还可以借助yield关键字利用函数实现生成器的功能。

例：实现faclist函数，依次生成1的阶乘、2的阶乘、…、n的阶乘。

def faclist(n):#定义函数faclist
   result=1
   for i in range(2,n+1):#i在2至n范围内依次取值
      yield result#遇到yield即暂停执行并返回result，下次执行时继续从此处开始执行
      result*=i#将i乘到result
for i in faclist(10):#遍历faclist并输出每个元素的值
   print(i,end='')

迭代器

1、可直接使用for循环遍历的对象统称为可迭代对象（Iterable）。
2、迭代器（Iterator）是指可以通过next函数不断获取下一个值的可迭代对象，并不是所有的可迭代对象都是迭代器。
3、可以使用isinstance方法判断一个对象是否是可迭代对象或迭代器。

from collection.abc import Iterable,Iterator#导入Iterable和Iterator类型
ls=[1,2,3,4,5]#创建一个列表对象
g=(x for x in range(1,6))#创建一个生成器
print('ls是可迭代对象：',isinstance(ls,Iterable))#True
print('g是可迭代对象：',isinstance(g,Iterable))#True
print('ls是迭代器：',isinstance(ls,Iterator))#False
print('g是迭代器：',isinstance(g,Iterator))#True

iter函数

对于可迭代对象，可以通过iter函数得到迭代器。

例：

from collections.abc import Iterator#导入Iterator类型
ls=[1,2,3,4,5]#创建一个列表对象
it=iter(ls)#利用iter函数获取ls的迭代器
print('it是迭代器：',isinstance(it,Iterator))

next函数

对于迭代器，则可以使用next函数不断获取下一个元素，当所有元素都获取完毕后再调用next函数，就会引发StopIteration异常。

例：

g=(x for x in range(1,3))#创建一个生成器
print('第1个元素：',next(g))
print('第2个元素：',next(g))

自定义迭代器

1、如果我们要自己定义一个类，使得该类的对象是迭代器，则需要再类中实现__ next __ 和 __ iter __ 这两个方法。
2、例：

from collections.abc import Iterator
class Faclist:#定义Faclist类
   def __init__(self):#定义构造方法
       self.n=1
       self.fac=1
def __nxet__(self):#定义next方法
    self.fac*=self.n
    self.n+=1
    return self.fac
def __iter__(self):#定义__iter__方法
    return self
if __main__=='__main__':
   facs=Faclist()
   print('facs是迭代器：',isinstance(facs,Iterator))
   for i in range(1,6):#i在1至5范围依次取值
       print('第%d个元素：'%i,next(facs))