Python学习笔记-序列、集合和字典

可变类型与不可变类型

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

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

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

内置方法id()

返回对象的“标识值”。该值是一个整数，这是对象在内在中的地址。

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

n1,n2=1,1   # 定义两个整形变量n1和n2
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))	# 指向内存地址相同

'''
第2行n1和n2的内存地址分别为： 140715745757624 140715745757624	
第4行n1和n2的内存地址分别为： 140715745757624 140715745757688
第6行n1和n2的内存地址分别为： 140715745757688 140715745757688
'''

s1,s2='Python','Python'     # 定义两个字符串变量
print('第8行s1和s2的内存地址分别为：',id(s1),id(s2))
s2='C++'
print('第10行s1和s2的内存地址分别为: ',id(s1),id(s2))
s1='C++'
print('第12行s1和s2的内存地址分别为: ',id(s1),id(s2))

'''
第8行s1和s2的内存地址分别为： 140714124530480 140714124530480		# 相同内存地址
第10行s1和s2的内存地址分别为:  140714124530480 1910625490224
第12行s1和s2的内存地址分别为:  1910625490224 1910625490224		# 相同内存地址
'''

t1,t2=(1,2,3),(1,2,3)   # 定义两个元组变量t1和t2
print('第14行t1和t2内存地址分别为:',id(t1),id(t2))
t2=(4,5,6)  # 被重新赋值为(1,2,3)
print('第16行t1和t2内存地址分别为:', id(t1),id(t2))
t1=(4,5,6)  # 被重新赋值为(1,2,3)
print('第16行t1和t2内存地址分别为:', id(t1),id(t2))

'''
第14行t1和t2内存地址分别为: 2987645718208 2987645718208
第16行t1和t2内存地址分别为: 2987645718208 2987646173120
第16行t1和t2内存地址分别为: 2987646173120 2987646173120
'''

ls1,ls2=[1,2,3],[1,2,3] # 定义两个列表变量
print('第18行ls1和ls2内存地址分别为:',id(ls1),id(ls2))
ls2[1]=5     #将ls2中下标为1的元素=2，重新赋值为5-->[1,5,3]
print('第20行ls1和ls2的内存地址分别:',id(ls1),id(ls2))
ls2=[1,2,3] # 重新赋值为[1,2,3]
print('第22行ls1和ls2内存地址分别为：:',id(ls1),id(ls2))
'''
第18行ls1和ls2内存地址分别为: 2512060928384 2512060930240
第20行ls1和ls2的内存地址分别: 2512060928384 2512060930240
第22行ls1和ls2内存地址分别为：: 2512060928384 2512061267328
'''

创建列表

列表就是用一对[ ]中括号括起来的多个元素的有序集合，各元素之间用逗号分给。

如果一个列表中不包含任何元素（即只有一对中括号），则该列表就是一个空列表。

ls1=[1,'one','一']   # 创建列表ls1，其包含3个元素
ls2=[]  # 创建一个空列表（不包含任何元素）

print('ls1的值为：',ls1)
print('ls2的值为：',ls2)

内置方法list()

例：使用list方法创建列表对象。

ls=list((1,'one','一'))		# 等同于以下两条注释语句
# t=(1,'one','一')	# 创建元组对象并赋给t
# ls=list(t)	# 根据元组t创建列表对象并赋给ls
print('ls的值为：',ls)
print('ls的第一个元素和最后一个元素的值分别为：',ls[0],ls[-1])	
print('ls的前两个元素的值为：',ls[0:-1])

'''
ls的值为： [1, 'one', '一']
ls的第一个元素和最后一个元素的值分别为： 1 一
ls的前两个元素的值为： [1, 'one']
'''

拼接列表

通过拼接运算可以将多个列表连接在一起，生成一个新的列表。

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

复制列表元素

Python中，通过赋值运算实际上是将两个变量指向同一个对象（具有相同的内存地址），而不是将一个变量的值赋给另一个变量。

两个变量指向同一个对象后，我们通过一个变量修改对象中元素的值，那么通过另一个变量访问对象时，访问到的对象中的元素值也是修改后的值 。

ls1=[1,2,3]
ls2=ls1	 # 通过赋值运算ls2和ls1指向同一个对象
print('ls1和ls2的值分别为:',ls1,ls2)		# 输出值相同	
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))	# 输出内存地址也相同

