元组，字典，浅复制

元组(tuple)

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组的创建

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ("a", "b", "c", "d")
tup4 = 1,2,3,4

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = 50,
tup2 = (50,)

元组索引

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组
元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

元组解包

元组解包指把元组每一个元素都赋值给一个变量

tup1 = (1,2,3,4)
a,b,c,d = tup1
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)

结果：

a= 1
b= 2
c= 3
d= 4

必须让变量数量对应元素数量，否则用*来让一个变量拥对应多个元素，形式为列表形式

tup1 = (1,2,3,4)
a,b,*c = tup1
print('a=',a)
print('b=',b)
print('c=',c)

tup1 = (1,2,3,4)
a,*b,c = tup1
print('a=',a)
print('b=',b)
print('c=',c)

tup1 = (1,2,3,4)
*a,b,c = tup1
print('a=',a)
print('b=',b)
print('c=',c)

以上实例输出结果：

a= 1
b= 2
c= [3, 4]

a= 1
b= [2, 3]
c= 4

a= [1, 2]
b= 3
c= 4

字典

字典的数据结构为映射(mapping)
字典的作用和列表一样，用来存储数据，但是列表的查询性能很差，而字典相反

字典外层是⼤括号{}，⽤等号赋值
列表中的元素是⾃成⼀体的，⽽字典的元素是由键值对构成的，⽤英⽂冒号连接。有多少个键值对就有多少个元素。

如’⼩郭’: 90，其中我们把’⼩郭’叫键（key），90叫值(value)
每个键值对我们可以称为一项(item)

键值对之间⽤逗号隔开

所存储的两种数据若存在⼀⼀对应的情况，⽤字典储存会更加⽅便。唯⼀的键和对应的值 形成的整体，我们就叫做【键值对】。键具备唯⼀性，⽽值可以重复。 字典中数据是随机排列的（无序的，所以无法像列表或者元组一样通过索引获得元素）

字典的创建

• 直接用变量加花括号创建
  如下：

dct = {'name':'小王','age':18,'job':'programmer',
       'home add':'天津'}
print(dct)

输出结果：

{'name': '小王', 'age': 18, 'job': 'programmer', 'home add': '天津'}

• 通过dict函数创建
  如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print(dct)
dct1 = dict([('name','age'),('小王',18)])   #双值子序列也能转换为字典
print(dct1)

输出结果：

{'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
{'name': 'age', '小王': 18}

获取字典元素

字典是无序的，所以通过索引无法获取字典中的值，但是可以通过字典中键值对的键来获取
如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print(dct['name'])

以上实例输出结果：

小王

还可以通过get方法获取，get(key,default)
get方法是通过键来获取字典当中的值，若是没有，则返回None，或者通过设置第二个参数（默认值）来返回默认值内容
如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print(dct.get('name'))
print(dct.get('小张'))
print(dct.get('小张'),'抱歉，字典中没有这个键')

以上实例输出结果：

小王
None
None 抱歉，字典中没有这个键

修改字典

直接修改或添加

字典中的键不能重复
可以直接用获取key改变value
如果没有这个键，则可以增加字典中的键值对
如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
dct['name'] = '小张'
dct['sex'] = '男'
print('修改后',dct)

结果：

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {'name': '小张', 'age': 18, 'job': '程序员', 'hone_add': '天津', 'sex': '男'}

通过setdefault(key,default)方法添加key:value

如果这个key已经存在，则返回key值，对字典没有任何影响
如果key不存在，向字典添加这个key并设置value，返回value
如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
dct.setdefault('name','小张')
dct.setdefault('sex','男')
print('修改后',dct)

结果：

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津', 'sex': '男'}

update方法添加字典

update方法将其他字典添加到当前字典中
如下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
dct1 = dict(sex='男')
print('修改前',dct)
dct.update(dct1)
print('修改后',dct)

结果：

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津', 'sex': '男'}

删除

del

删除字典中的key:value

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
del dct['name']
print('修改后',dct)

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {'age': 18, 'job': '程序员', 'hone_add': '天津'}

popitem

随机删除字典中的一个键值对，一般删除最后一个
删除后会将删除的值作为返回值返回(元组形式)

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
dct.popitem()
print('修改后',dct)

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {'name': '小王', 'age': 18, 'job': '程序员'}

pop

通过key来删除key:value,删除的值作为返回值返回

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
fan = dct.pop('name')
print('返回值：',fan)
print('修改后',dct)

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
返回值： 小王
修改后 {'age': 18, 'job': '程序员', 'hone_add': '天津'}

clear()

清空字典

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('修改前',dct)
dct.clear()
print('修改后',dct)

修改前 {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'}
修改后 {}

遍历字典

keys()

keys()返回的是一个序列，保存的是字典中所有的键

dct = {'name':'小王','age':'18','job':'程序员'}
for i in dct.keys():
    print(i)

name
age
job

values()

values()返回的是一个序列，保存的是字典中所有的值

dct = {'name':'小王','age':'18','job':'程序员'}
for i in dct.values():
    print(i)

小王
18
程序员

items()

items()返回的是一个序列，返回字典的所有项，包括双值子序列

dct = {'name':'小王','age':'18','job':'程序员'}
for i,j in dct.items():
    print(i,':',j)

name : 小王
age : 18
job : 程序员

浅复制

浅复制复制以后与原对象之间是独立的，修改一个并不会影响另一个
普通复制：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
#普通复制
dct1 = dct
dct['name'] = '小张'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

dct: {'name': '小张', 'age': 18, 'job': '程序员', 'hone_add': '天津'} 1402806635136
dct1: {'name': '小张', 'age': 18, 'job': '程序员', 'hone_add': '天津'} 1402806635136

普通复制两个id相同，一方修改另一个也会改变
浅复制：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
#浅复制
dct1 = dct.copy()
dct['name'] = '小张'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

dct: {'name': '小张', 'age': 18, 'job': '程序员', 'hone_add': '天津'} 2238110323136
dct1: {'name': '小王', 'age': 18, 'job': '程序员', 'hone_add': '天津'} 2237827343488

浅复制双方id不同，一方修改另一方不会改变
但是，如果嵌套字典，则会只复制第一层字典内容
如：

dct = {'n':{'name':'小王','age':'18'},'job':'程序员'}
#浅复制
dct1 = dct.copy()
dct['n']['name'] = '小张'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

字典内的嵌套字典会随一方改变而改变

dct: {'n': {'name': '小张', 'age': '18'}, 'job': '程序员'} 1191683056832
dct1: {'n': {'name': '小张', 'age': '18'}, 'job': '程序员'} 1191683057152

通用方法

• len 获取字典中键值对个数
• in 判断字典中是否有这个键
• in not 判断字典中是否没有这个键

如以下：

dct = dict(name='小王',age=18,job='程序员',hone_add='天津')
print('字典中键值对的个数是',len(dct))
print('home_add' in dct)
print('home_add'  not in dct)

以上实例输出结果

字典中键值对的个数是 4
False
True