Python第五章序列，集合，字典_含集合、序列、字典的python

---

一、切片

介绍

python中没有字符类型，有字符串类型String可以写在一对单引号或双引号或者三引号。
Python中提供了int和float函数，可以将字符串转换成整数和浮点数。
（1）int函数有两个参数，第一个参数是要转换的字符串，第二个参数是数制（默认是十进制）
（2）float函数只有一个参数
int函数和float函数中要转换的字符不允许出现“+”，否则会报错。

1.函数float函数和eval函数的区别：

eval函数的功能是计算字符串所对应的表达式的值，返回表达式的计算结果。

// An highlighted block
r=eval(input("请输入一个有效的表达式"))
1
2

如果输入3+5，通过print（r）可以得到8
1

2. 利用下标“[]”可以从字符串（列表，元组）中截取一个子串

s[beg,end]

s:原始字符串
beg：起始下标
end：结束下标（不包括end）

s[:end]等价于s[0,end]
s[beg:]从beg开始截取，直到最后一个字符（包括最后一个字符）
s[:]表示子串包含s中所有字符。
1
2
3

含有步长的切片：
步长为正，从前向后取值
步长为负，从后向前取值
1
2
3

二、浅拷贝和深拷贝

1.浅拷贝

浅拷贝用copy，
浅拷贝使原有的字典对象和生成的字典对象具有一定的独立性，但是不完全独立；虽然他们对应不同的内存空间，但是当字典中含有可变类型的元素时，就会产生问题，此时两个字典中可变元素对应着相同的内存空间。
代码如下（示例）：