ls1[1]=5    # 将ls1中下标为1的元素值修改为5：2-->5
print('ls1和ls2的值分别为:',ls1,ls2)	
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))

'''
ls1和ls2的值分别为: [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 2042183012736 2042183012736
ls1和ls2的值分别为: [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 2042183012736 2042183012736
'''

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

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

浅拷贝和深拷贝

A=[1,5,6]
浅拷贝：生成了一个新的对象B，没有生成新的“指向对象”，A和B同时指向[1,5,6]。
		A----->[1,5,6]<------B
深拷贝：生成了一个新的对象C，也生成了一个新的“指向对象[1,5,6]”。
	A----->[1,5,6]
	C----->[1,5,6]

示例1：无嵌套（无子对象元素）

ls1=[1,2,3]
ls2=ls1[:]  # 将ls1的所有元素截取生成新的对象并赋给ls2

print('ls1和ls2的值分别为',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))	

ls1[1]=5
print('ls1和ls2的值分别为:',ls1,ls2)

'''
ls1和ls2的值分别为 [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 2811906216320 2811906218176	（内存地址不同，说明是生成的新的对象）
ls1和ls2的值分别为: [1, 5, 3] [1, 2, 3]	(修改了ls1，但并未影响到ls2)
'''

示例2：有嵌套（有子对象）

ls1=[1,[2,3]]	# 包含一个元素1，以及一个子对象[2,3]
ls2=ls1[:]	# 生成新的对象ls2
print('ls1和ls2的值分别为：',ls1,ls2)	# 值相同
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))	# 内存地址不同

print('ls1[1]和ls2[1]的值分别为:',ls1[1],ls2[1])		# 输出[2, 3] [2, 3]
print('ls1[1]和ls2[1]的内存地址分别为:',id(ls1[1]),id(ls2[1])) # 列表中下标为1的元素内存地址相同

ls1[0]=2       # 修改ls1下标为0的元素值为2
ls1[1][0]=5		#修改ls1子元素 [2,3]--->[5,3]
print('ls1和ls2的值分别为：',ls1,ls2)	# 子元素输出值相同，为什么？
# 浅拷贝后，如果修改子对象是可变的，那么两个对象同时改变。反之就是不会同时改变。	
# 1、虽然ls1和ls2具有不同的内存地址。
# 2、但ls1和ls2下标为1的元素值具有相同的地址空间,所有修改这个元素值后，输出相同

ls1和ls2的值分别为： [1, [2, 3]] [1, [2, 3]]
ls1和ls2的内存地址分别为: 2390967048384 2390967385472 
ls1[1]和ls2[1]的值分别为: [2, 3] [2, 3]
ls1[1]和ls2[1]的内存地址分别为: 2390967046528 2390967046528
ls1和ls2的值分别为： [2, [5, 3]] [1, [5, 3]]  

深拷贝deepcopy函数（copy模块）

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

import copy
ls1=[1,[2,3]]
ls2=copy.deepcopy(ls1)  # 通过调用deepcopy函数复制ls1生成新对象并赋给ls2
print('ls1和ls2的值分别为：',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))

print('ls1[1]和ls2[1]的值分别为:',ls1[1],ls2[1])
# print('ls1[1]和ls2[1]的内存地址分别为:',id(ls1[1]),id(ls2[1]))
#
ls1[1][0]=5
print('ls1和ls2的值分别为：',ls1,ls2)	# 输出值不相同，深拷贝？？？

'''
ls1和ls2的值分别为： [1, [2, 3]] [1, [2, 3]]
ls1和ls2的内存地址分别为: 1401369055616 1401371294272
ls1[1]和ls2[1]的值分别为: [2, 3] [2, 3]
ls1和ls2的值分别为： [1, [5, 3]] [1, [2, 3]]
'''

列表元素的查找(index)、插入(insert)、追加(append)和删除（del）

通过列表中的index方法可以根据指定值查找第一个匹配的列表元素的位置。

index()方法

例：查找元素3出现的索引位置。

ls=[1,2,5,3]
print('ls值为3的元素第一次出现的位置为:',ls.index(5))

ls值为3的元素第一次出现的位置为: 2 (从左至右，从0开始)。

insert()与append()方法

ls=[1,2,3]
ls.insert(0,'Python')   # 在ls列表下标为0的位置插入新元素Python
print(ls)   # 输出['Python',1,2,3]

