Python Learning(五)-字典

一 字典简介

-字典属于一种新的数据结构,称为映射(mapping)
-字典的作用和列表相似,都是用来存储对象的容器
-列表存储数据的性能很好,但是查询的性能很差
-在字典中每一个元素都有一个唯一的名字,通过这个唯一的名字可以快速查到指定的元素
-在查询元素时,字典的效率是非常快的,每个对象都会有一个唯一的名字,这个唯一的名字
我们称为key,这个对象我们成为value,所以字典就是键值对key-value结构
-每个字典中都可以有多个键值对,每一个键值对我们称为一项(item)

语法:使用{}来创建一个字典
d={}
print(d,type(d))
# ({}, <type 'dict'>)

d={'name':'tom','age':18}
print(d,type(d))
# ({'age': 18, 'name': 'tom'}, <type 'dict'>)

字典的键可以是任意的不可变对象,但字典的键不能重复,如果重复后面的会替换前面的
字典的值可以是任意对象

d={'name':'tom',
	'age':18,
	'sex':True}
print(d['name'])
# tom

二 字典的使用

创建字典
语法一: {'key':value}
语法二: dict()函数创建

dict(name=value)
d=dict(name='tom',age=18) 每一个参数都是一个item
注:这种方式创建的字典,键都是str
print(d)
# {'age': 18, 'name': 'tom'}

语法三:将包含有双值子序列的序列转换为字典
双值序列:序列中只有俩个值 [1,2] ('a',3) 'ab'
子序列:如果序列中的元素也是序列,那么称这个元素为子序列
[(1,2),(3,5)]

d=dict([('name','tom'),('age',18)])
print(d)
# {'age': 18, 'name': 'tom'}

len()获取字典中键值对的个数
d=dict([('name','tom'),('age',18)])
print(len(d))
# 2

in 检查字典中是否包含指定的键
not in  检查字典中是否不包含指定的键

d=dict([('name','tom'),('age',18)])
print('name' in d)
# True

获取字典中的值,根据键来获取值
语法:d[key]

d=dict([('name','tom'),('age',18)])
print(d['name'])
# tom

d=dict([('name','tom'),('age',18)])
n='name'
print(d[n])
# tom

通过[]获取值的时候,如果键不存在,会抛出异常 keyerror

get(key[,default])该方法会根据字典中的键来获取字典中的值

d=dict([('name','tom'),('age',18)])
print(d.get('error'))
# None
它和上面一种方法的区别是,上面没有就报错,这个没有就返回None

d=dict([('name','tom'),('age',18)])
print(d.get('error','Jane'))
# Jane

甚至还可以加默认值,没有就返回默认值

修改字典 (有就修改没有就加上)
	d[key]=value

d=dict([('name','tom'),('age',18)])
d['name']='jiaoyue'
d['address']='suruima'
print(d)
# {'age': 18, 'name': 'jiaoyue', 'address': 'suruima'}

setdefault(key[,default]) 如果这个key存在则返回值,不存在则添加然后返回默认添加的值
d=dict([('name','tom'),('age',18)])
d.setdefault('name','tom2')
print(d)
# {'age': 18, 'name': 'tom'}

update()
将其它字典中的key-value添加到当前字典中 如果有重复的key则后面的会替换当前的
d=dict([('a','1'),('b',2)])
d2={'a':'5','c':3,'d':4}
d.update(d2)
print(d,d2)
# ({'a': '5', 'c': 3, 'b': 2, 'd': 4}, {'a': '5', 'c': 3, 'd': 4})

删除,可以使用del删除字典中的key-value key不存在会报错
d=dict([('a','1'),('b',2)])
del d['a']
print(d)
# {'b': 2}

popitem()
随机删除字典中的一个键值对,一般都会删除最后一个键值对
	d={'a':1,'b':3}
	print(d)
	result=d.popitem() 返回值是一个元组,第一个元素是删除的key,第二个元素是删除的value
	print(result,d)
	# 	{'a': 1, 'b': 3}
		(('a', 1), {'b': 3})

	d.popitem()可以掉多次,当字典为空时再去删除则会报错

pop(key[,default])
根据key删除字典中的项
d={'a':1,'b':3}
print(d)
result=d.pop('b')  返回值是删除的元素value 删除不存在的key有异常
print(d,result)
#	{'a': 1, 'b': 3}
	({'a': 1}, 3)

如果指定了默认值,再删除不存在的key,不会报错直接返回默认值
d={'a':1,'b':3}
print(d)
result=d.pop('c','default')
print(d,result)
# 	{'a': 1, 'b': 3}
	({'a': 1, 'b': 3}, 'default')

clear()
d={'a':1,'b':3}
print(d)
d.clear()
print(d)
# 	{'a': 1, 'b': 3}
	{}

copy()
该方法用于对字典进行浅复制(只复制值不复制地址) 修改一个不会影响另一个
d={'a':1,'b':3}
d2=d.copy()
print(d,d2,id(d),id(d2))
# ({'a': 1, 'b': 3}, {'a': 1, 'b': 3}, 140054334112384, 140054334114904)

注:浅复制会简单复制对象内部的值,如果值也是一个可变对象,这个可变对象不会被复制
d={'a':{'c':4,'d':5},'b':3}
d2=d.copy()
d2['a']['c']=6
print(d,d2)
# ({'a': {'c': 6, 'd': 5}, 'b': 3}, {'a': {'c': 6, 'd': 5}, 'b': 3})

拓展:深度拷贝需要引入 copy 模块：
实例
import copy
a = {1: [1,2,3]}
c = copy.deepcopy(a)
a, c
print(a,c)
a[1].append(5)
print(a,c)

#	({1: [1, 2, 3]}, {1: [1, 2, 3]})
	({1: [1, 2, 3, 5]}, {1: [1, 2, 3]})

二 遍历字典

-keys() 获取所有的key
-values()  获取所有的value
-items()

d={'a':1,'b':2,'c':3}
print(d.keys())
# ['a', 'c', 'b']

for k in d.keys():
	print(k,d[k])
# 	('a', 1)
	('c', 3)
	('b', 2)

values
该方法会返回一个序列,序列中保存有字典所有的值 缺点是只能看见值没有key了
d={'a':1,'b':2,'c':4}
for v in d.values():
	print(v)
# 	1
	4
	2

items()
他会返回字典中所有的项
他返回的是一个序列,序列中包含有双值子序列
双值分别是,字典中的key和value

d={'a':1,'b':2,'c':4}
for k,v in d.items():
	print(k,v)
# 	('a', 1)
	('c', 4)
	('b', 2)