知识点

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下：

>>>dict1 = {'a':1,'b':2,'c':3}
>>>del dict1['a']
>>>dict1
{'b': 2, 'c': 3}
>>>del dict1
>>>dict1
Traceback (most recent call last):
File "", line 1, in 
dict1
NameError: name 'dict1' is not defined

字典key的特性

字典value可以是任何的python对象，既可以是标准的对象，也可以是用户定义的，但key不行。

两个重要的店需要记住：

1) 不允许同一个key出现两次。创建时如果同一个key被赋值两次，后一个value会被记住，如下：

>>>dict1 = {'a':1,'b':2,'c':3,'a':4}
>>>dict1['a']
4

2) key必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下：

>>>dict2 = {['a']:1,'b':2}
Traceback (most recent call last):
File "", line 1, in 
dict2 = {['a']:1,'b':2}
TypeError: unhashable type: 'list'
#改成元祖形式
>>>dict2 = {('a','c'):1,'b':2}
>>>dict2
{('a', 'c'): 1, 'b': 2}
>>>dict2['a','c']
1

字典的内置方法：

clear():清除字典内元素

示例：

>>>dict1
{'a': 4, 'b': 2, 'c': 3}
>>>dict1.clear()
>>>dict1
{}

copy():返回一个字典的浅拷贝

示例：

>>>a = {1:'one',2:'two',3:'three'}
>>>b = a.copy()
>>>b
{1: 'one', 2: 'two', 3: 'three'}

直接赋值和copy的区别

>>>dict1 = {'a':1,'b':2,'c':[1,2,3]}
>>>dict2 = dict1 #浅拷贝: 引用对象
>>>dict3 = dict1.copy() #浅拷贝：深拷贝父对象(一级目录)，子对象(二级目录)不拷贝，还是引用
#修改数据：
>>>dict1['a'] = '一'
>>>dict1['c'].remove(1)
#输出结果对比：
>>>dict1
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>dict2
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>dict3
{'a': 1, 'b': 2, 'c': [2, 3]}

示例中 dict2其实是dict1的引用(别名)，所以输出结果都是一致的。

dict3父对象进行了深拷贝，不会随dict1修改而修改，子对象是浅拷贝所以随dict1的修改而修改

fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

示例：

#语法
dict.fromkeys(seq[, value])
#参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列(seq)的值，默认为None
#示例：
>>>dict1 = {}
>>>dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>>dict1.fromkeys((1,2,3),'Number')
{1: 'Number', 2: 'Number', 3: 'Number'}
>>>dict1.fromkeys((1,2,3),('One','Two','Three'))
{1: ('One', 'Two', 'Three'), 2: ('One', 'Two', 'Three'), 3: ('One', 'Two', 'Three')}
>>>dict1.fromkeys((1,3),'数字')
{1: '数字', 3: '数字'}

get(key, default=None)返回指定键的值，如果key不存在，可以返回None，或者指定的value

示例：

>>>dict1
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>dict1.get('a')
'一'
>>>print(dict1.get('d'))
None
>>>print(dict1.get('d','四'))

四

key in dict如果键在字典dict里返回true，否则返回false

示例：

>>>dict1
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>'a' in dict1
True
>>>'d' in dict1
False

keys()以列表返回一个字典所有的键

示例

>>>dict1
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>dict1.keys()
dict_keys(['a', 'b', 'c'])

values()以列表返回字典中的所有值

示例：

>>>dict1.values()
dict_values(['一', 2, [2, 3]])

items()以列表返回可遍历的(键, 值) 元组数组

示例：

>>>dict1.items()
dict_items([('a', '一'), ('b', 2), ('c', [2, 3])])

setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

示例：

>>>a
{1: 'one', 2: 'two', 3: 'three'}
>>>a.setdefault(1)
'one'
>>>a.setdefault('小白')
>>>a
{1: 'one', 2: 'two', 3: 'three', '小白': None}
>>>a.setdefault(5,'five')
'five'
>>>a
{1: 'one', 2: 'two', 3: 'three', '小白': None, 5: 'five'}

update(dict2)把字典dict2的键/值对更新到dict1里

示例：

#参数
dict2 -- 添加到指定字典dict1里的字典。
>>>dict1
{'a': '一', 'b': 2, 'c': [2, 3]}
>>>dict2 ={'c':[1,2,3,4]}
>>>dict1.update(dict2)
>>>dict1
{'a': '一', 'b': 2, 'c': [1, 2, 3, 4]}
>>>dict3 = {'d':5678}
>>>dict1.update(dict3)
>>>dict1
{'a': '一', 'b': 2, 'c': [1, 2, 3, 4], 'd': 5678}

pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

示例：

>>> a = {1: 'one', 2: 'two', 3: 'three', 4: 'Four'}
>>> a.pop(2)
'two'
>>> a
{1: 'one', 3: 'three', 4: 'Four'}
>>> a.pop()
Traceback (most recent call last):
File "", line 1, in 
a.pop()
TypeError: pop expected at least 1 arguments, got 0
>>> a.pop(2)
Traceback (most recent call last):
File "", line 1, in 
a.pop(2)
KeyError: 2
>>> a.pop(5,'f')
'f'
>>> a
{1: 'one', 3: 'three', 4: 'Four'}
>>> a.pop(4,'f')
'Four'
>>> a
{1: 'one', 3: 'three'}

popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)。

示例：

>>> a
{1: 'one', 3: 'three', 4: 'Four'}
>>> a.popitem()
(4, 'Four')
>>> a
{1: 'one', 3: 'three'}
>>> a = {}
>>> a.popitem()
Traceback (most recent call last):
File "", line 1, in 
a.popitem()
KeyError: 'popitem(): dictionary is empty'

测试题

Python的字典是否支持一键(key)多值(value)？

不支持，对相同的键再次赋值会将上一次的值直接覆盖。

>>>dict1 = {1:'one', 1:'yi'}
>>>dict1[1]
'yi'

在字典中，如果试图为一个不存在的键(key)赋值会怎么样？

会自动创建对应的键(key)并添加相应的值(value)进去

成员资格操作符(in和not in)可以检查一个元素是否存在序列中，当然也可以用来检查一个键(key)是否存在字典中，那么请问哪种的检查效率更高些？为什么

在字典中检查键(key)是否存在比在序列中检查是否存在更高效。

因为字典的原理是使用哈希算法存储，一步到位，不需要使用查找算法进行匹配，因此时间复杂度是0(1)，效率非常高。

Python对键(key)和值(value)有没有类型限制？

Python对键(key)的要求相对严格一些，要求它们必须是可哈希的对象，不能是可变类型(包括变量、列表、字典本身等。)

但是Python对值是没有任何限制的，它们可以是任意的Python对象。

请目测下边代码执行后，字典dict1的内容是什么？

>>>dict1.fromkeys((1, 2, 3), ('one', 'two', 'three'))
>>>dict1.fromkeys((1, 3), '数字')

执行完成后，字典dict1的内容是：{1:'数字',2:'数字'}

【注意】：fromkeys方法是直接创建一个新的字典，不要试图使用它来修改一个原有的字典，因为它会直接无情的把整个字典给覆盖掉。

如果你需要将字典dict1 = {1:'one',2:'two',3:'three'}拷贝到dict2，你应该这么做？

可以利用copy()方法

dict2 = dict1.copy()

用赋值的方法(dict2 = dict1)，这样子做在python中只是将对象的引用拷贝过去而已。

看以下区别：

>>>a = {1:'one', 2:'two', 3:'three'}
>>>b = a.copy()
>>>c = a
>>>c[4] = 'four'
>>>c
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>>a
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>>b
{1: 'one', 2: 'two', 3: 'three'}

动动手

尝试编写一个用户登录程序(这次尝试将功能封装成函数)，程序实现如图：


user_data = {}
def new_user():
prompt = '请输入用户名：'
while True:
name = input(prompt)
if name in user_data:
prompt = '此用户名已经被使用，请重新输入：'
continue
else:
break
passwd = input('请输入密码：')
user_data[name] = passwd
print('注册成功，赶紧试试登录吧^_^')
def old_user():
prompt = '请输入用户名：'
while True:
name = input(prompt)
if name not in user_data:
prompt = '您输入的用户名不存在，请重新输入：'
continue
else:
break
passwd = input('请输入密码：')
pwd = user_data.get(name)
if passwd == pwd:
print('欢迎进入XXOO系统，请点右上角的X结束程序！')
else:
print('密码错误！')
def showmenu():
prompt = '''
|--- 新建用户：N/n ---|
|--- 登录账号：E/e ---|
|--- 推出程序：Q/q ---|
|--- 请输入指令代码：'''
while True:
chosen = False
while not chosen:
choice = input(prompt)
if choice not in 'NnEeQq':
print('您输入的指令代码错误，请重新输入：')
else:
chosen = True
if choice == 'q' or choice == 'Q':
break
if choice == 'n' or choice == 'N':
new_user()
if choice == 'e' or choice == 'E':
old_user()
showmenu()