ls.insert(2,True)   # 在ls列表下标为2的位置插入新元素True
print(ls)

ls.append([5,10])   # 在ls列表最后添加新元素[5,10]
print(ls)   

['Python', 1, 2, 3]
['Python', 1, True, 2, 3]
['Python', 1, True, 2, 3, [5, 10]]

del()方法

可以删除某个变量或列表中的某个元素。

如果要删除列表中的连续多个元素，与可以截取列表中的连续多个元素并将其赋为空列表。

ls=[0,1,2,3,4,5,6,7,8,9]
del ls[8] # 使用del将ls中下标为8的元素删除
print(ls)
ls[1:6]=[]  # 将ls中下标为1至5的元素删除
print(ls)

[0, 1, 2, 3, 4, 5, 6, 7, 9]
[0, 6, 7, 9]

列表元素的最大值(max)、最小值(min)、出现次数（count）和列表长度(len)

ls=[23,56,12,37,28,12,23,66,12,47,88,12,23,76]
print('ls中最大的元素值为:',max(ls))	# 统计最大值
print('ls中最小的元素值为:',min(ls))	# 统计最小值
lens=len(ls)	# 统计列表元素数量（即列表长度）
print(f'ls列表中包含了{lens}个元素')

c=ls.count(12)
d=ls.count(23)
print(f'元素12一共出现了{c}次')
print(f'元素23一共出现了{d}次')

ls中最大的元素值为: 88
ls中最小的元素值为: 12
ls列表中包含了14个元素
元素12一共出现了4次
元素23一共出现了3次

列表元素的排序sort（）

语法格式

ls.sort(key=None,reverse=Flase)
# key接收一个函数，通过该函数获取用于排序时比较大小的数据。
# reverse指定是将列表中的元素按升序（False，默认值）还是按降序（True）排列。

'''
key=lambda stu:stu.sno 表示将lambda函数传入对象的sno属性作为返回值。
也可以先定义一个函数，如：
def GetStuSno(stu)：
	return stu.sno	# 返回stu的sno属性
	
再将key=lambda stu:stu.sno，该为如下：
ls2.sort(key=GetStuSno)	# 按升序
ls2.sort(key=GetStuSno,reverse=True) # 按降序
'''
class Student:  # 定义学生类
    def __init__(self,sno,name):    # 定义构造方法
        self.sno = sno
        self.name = name

    def __str__(self):  # 定义内置方法__str__
        return '学号：'+self.sno+',姓名：'+self.name

if __name__=='__main__':
    ls1=[23,56,12,37,28]
    ls1.sort()  # 将ls1中的元素按升序排列
    print('ls1升序排序后的结果：',ls1)
    ls1.sort(reverse=True)  # 将ls1中的元素按降序排序
    print('ls1降序排序后的结果：',ls1)

ls2=[Student('1810101','李晓明'),Student('1810100','马红'),Student('1810102','张刚')]
ls2.sort(key=lambda stu:stu.sno)    # 按学号升序排序
print('ls2按学号升序排序后的结果：')	# 仅输出一句话
for stu in ls2:	 # 遍历ls2中的每名学生并输出
    print(stu)
    
ls2.sort(key=lambda stu:stu.sno,reverse=True)   # 按学号降序排列
print('ls2按学号降序排序后的结果：')
for stu in ls2:
    print(stu)

ls1升序排序后的结果： [12, 23, 28, 37, 56]
ls1降序排序后的结果： [56, 37, 28, 23, 12]

ls2按学号升序排序后的结果：
学号：1810100,姓名：马红
学号：1810101,姓名：李晓明
学号：1810102,姓名：张刚

ls2按学号降序排序后的结果：
学号：1810102,姓名：张刚
学号：1810101,姓名：李晓明
学号：1810100,姓名：马红

元组的操作

元组就是使用一对小括号括起来的多个元素的有序集合，各元素之间用逗号分隔。

如果一个元组不包含任何元素 (即只有一对小括号)，则该元组就是一个空元组。

t1=(1,'one','一')    # 包含3个元素
t2=()   # 空元组

#使用内置方法tuple创建元素对象示例。
t=tuple([1,'one','一'])
print('t的值为：',t)
print('t的第一个元素和最后一个元素的值分别为:',t[0],t[-1])
print('t的前两个元素的值为:',t[0],t[1]) # 与下一条语句输出的元素为不同类型
print('t的前两个元素的值为:',t[:2])	# 与上一条语句输出的元素为不同类型