"""
copy实现一个字典的浅拷贝
"""
stu1={'name':'李明','age':19,'score':{'python':95,'math':92}}
stu2=stu1#直接赋值，此时stu1和stu2指向同一个字典对象
stu3=stu1.copy()
print('stu1,stu2和stu3的内存地址分别为：',id(stu1),id(stu2),id(stu3))#stu1和stu2内存地址一样和stu3不一样
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)#stu1的值为 {'name': '马红', 'age': 19, 'score': {'python': 100, 'math': 92}}
print('stu3的值为：',stu3)#stu3的值为： {'name': '李明', 'age': 19, 'score': {'python': 100, 'math': 92}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 运行结果
stu1,stu2和stu3的内存地址分别为： 2303311304768 2303311304768 2303311304832
stu1的值为： {'name': '马红', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu2的值为： {'name': '马红', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu3的值为： {'name': '李明', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu1[score]和stu3[score]的内存地址分别为： 2303311304576 2303311304576
stu1的值为 {'name': '马红', 'age': 19, 'score': {'python': 100, 'math': 92}}
stu3的值为： {'name': '李明', 'age': 19, 'score': {'python': 100, 'math': 92}}

1
2
3
4
5
6
7
8
9

2.深拷贝

深拷贝用deepcopy
深拷贝原有的字典对象和拷贝后的字典对象是完全独立的，他们具有不同的内存空间，而且他们所有对应的元素，即使是可变的元素也对应不同的内存空间。从

代码如下（示例）：

"""
深拷贝deepcopy
"""
import copy

stu1={'name':'李晓明','age':19,'score':{'python':95,'math':92}}
stu2=copy.deepcopy(stu1)
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)
1
2
3
4
5
6
7
8
9
10
11
12

// 运行结果
stu1贺stu2的内存地址分别为： 2510197119040 2510197119424
stu1['score']的stu2['score'的内存地址分别为：地址不同
stu1的值为： {'name': '李晓明', 'age': 19, 'score': {'python': 100, 'math': 92}}
stu2的值为： {'name': '李晓明', 'age': 19, 'score': {'python': 95, 'math': 92}}

1
2
3
4
5
6

3.哈希

帮助理解可变类型和不可变类型：
https://www.cnblogs.com/blackmatrix/p/5614086.html
#一个对象能被称为可哈希的 ，它必须有个哈希值，
# 这个值在整个生命周期都不会变化，而且必须可以进行相等比较。
# 对于 Python 的内建类型来说，不可变类型都是 可哈希的，
# 如字符串，可变类型：列表、字典、集合，他们在改变值的同时却没有改变id,
# 无法由地址定位值的唯一性,因而无法哈希。
1
2
3
4
5
6
7

4.迭代和迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。
通过for循环可以用于遍历序列、集合、字典等可迭代对象，也可以使用迭代器来进行集合的遍历。
# 迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
迭代器只能往前不会后退。迭代器有两个基本的方法：iter()和next()。
字符串，列表或元组是迭代对象但不是迭代器。
1
2
3
4
5
6

可以用isinstance判断一个对象是不是迭代对象

from collections.abc import Iterable,Iterator
numList=[1,2,3]
print(isinstance(numList,Iterable))   #属于可迭代对象#True
print(isinstance(numList,Iterator))   #不是迭代器#False
1
2
3
4

创建一个迭代器对象

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
1
2

遍历的两种方法

# 迭代器对象可以使用常规for语句进行遍历：
for x in it:
    print (x, end=" ")
# 也可以使用 next() 函数：
#print(next(it))
# 对于迭代器，可以使用next函数不断获取下一个元素，
# 当所有元素获取完毕再次调用next函数时，会引发StopInteration异常。
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()
1
2
3
4
5
6
7
8
9
10
11
12

4.生成器

#回顾列表生成表达式
ls=[x*x for x in range(10) if x%2!=0]#创建0-9中所有技奇数的平方组成的列表对象
print(ls)#[1, 9, 25, 49, 81]
"""
列表生成表达式也支持多层循环的形式
"""
snolist=['121','122','123']
namelist=['李明','马红','张刚']
ls=['学号:'+sno+',姓名：'+name for sno in snolist for name in namelist]
for stu in ls:
    print(stu)
# 学号:121,姓名：李明
# 学号:121,姓名：马红
# 学号:121,姓名：张刚
# 学号:122,姓名：李明
# 学号:122,姓名：马红
# 学号:122,姓名：张刚
# 学号:123,姓名：李明
# 学号:123,姓名：马红
# 学号:123,姓名：张刚
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

三、组合数据类型

组合数据类型：序列，集合，映射
序列：字符串，元组（tuple），列表（list）
集合：集合（set）
映射：字典（map）

在Python中序列类型支持双向索引
1

可变类型和不可变类型：

# 在Python中对象类型分为两种：可变类型与不可变类型。
# 可变类型：可以对该类型对象中保存的元素值做修改。列表、字典集合都属于可变类型。
# 不可变类型：该类型的对象所保存的元素值不允许修改，只能通过给对象整体赋值来修改对象所保存的值，
# 本质上就是创建了一个新的不可变类型的对象，而不是修改了原对象的值。数字、字符串和元组都属于不可变类型。


1
2
3
4
5
6

#不可变类型

n1,n2=1,1
print(id(n1),id(n2))#2851353094448 2851353094448相同
n1=2
print(id(n1),id(n2))#2851353094480 2851353094448#做出修改，会创建新的对象，所以id不相同

#可变类型

s=set([23,37,12,28,37])
print(id(s))#1730217031264
s.add('python')
print(id(s))#1730217031264


list1,list2=[1,2,3],[1,2,3]
print(id(list1),id(list2))#2851361235840 2851358451712不同
list1[1]=9
print(id(list1),id(list2))#2851361235840 2851358451712对list1作出修改之后不会创建新的对象，id还是相同的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.序列类型概述

序列特点：

# Python中的序列，包括字符串(String)、列表(List)、元组(Tuple)。
# 序列指的是一块可存放多个值的连续内存空间，这些值具有一定的先后顺序。
# 序列是一维元素向量，元素类型可以不同，元素间由索引引导，通过索引访问序列的特定元素。
1
2
3

序列运算符：

2.列表类型

"""
列表拼接,拼接运算符+
"""
list1=[1,2,3]
list2=['python','c++']
list3=list1+list2
print(f'list1和list2的值分别为')
print('list1的值为：',list1)#list1的值为： [1, 2, 3]
print('list2的值为：',list2)#list2的值为： ['python', 'c++']
print('list3的值为：',list3)#list3的值为： [1, 2, 3, 'python', 'c++']
1
2
3
4
5
6
7
8
9
10

import copy
"""
1.复制列表元素
"""
ls1=[1,2,3]
ls2=ls1
print('The value of ls1 and ls2 are:',ls1,ls2)
print('The id of ls1 and ls2 are:',id(ls1),id(ls2))#id is same
#ls1=ls2实际上使得ls1和ls2这两个变量对应同一个列表对象
#所以修改ls1和ls2中任意一个列表中的元素值，另外一个列表也会改变
ls1[1]=5
print('The value of ls1 and ls2 are:',ls1,ls2)
print('The id of ls1 and ls2 are:',id(ls1),id(ls2))#id is same

print("***********************元素截取**************************")
"""
2.如何根据一个列表复制出一个新的列表对象呢？
    我们可以用元素截取的方法
"""
ls1=[1,2,3]
ls2=ls1[:]
print('The value of ls1 and ls2 are:',ls1,ls2)
print('The id of ls1 and ls2 are:',id(ls1),id(ls2))#id is not same
"""
2.1但是如果列表中的元素包含列表，那这个元素（列表）是指向同一个对象还是会创建一个新的对象呢？
    答：指向同一个对象
"""
print("***********************元素截取含有列表类型元素的列表**************************")
ls1=[1,[2,3]]
ls2=ls1[:]
print('The value of ls1 and ls2 are:',ls1,ls2)#The value of ls1 and ls2 are: [1, [2, 3]] [1, [2, 3]]
print('The id of ls1 and ls2 are:',id(ls1),id(ls2))#The id of ls1 and ls2 are: 3173096637248 3173096701120
print('The id of ls1[1] and ls2[1] are:',id(ls1[1]),id(ls2[1]))#The id of ls1[1] and ls2[1] are: 3173096615040 3173096615040
"""
2.2怎么解决2.1的问题呢？
    答：可以使用python中copy模块中的deepcopy函数
"""
print("***********************深拷贝deepcopy**************************")
ls1=[1,[2,3]]
ls2=copy.deepcopy(ls1)
print('The value of ls1 and ls2 are:',ls1,ls2)
print('The id of ls1 and ls2 are:',id(ls1),id(ls2))
#The id of ls1 and ls2 are: 3173096701056 3173096637248
print('The id of ls1[1] and ls2[1] are:',id(ls1[1]),id(ls2[1]))#not same
#The id of ls1[1] and ls2[1] are: 3173096701760 3173096701504
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

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

"""
查找列表元素index
"""
ls=[1,3,5,3]
print('ls值为3的元素第一次出现的位置为：',ls.index(3))
#ls值为3的元素第一次出现的位置为： 1
"""
插入列表元素insert and append
"""
print("********************插入列表元素***********************")
ls1=[1,2,3]
ls1.insert(0,'python')#在ls1列表下表为0的位置插入新的元素python
print(ls1)#['python', 1, 2, 3]
ls1.insert(2,True)#在列表ls1下标为2的位置插入新元素True
print(ls1)#['python', 1, True, 2, 3]
ls1.append([5,10])#在ls1列表的最后添加元素[5,10]
print(ls1)#['python', 1, True, 2, 3, [5, 10]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

"""
1.重新初始化
"""
ls1=[0,1,2,3,4,5]#[0, 1, 2, 3, 4, 5]
print(ls1)
ls1=[]#[]
print(ls1)
"""
2.使用clear（）方法
"""
ls2=[0,1,2,3,4,5]
print(ls2)#[0, 1, 2, 3, 4, 5]
ls2.clear()
print(ls2)#[]
"""
3.使用*=0（鲜为人知）
"""
ls3=[0,1,2,3,4,5]
print(ls3)#[0, 1, 2, 3, 4, 5]
ls3*=0
print(ls3)#[]
"""
4.使用del a[:]
    不指出删除的范围，则删除所有元素
"""
ls4=[0,1,2,3,4,5]
print(ls4)#[0, 1, 2, 3, 4, 5]
del ls4[:]
print(ls4)#[]


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

"""
列表中元素排序，默认是false升序
    sort（key=None，reverse=False）
"""
class Student:
    def __init__(self,sno,name):
        self.sno=sno
        self.name=name
        """
        内置方法__str__
        该方法在调用str函数对类对象进行处理时或
        调用python内置函数format()和print()时自动执行
        __str__方法返回值必须是字符串
        """
    def __str__(self):
        return '学号'+self.sno+',姓名：'+self.name
ls1=[23,56,12,37,28]
print(f'ls1：',ls1)#ls1： [23, 56, 12, 37, 28]
ls1.sort()#将ls1中的元素升序排列
print(f'ls1升序排列的结果：',ls1)#ls1升序排列的结果： [12, 23, 28, 37, 56]
ls1.sort(reverse=True)#将ls1中的元素降序排列
print(f'ls1降序排列的结果：',ls1)#ls1降序排列的结果： [56, 37, 28, 23, 12]
ls2=[Student('192501','小明'),Student('192505','小李'),Student('192500','张三')]
ls2.sort(key=lambda stu:stu.sno)#按学号升序排列

print('ls2升序排列的结果：')
for i in ls2:
    print(i)
# 学号192500,姓名：张三
# 学号192501,姓名：小明
# 学号192505,姓名：小李
ls2.sort(key=lambda stu:stu.sno,reverse=True)
print('ls2降序排列的结果：')
for i in ls2:
    print(i)
# 学号192505,姓名：小李
# 学号192501,姓名：小明
# 学号192500,姓名：张三

#Sorted和sort使用方法不一样，而且sorted不会改变原来的列表，但是sort会修改原来的列表
list=[4,7,2,6,2]
print(list)#[4, 7, 2, 6, 2]
l1=sorted(list)
print(l1)#[2, 2, 4, 6, 7]
l2=sorted(list,reverse=True)
print(l2)#[7, 6, 4, 2, 2]
print(list)#[4, 7, 2, 6, 2]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#zip() 函数用于将任意多个可迭代对象作为参数，
#将对象中对应的元素打包成元组，然后返回由这些元组组成的可迭代的zip对象，
#可以使用 list() 转换来输出列表。
alist=[1,2,3]
blist=[4,5,6]
clist=[6,7,8,9,10]
zipped = zip(alist,blist)     # 返回一个对象
print(zipped)#<zip object at 0x00000119A491EEC0>
zipped=list(zipped)# list() 转换为列表，结果为：[(1, 4), (2, 5), (3, 6)]
print(zipped)      
print(list(zip(alist,clist)))# 元素个数与最短的列表一致  [(1, 6), (2, 7), (3, 8)]
a1, a2 = zip(*zipped)     # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式 a1,a2分别为元组(1,2,3)(4,5,6)
print(list(a1))   #输出结果为：[1, 2, 3]
print(list(a2))  #输出结果为：[4, 5, 6]


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.元组类型

"""
元组是一种不可变类型，元组中的元素不能修改
因此元组不支持sort等需要修改元素值的方法
"""
"""
创建元组：两种方法
"""
t1=(1,'one','一')
print('the valude of t1:',t1)
t2=tuple([1,'one','一'])
print('the valude of t2:',t2)

1
2
3
4
5
6
7
8
9
10
11
12

"""
创建具有单个元素的元组需要在该元素之后添加一个逗号
否则小括号会被系统默认为是括号运算符
"""
t1=(5)
t2=(5,)
str='python'
print(t1)#5
print(t2)#(5,)
print(tuple(str))#('p', 'y', 't', 'h', 'o', 'n')
1
2
3
4
5
6
7
8
9
10

"""
拼接元组 +
"""
t1=(1,2,3)
t2=('python','C++')
t3=t1+t2
print('the value of t1 and t2 are:',t1,t2)#(1, 2, 3) ('python', 'C++')
print('the value of t3 is:',t3)#(1, 2, 3, 'python', 'C++')
1
2
3
4
5
6
7
8

t=(1,5,9,3,4,7,6)
print('元组中的最大值是：',max(t))
print('元组中的最小值是：',min(t))
1
2
3

4.集合类型

创建：

"""
有两种方式创建集合{。。。}或者用set函数创建集合
    如果要创建空集合只能用set函数
集合中的元素具有唯一性，集合会自动过滤掉重复的元素
"""
s=set([23,37,12,28,37])
print('the value of s :',s)#the value of s : {28, 12, 37, 23}

1
2
3
4
5
6
7
8

插入：

"""
插入集合元素有两种方法：
    s.add（x）方法，x必须是可哈希的对象，可哈希（字符串，元素，数字等）就是不可变呗
    s.update（x）方法，把x拆分成多个元素之后插入到集合，x必须是一个可迭代对象
"""
s1=set([1,2])
s2=set([1,2])
s1.add('python')
s2.update('python')
print('the value of s1:',s1)#the value of s1: {1, 2, 'python'}
print('the value of s2',s2)#the value of s2 {1, 2, 'p', 'y', 'h', 'o', 'n', 't'}
#s1.add([1,2])#TypeError: unhashable type: 'list'
#s2.update(3)#TypeError: 'int' object is not iterable
1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
交集：s1.intersection(s2)
并集：s1.union(s2)
差集：s1.difference(s2)
对称差集：两个集合独有的元素 s1.symmetric_difference(s2)
"""
s1=set([1,2,3])
s2=set([1,3,4])
s3=s1.intersection(s2)
print(s3)#{1, 3}
s4=s1.union(s2)
s5=s1.difference(s2)
s6=s1.symmetric_difference(s2)
print('s1和s2的值分别为:',s1,s2)#{1, 2, 3} {1, 3, 4}
print('s1 和s2 的交集为：',s3)#{1, 3}
print('s1 和s2 的并集为：',s4)# {1, 2, 3, 4}
print('s1 和s2 的差集为：',s5)#{2}
print('s1 和s2 的对称差集为：',s6)#{2, 4}
"""
issubset方法用来判断一个集合是否是另一个集合的子集
issuperset方法用来判断是一个集合是否为另一个集合的父集
"""
print('s3是s1的子集',s3.issubset(s1))#True
print('s1是s4的父集',s1.issuperset(s4))#False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.字典类型

"""
创建有两种方法
    {...}
    dict（）
    创建空字典
    a={}
    b=dict()
"""
a={'one':1,'two':2,'three':3}#{'one': 1, 'two': 2, 'three': 3}
b=dict(one=1,two=2,three=3)#{'one': 1, 'two': 2, 'three': 3}
c=dict(zip(['one','two','three'],[1,2,3]))
#zip将不同对象中的元素分别打包成元组,生成一个zip对象，然后通过dict()转换成字典
print(c)#{'one': 1, 'two': 2, 'three': 3}
d=dict([('one',1),('two',2),('three',3)])#{'one': 1, 'two': 2, 'three': 3}
e=dict({'one':1,'two':2,'three':3})#{'one': 1, 'two': 2, 'three': 3}
"""
除了上述初始化字典的方法以外，还有使用fromkeys方法进行字典初始化
d.fromkeys(seq[,value])
    d是一个已经创建的字典对象
    seq是一个包含字典所有键名的序列
    value是一个可选的参数，其值指定了各个元素的初始值
"""
d1={}.fromkeys(['sno','name','major'])
d2=dict().fromkeys(['sno','name','major'],'Unknow')
print('d1的值为：',d1)#{'sno': None, 'name': None, 'major': None}
print('d2的值为：',d2)#{'sno': 'Unknow', 'name': 'Unknow', 'major': 'Unknow'}
"""
如果使用的字典对象已经有其他元素，则调用fromkeys方法后所有的元素都会被清除
"""
print("**********如果使用的字典对象已经有其他元素，则调用fromkeys方法后所有的元素都会被清除************")
d3=dict(age=18)
print('d3的值为：',d3)#{'age': 18}
d4=d3.fromkeys(['sno','name','major'])
print('d4的值为：',d4)#{'sno': None, 'name': None, 'major': None}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

"""
给指定的键的元素赋值时，如果该键在字典中已经存在，则将该键对应的元素值做修改
如果该键不存在，则会在字典中插入一个新的元素
    另外也可使用update方法一次修改或插入多个元素
    d.update（d2）
"""
stu=dict(sno='123456')
print(stu)#{'sno': '123456'}
stu['sno']='654321'
print(stu)#{'sno': '654321'}
stu['name']='李晓明'
print(stu)#{'sno': '654321', 'name': '李晓明'}
stu.update({'name':'马红','age':19})
print(stu)#{'sno': '654321', 'name': '马红', 'age': 19}
stu.update(name='张刚',major='计算机')
print(stu)#{'sno': '654321', 'name': '张刚', 'age': 19, 'major': '计算机'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
删除字典中的元素有两种方法
    del方法
    字典中的pop方法
"""
d=dict(sno='123456',name='李晓明',age=18)
print(d)#{'sno': '123456', 'name': '李晓明', 'age': 18}
del d['age']
print(d)#{'sno': '123456', 'name': '李晓明'}

name=d.pop('name')#使用pop删除键为name的元素，并返回键值赋值给name
print('name的值：',name)
print(d)#{'sno': '123456'}
major=d.pop('major','Not found')
print('major的值为：',major)#major的值为： Not found
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

"""
计算字典中元素个数用len
"""
d={'sno':'156789','name':'李小敏'}
print('字典d的长度为：',len(d))#字典d的长度为： 2
"""
清除字典中所有元素clear
"""
d1={'sno':'156789','name':'李小敏'}
print(d1)#{'sno': '156789', 'name': '李小敏'}
d1.clear()
print(d1)#{}
print(len(d1))#0
1
2
3
4
5
6
7
8
9
10
11
12
13

"""
判断字典中是否存在键有两种方法
    d.get(key,default=None)
        从字典中获取键为key的元素并返回其值，如果字典中不存在key值就返回default的参数
    成员运算符 in
"""
d={'sno':'156789','name':'李小敏'}
if d.get('sno')!=None:
    # print('字典中存在键为sno的元素')
    print(d.get('sno'))#156789
else:
    print('字典中不存在键为sno的元素')
if 'name' in d:
    print('字典中存在键为name的元素')#字典中存在键为name的元素
else:
    print('字典中不存在键为name的元素')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
拼接两个字典有两种方法
    dMerge=dic(d1,**d2)

    dMerge=d1.copy()
    dMerge.update(d2)
"""
d1=dict(sno='156464',name='李晓明')
d2={'age':19}
dMerge1=dict(d1,**d2)
print('dMerge1的值为：',dMerge1)
#{'sno': '156464', 'name': '李晓明', 'age': 19}
dMerge2=d1.copy()
dMerge2.update(d2)
print('dMerge的值为：',dMerge2)
#{'sno': '156464', 'name': '李晓明', 'age': 19}
print(d1)#{'sno': '156464', 'name': '李晓明'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

"""
获取键的集合
    d.keys()
"""
d=dict(sno='156464',name='李晓明')
print('d中键为：',d.keys())#返回的是一个dict_keys对象 dict_keys(['sno', 'name'])
# print(list(d.keys()))
print('d中的值为：',d.values())#返回的是一个dict_values对象  dict_values(['156464', '李晓明'])

"""
使用字典中的items方法可以返回一个可按（键，值）方法遍历的对象
"""
print(d.items())#dict_items([('sno', '156464'), ('name', '李晓明')])
for key,value in d.items():
    print(key,value)
# sno 156464
# name 李晓明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17