'''
t的前两个元素类型为: <class 'int'> <class 'str'>
t的前两个元素类型为: <class 'tuple'>
'''
t的值为： (1, 'one', '一')
t的第一个元素和最后一个元素的值分别为: 1 一
t的前两个元素的值为: 1 one
t的前两个元素的值为: (1, 'one')

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

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

t1的类型为： <class 'int'>
t2的类型为: <class 'tuple'>

拼接元组（与列表相同）

获取元组中的最大、最小元素（与列表相同）

集合的创建和插入元素

可以使用一对大括号或set函数创建集合，如果要创建空集合则只能使用set函数。

集合中不能包含有重复值的元素。如果创建集合或向集合中插入元素时，指定的元素具有重复值，则集合会自动过滤调重复值的元素，使得每种取值的元素只保留一个。

s=set([23,37,12,37,28])		# 使用set函数创建集合对象并赋给s
print('s的值为:',s)

s的值为: {28, 12, 37, 23} 	# 自动过滤调重复的元素37

插入集合元素，add和update方法

s.add(x)
	add：作用是把x作为新的元素插入到集合s中，其中x必须是一个可哈希对象。
	（列表是不可哈希对象TypeError: unhashable type: 'list'）

s.update(x)
	update：作用是把x拆分成多个元素（打乱顺序）后再将这多个元素插入到集合中，其中x必须是一个可迭代对象。
	（整数是不可迭代的TypeError: 'int' object is not iterable）

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

s1=set([1,2])
s2=set([1,2])

s1.add('Python')     # s1中插入元素'Python'
s2.update('Python')  # 将'Python'拆分成多个元素（顺序打乱了），再插入到s2中
print('s1的值为:',s1)
print('s2的值为:',s2)

# s2.update([4,5])	# 列表是不可哈希对象，取消注释会报错
print('s1的值为:',s1)
print('s2的值为:',s2)
s1.add(3)   # 插入元素3	
# s2.update(3)		# 整数是不可迭代对象，取消注释会报错

s1的值为: {'Python', 1, 2}
s2的值为: {1, 2, 'P', 'h', 't', 'y', 'n', 'o'}
s1的值为: {'Python', 1, 2}
s2的值为: {1, 2, 'P', 4, 5, 'h', 't', 'y', 'n', 'o'}

集合的运算

intersection方法（交集）

计算一个集合与另一个集合的交集，不会修改s1和s2本身的值。语法格式为：
s1.intersection(s2)

union方法（并集）

计算一个集合与另一个集合的并集，不会修改s1和s2本身的值。语法格式为：
s1.union(s2)

difference方法（差集）

计算一个集合与另一个集合的差集，不会修改s1和s2本身的值。语法格式为：
s1.difference(s2)

symmetric_difference（对称差集）

对称差集是指由包含在s1中或s2中元素组成的集合，不会修改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)

s1和s2的值分别为： {1, 2, 3} {2, 3, 4}
s1和s2的交集为： {2, 3}
s1和s2的并集为： {1, 2, 3, 4}
s1和s2的差集为： {1}
s1和s2的对称差集为： {1, 4}

子集issubset

用于判断一个集合是否是另一个集合的子集，语法格式为：
s1.issubset(s2)，判断s1是否是s2的子集，如果是，则返回True；否则返回False。

父集issuperset

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

例：子集和父集判断示例。

s1=set([1,2,3,4])
s2=set([2,3,4,5])
s3=set([1,3])

print('s3是s1的子集：',s3.issubset(s1))
print('s1是s3的父集,',s1.issuperset(s3))
print('s3是s2的子集：',s3.issubset(s2))
print('s2是s3的父集,',s3.issuperset(s2))

s3是s1的子集： True
s1是s3的父集, True
s3是s2的子集： False
s2是s3的父集, False

字典的创建和初始化

与集合类似，字典（dictionary）也是有若干无序的元素组成。
但与集合不同的是，字典是一种映射类型，字典中的每个元素都是键（key）:值（value）对的形式。

字典中每个元素键的取值必须唯一（即集合中不能包含相同的元素）且必须是可哈希类型的数据，但对于每个元素值的取值则没有任何限制。

字典的主要应用是做数据的快速检索。将要查询的数据作为键，将其他数据作为值。

可以使用一对大括号{ }或dict函数创建字典，如果要创建空字典可以使用{ }或dict（）。

stu=dict(name='李晓明',age=18,score={'python':95,'math':92})
stu1={'name':'李晓明','age':18,'score':{'Python':95,'math':92}}
print(stu['score']['math'])	# 输出92
print(stu1['score']['Python'])	# 输出95

初始化字典元素fromkeys方法

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

例：fromkeys使用示例。

d1={}.fromkeys(['sno','name','major'])	# 指定了键，没指定value（默认为None）
d2=dict().fromkeys(['sno','name','major'],'Unknown')
print('d1的值为：',d1)
print('d2的值为：',d2)

d1的值为： {'sno': None, 'name': None, 'major': None}  
d2的值为： {'sno': 'Unknown', 'name': 'Unknown', 'major': 'Unknown'}

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

d1=dict(aage=18)
print('d1的值为：',d1)

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

d1的值为： {'aage': 18}
d2的值为： {'sno': None, 'name': None, 'major': None}

字典元素的修改/插入（update）

给指定键的元素赋值时，如果该键在字典中已经存在，则会将该键对应的元素值做修改；如果改键在字典中不存在，则会在字典中插入一个新元素。

另外，也可以使用字典中的update方法一次修改或插入多个元素。

update方法的语法格式为：

d.update(d2)	# 用另一个字典对象d2的元素修改或插入字典对象d的元素

d.update(key1=value1,key2=value2,...,keyN=valueN) # 用键值列表修改或插入字典对象d的元素

例：字典元素的修改和插入。

stu=dict(sno='1810101') # 创建字典对象并赋给变量stu
print(stu)
stu['sno']='1811111'    # 将键为'sno'的元素的值修改为1811111
print(stu)
stu['name']='李晓明'   # 插入一个键为name的元素，其值为’李晓明‘

stu.update({'name':'马红','age':18})
print(stu)

stu.update(name='张刚',major='计算机')
print(stu)

{'sno': '1810101'}
{'sno': '1811111'}
{'sno': '1811111', 'name': '马红', 'age': 18}
{'sno': '1811111', 'name': '张刚', 'age': 18, 'major': '计算机'}

字典元素的删除(del、pop)

使用del可以删除某个元素，也可以使用字典中的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)

第2行输出字典的d: {'sno': '1810100', 'name': '李晓明', 'age': 19}
name的值为: 李晓明
第6行输出的字典d： {'sno': '1810100'}
major的值为： Not found

字典的浅拷贝(copy)

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

stu1={'name':'李晓明','age':18,'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)

# 输出结果中stu1和stu2的值相同，因为都是指向同一个字典对象，具有相同的内存空间。
#	stu1--->字典对象<---stu2
#	stu3--->新字典对象

stu1,stu2,stu3的内存地址分别为： 2770961038784 2770961038784 2770962937600
stu1的值为 {'name': '马红', 'age': 18, 'score': {'Python': 95, 'math': 92}}
stu2的值为 {'name': '马红', 'age': 18, 'score': {'Python': 95, 'math': 92}}
stu3的值为 {'name': '李晓明', 'age': 18, 'score': {'Python': 95, 'math': 92}}

深拷贝

使用copy模块的deepcopy方法可以实现深拷贝，语法格式为: copy.deepcopy(d)，其作用是根据字典d进行深拷贝创建一个新的字典对象并返回。

深拷贝使原有字典对象和生成的字典对象对应不同的内存空间，而且使得两个字典对象中的可变类型元素对应不同的内存空间，从而使得两个字典对象完全独立。

例：使用copy.deepcopy()方法进行深拷贝。

import copy # 导入copy模块
# stu1=dict(name='李晓明',age=19,score={'python':95,'math':92}) # 两种创建字典方法都可以
stu1={'name':'李晓明','age':19,'score':{'python':95,'math':92}}
stu2=copy.deepcopy(stu1)    # 深拷贝copy.deepcopy()
print("stu1['score']和stu2['score']的内存地址分别为:",id(stu1['score']),id(stu2['score']))	# 输出不同的内存地址空间

stu1['score']['python']=100
print('stu1的值为：',stu1)   # python：100   
print('stu2的值为:',stu2)   # python：95

判断字典中是否存在键（get方法）

• 使用字典中的get方法，其语法格式为：d.get(key,default=None)，其作用是从字典d中获取键为key的元素的值并返回。如果指定的键不存在，则返回default参数值（默认为None）。
• 使用成员运算符in。

d=dict(sno='1810100',name='李晓明')
if d.get('sno')!= None:     # 如果get方法返回的不是None(说明存在'sno'这个键)
    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的元素')
    
字典d中存在键为sno的元素
字典d中存在键为name的元素
字典d中不存在键为age的元素

拼接两个字典

• 第一种：dMerge=dict(d1,**d2)
• 第二种：
  • dMerge=d1.copy()
  • dMerge.update(d2)

d1=dict(sno='1810100',name='李晓明')
d2=dict(age=19)

dMerge1=dict(d1,**d2)
print('dMerge1的值为:',dMerge1)

dMerge2=d1.copy()  # 使用copy方法复制d1生成新的字典对象并赋给dMerge2
dMerge2.update(d2) # 根据d2中的元素对dMerge2进行修改/插入操作
print('dMerge2的值为:',dMerge2)

dMerge1的值为: {'sno': '1810100', 'name': '李晓明', 'age': 19}
dMerge2的值为: {'sno': '1810100', 'name': '李晓明', 'age': 19}

计算字典中元素个数(len)

d1=dict(sno='1810100',name='李晓明')
l=len(d1)	# 统计字典d1中的元素个数
print(l)

2

清除字典中所有元素(clear)

可以一次将一个字典中的所有元素都清除（成为空字典），语法格式为:d.clear()，d为要清除元素的字典。

d1=dict(sno='1810100',name='李晓明')
print(d1)
d1.clear()	# 清除字典d1中的所有元素
print(d1)

{'sno': '1810100', 'name': '李晓明'}
{}

获取字典中键集合（keys）

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

d1=dict(sno='1810100',name='李晓明')
print(d1)
v1=d1.keys()	# 获取字典d1所有键的集合
print(v1)

{'sno': '1810100', 'name': '李晓明'}
dict_keys(['sno', 'name'])

获取字典中值集合（values）

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

d1=dict(sno='1810100',name='李晓明')
print(d1)
v1=d1.values()
print(v1)

{'sno': '1810100', 'name': '李晓明'}
dict_values(['1810100', '李晓明'])

获取字典中元素数组（items）

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

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

d1=dict(sno='1810100',name='李晓明')
for key,value in d1.items():
    print(key,value)
    
sno 1810100
name 李晓明

切片和列表生成表达式

从一个序列对象中取部分元素形成一个新的序列对象是一个非常常用的操作，这给操作被称为切片（slice）。

切片操作除了可以取指定范围中的多个连续元素，还可以以固定步长取指定范围中的多个不连续元素。

ls1=list(range(0,20))   # 创建包含20个元素（0~19）的列表对象并赋给ls1
print('ls1：',ls1)

ls2=ls1[3:10:2]     # 从下标3至9的元素中以步长2取元素生成一个新列表赋给ls2
print('ls2:',ls2)

ls3=ls1[-10::3]     # 从倒数第10个元素开始到最后一个元素以步长3取元素生成一个新列表
print('ls3:',ls3)

ls4=ls1[-1:-11:-3]  # 从最后一个元素到倒数第10个元素以步长-3取元素，生成一个新列表
print('ls4:',ls4)

ls1： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
ls2: [3, 5, 7, 9]
ls3: [10, 13, 16, 19]
ls4: [19, 16, 13, 10]

列表生成表达

# 通过for是的x在0~9范围内依次取值，对于每一个x，将x*x的计算结果作为列表对象中的元素。
ls=[x*x for x in range(10)] # 创建包含10个元素（0~9）的列表对象并赋给ls
print(ls)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

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

[1, 9, 25, 49, 81]

例：也支持多层循环

snolist=['1810100','1810102','1810103']
namelist=['李晓明','马红','张刚']

ls=['学号:'+sno+',姓名: '+ name for sno in snolist for name in namelist]

for stu in ls:
    print(stu)
    
学号:1810100,姓名: 李晓明
学号:1810100,姓名: 马红
学号:1810100,姓名: 张刚

学号:1810102,姓名: 李晓明
学号:1810102,姓名: 马红
学号:1810102,姓名: 张刚

学号:1810103,姓名: 李晓明
学号:1810103,姓名: 马红
学号:1810103,姓名: 张刚