第25~26讲：字典：当索引不好用时

一 字典https://www.cnblogs.com/linupython/p/5880280.html

1 概念/特点

• 字典是另一种可变容器模型，且可存储任意类型对象。
• 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的，可哈希表示键值不可变。

总结：

• 字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

2 定义：字典可通过一对花括号来定义，元素内部通过冒号来连接key和对应的value，元素与元素之间通过逗号隔开，可进行自由嵌套。

3 语法格式：d = {key1 : value1, key2 : value2 }

4 字典的相关操作

• 创建
  • 通过定义字典的过程创建 。 dict = {'a':1,'b':2,'c':3}
  • dict()函数：也可以创建字典，工厂函数/类型函数
    • 注意：在使用dict函数之前先把原来定义的dict字典给删了，用'del dict'命令，否则系统会报错：TypeError: 'dict' object is not callable
    • 通过元组定义：dict1 = dict((('F',70),('i',105),('s',115),('h',104),('C',67)))
    • 通过关键字定义：dict1 = dict(a = 97,b=98)
• 访问：通过在方括号内引用其键名来访问字典的元素。 print(dict['c'])
• 修改：
  • 更改已有键值对的值：通过引用其键名来更改特定项的值。dict['a'] = 0
  • 增加新的键值对：通过引用要添加的'key'并给该'key'赋值来添加新的键值对： dict['d']=4
• 删除：字典长度：获取字典的长度（键值对的个数），通过len方法实现。 len(dict)
  • del语句：
    • 删除整个字典。del dict
    • 删除字典中的某个键值对。del dict['a']
  • clear()方法：清空字典所有键值对，不需要参数。dict.clear()
  • pop()方法：删除字典的某一键值对，其参数直接是键值key，不需要通过字典名称引用。dict.pop('c')
  • popitem() 方法：删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）。 dict.popitem()
• 字典长度：获取字典的长度（键值对的个数），通过len方法实现。len(dict)
• 字典排序：通过sorted方法对所有的key进行排序并以列表形式返回。 sorted(dict)
• 字典类型： 可用type函数查看字典中某一键值对的值的类型。type(dict['a'])
• 检查键值是否存在：要确定字典中是否存在指定的键，可使用 in 关键字。
  

  • >>> if 'a' in dict:
    ...     print("True")

• 遍历字典：可以使用 for 循环遍历字典，循环遍历字典时，返回值是字典的键，但也有返回值的方法。
  • 逐个打印字典中的所有键名：

    • >>> for x in dict:
      ...     print(x)

  • 逐个打印字典中的所有值：

    • >>> for x in dict:
      ...     print(dict[x])

  • 还可以使用 values() 函数返回字典的值

    • >>> for x in dict.values():
      ...     print(x)

  • 通过使用 items() 函数遍历键和值

    • >>> for x,y in dict.items():
       ...     print(x,y)

5  字典的常用内置方法

（1）fromkeys()方法

• 描述：Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
• 语法：dict.fromkeys(seq[, value])
• 参数：
  • seq -- 字典键值列表。
  • value -- 可选参数, 设置键序列（seq）的值，该参数只能有一个，并且所有键值列表对应的值都是它。
• 返回值：该方法返回一个新字典。
• 举例：

• >>> 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: '数字'}

（2）keys()方法

• 描述：Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键。
• 语法：dict.keys()
• 参数：无参数
• 返回值：返回一个字典所有的键。
• 举例：

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

（3）values()方法

• 描述：Python 字典(Dictionary) values() 函数以列表返回字典中的所有值。
• 语法：dict.values()
• 参数：无参数
• 返回值：返回字典中的所有值。
• 举例：

• >>> dict1.values()
  dict_values([1, 2, 3])

（4）items()方法

• 描述：Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
• 语法：dict.items()
• 参数：无参数
• 返回值：返回可遍历的(键, 值) 元组数组。
• 举例：

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

（5）get()方法

• 描述：Python 字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。
• 语法：dict.get(key, default=None)
• 参数：
  • key -- 字典中要查找的键。
  • default -- 如果指定键的值不存在时，返回该默认值。
• 返回值：返回指定键的值，如果值不在字典中返回默认值None。
• 举例：>>> dict1.get('a')

（6）clear()方法：

• 描述：Python 字典(Dictionary) clear() 函数用于删除字典内所有元素。
• 语法：dict.clear()
• 参数：无参数
• 返回值：该函数没有任何返回值。
• 举例：

• >>> dict1.clear()
  >>> dict1
  {}

（7）copy()方法

• 描述：Python 字典(Dictionary) copy() 函数返回一个字典的浅复制。
  • 浅复制和赋值是不一样的，由以下例子可看出：dict3和dict2的id是不一样的。

  • >>> dict1 = {'a':1,'b':2,'c':3}
    >>> dict2 = dict1
    >>> dict3 = dict1.copy()
    >>> id(dict1)
    216304025856
    >>> id(dict2)
    216304025856
    >>> id(dict3)
    216275514752

  • 关于浅复制和深复制的内容，见网页：https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
• 语法：dict.copy()
• 参数：无参数
• 返回值：返回一个字典的浅复制。
• 举例：

• >>> dict1.clear()
  >>> dict1
  {}
  >>> dict2
  {}
  >>> dict3
  {'a': 1, 'b': 2, 'c': 3}

（8）pop()方法

• 描述：Python 字典 pop() 方法删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。
• 语法：dict.pop(key[,default])
• 参数：
  • key: 要删除的键值
  • default: 如果没有 key，返回 default 值
• 返回值：返回被删除的值。
• 举例：

• >>> dict3
  {'a': 1, 'b': 2, 'c': 3}
  >>> dict3.pop('c')
  3
  >>> dict3
  {'a': 1, 'b': 2}

（9）popitem()方法

• 描述：Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
• 语法：dict.popitem()
• 参数：无参数
• 返回值：返回一个键值对(key,value)形式。

• >>> dict3
  {'a': 1, 'b': 2}
  >>> dict3.popitem()
  ('b', 2)
  >>> dict3
  {'a': 1}

（10）setdefault()方法

• 描述：Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值/设置的值。
• 语法：dict.setdefault(key, default=None)
• 参数：
  • key -- 查找的键值。
  • default -- 键不存在时，设置的默认键值。
• 返回值：如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值
• 举例：

• >>> dict3 = {'a':1}
  >>> print(dict3.setdefault('b'))
  None
  >>> dict3
  {'a': 1, 'b': None}
  >>> print(dict3.setdefault('a',3))
  1
  >>> print(dict3.setdefault('c',3))
  3

（11）update()方法

• 描述：Python 字典(Dictionary) update() 函数把字典dict2的键/值对更新到dict1里。
• 语法：dict1.update(dict2)
• 参数：dict2 -- 添加到指定字典dict1里的字典。
• 返回值：该方法没有任何返回值。
• 举例：

• >>> dict3
  {'a': 1, 'b': None, 'c': 3}
  >>> dict1 = {'d':4,'e':5}
  >>> dict3.update(dict1)
  >>> dict3
  {'a': 1, 'b': None, 'c': 3, 'd': 4, 'e': 5}
  >>> dict1
  {'d': 4, 'e': 5}

6 字典和列表的对比

字典的特殊性在于，内部存放的顺序与key存入的顺序没有任何关系，因为它本身就是无序的。字典与列表对比特点如下：

• 字典：
  • 查找和插入的速度极快，不会随着key的增加而变慢
  • 需要占用大量的内存（浪费比较多）
• 列表：
  • 查找和插入的时间随着元素的增加而增加
  • 占用空间小，内存浪费少

综上所述，字典是在用空间换取时间（执行效率）。

二 课后习题

（一）测试题部分

第25讲：

0. 当你听到小伙伴们在谈论“映射”、“哈希”、“散列”或者“关系数组”的时候，事实上他们就是在讨论什么呢？

答：是的，事实上他们就是在讨论我们这一讲介绍的“字典”，都是一个概念！

1. 尝试一下将数据（'F': 70, 'C': 67, 'h': 104, 'i': 105, 's': 115）创建为一个字典并访问键 'C' 对应的值？

>>> MyDict = dict((('F', 70), ('i',105), ('s',115), ('h',104), ('C',67)))
>>> MyDict_2 = {'F':70, 'i':105, 's':115, 'h':104, 'C':67}
>>> type(MyDict)
<class 'dict'>
>>> type(MyDict_2)
<class 'dict'>
>>> MyDict['C']
67

 2. 用方括号（“[]”）括起来的数据我们叫列表，那么使用大括号（“{}”）括起来的数据我们就叫字典，对吗？

>>> NotADict = {1, 2, 3, 4, 5}
>>> type(NotADict)
<class 'set'>

不难发现，虽然我们用大括号（“{}”）把一些数据括起来了，但由于没有反映出这些数据有映射的关系，所以创建出来的不是字典，而是叫’set’的东西，那’set’到底又是啥玩意儿呢？请看第027讲 | 集合：在我的世界里，你就是唯一！

3. 你如何理解有些东西字典做得到，但“万能的”列表却难以实现？

>>> brand = ['李宁', '耐克', '阿迪达斯', '鱼C工作室']
>>> slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing', '让编程改变世界']
>>> print('鱼C工作室的口号是：', slogan[brand.index('鱼C工作室')])
鱼C工作室的口号是： 让编程改变世界

列表brand、slogan的索引和相对的值是没有任何关系的，我们可以看出唯一有联系的就是两个列表间，索引号相同的元素是有关系的（品牌对应口号嘛），所以这里我们通过brand.index('鱼C工作室')这样的语句，间接的实现通过品牌查找对应的口号的功能。
  
这确实是一种可实现方法，呃……但用起来呢，多少有些别扭，效率还不高咧。况且Python是以简洁为主，这样子的实现肯定是不能让人满意的，所以呢，我们需要有字典这种映射类型的出现：

>>> dict1 = {'李宁':'一切皆有可能', '耐克':'Just do it', '阿迪达斯':'Impossible is nothing', '鱼C工作室':'让编程改变世界'}
>>> print('鱼C工作室的口号是：', dict1['鱼C工作室'])
鱼C工作室的口号是： 让编程改变世界

4. 下边这些代码，他们都在执行一样的操作吗？你看得出差别吗？

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})

答：是的，他们都在创建字典：a = dict(one=1, two=2, three=3)，没有差别

5. 如图，你可以推测出打了马赛克部分的代码吗？

嗯，我很傻的用分片的方式一个一个写的，我好呆。。。(data[0:3],data[5:7],data[9:])

data = "1000,小甲鱼,男"
MyDict = {}
# 还记得字符串的分割方法吧，别学过就忘啦^_^
(MyDict['id'], MyDict['name'], MyDict['sex']) = data.split(',') 

print("ID:   " + MyDict['id'])
print("Name: " + MyDict['name'])
print("Sex   " + MyDict['sex'])

第26讲：

0. Python的字典是否支持一键（Key）多值（Value）？

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

1. 在字典中，如果试图为一个不存在的键（Key）赋值会怎样？

答：会自动创建对应的键（Key）并添加相应的值（Value）进去。（具体原理可以参考第3题的“扩展阅读”部分）

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

答：在字典中检查键（Key）是否存在比在序列中检查指定元素是否存在更高效。因为字典的原理是使用哈希算法存储，一步到位，不需要使用查找算法进行匹配，因此时间复杂度是O（1），效率非常高。（关于如何使用哈希算法存储的具体原理可以参考第3题的“扩展阅读”部分）

3. Python对键（Key）和值（Value）有没有类型限制？

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

但是Python对值是没有任何限制的，它们可以是任意的Python对象。
如果不清楚哈希原理以及字典的存放原理的童鞋，推荐阅读下小甲鱼帮你整理的这篇文章：你知道Python的字典（Dict）是如何存储的吗？（http://bbs.fishc.com/thread-45016-1-1.html）

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

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

答：执行完成后，字典dict1的内容是：{1: '数字', 3: '数字'}
这里要注意的是，fromkeys方法是直接创建一个新的字典，不要试图使用它来修改一个原有的字典，因为它会直接无情的用把整个字典给覆盖掉。

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

答：可以利用字典的copy()方法：dict2 = dict1.copy()，在其他语言转移到Python小伙伴们刚开始可能会习惯性的直接用赋值的方法（dict2 = dict1），这样子做在Python中只是将对象的引用拷贝过去而已。

（二）动动手部分：

第25讲：

0. 尝试利用字典的特性编写一个通讯录程序吧！

 我的代码：（感觉我的代码比小甲鱼的代码要聪明一点，哈哈哈哈）

# -*- coding:utf-8 -*-
def printInfo():
    print("|--- 欢迎进入通讯录程序 ---|")
    print("|--- 1：查询联系人资料 ---|")
    print("|--- 2：插入新的联系人 ---|")
    print("|--- 3：删除已有联系人 ---|")
    print("|--- 4：退出通讯录程序 ---|")
    print()

def find(addressDict):
    print(addressDict)
    name = input("请输入联系人姓名：")
    if name in addressDict:
        print(f"{name}:{addressDict[name]}")
        return addressDict
    else:
        print("用户不存在，请重新选择相应操作！")
        return addressDict

def insert(addressDict):
    name = input("请输入联系人姓名：")
    if name in addressDict:
        print("您输入的姓名在通讯录中已存在",end = '')
        print(f"-->> {name}:{addressDict[name]}")
        i= input("是否修改用户资料（YES/NO）：")
        if i == YES:
            addressDict[name]=input("请输入用户联系电话：")
            return addressDict
        else:
            return main()
            return addressDict
    else:
        addressDict[name]=input("请输入用户联系电话：")
        return addressDict

def delete(addressDict):
    name = input("请输入联系人姓名：")
    if name in addressDict:
        del addressDict[name]
        return addressDict
    else:
        print("用户不存在，请重新选择相应操作！")
        return addressDict

def over():
    print("|--- 感谢使用通讯录程序 ---|")
    exit()

def main():
    addressDict = {}
    printInfo()
    while 1:
        print(f"addressDict = {addressDict}")
        num = int(input("请输入相关的指令代码："))

        if num == 1:
            find(addressDict)
        elif num == 2:
            insert(addressDict)
        elif num == 3:
            delete(addressDict)
        elif num == 4:
            over()
        else:
            print("输入错误，请重新输入数字:1或2或3或4 选择相应的操作")
        print()

main()

小甲鱼的代码：

print('|--- 欢迎进入通讯录程序 ---|')
print('|--- 1：查询联系人资料  ---|')
print('|--- 2：插入新的联系人  ---|')
print('|--- 3：删除已有联系人  ---|')
print('|--- 4：退出通讯录程序  ---|')

contacts = dict()

while 1:
    instr = int(input('
请输入相关的指令代码：'))
    
    if instr == 1:
        name = input('请输入联系人姓名：')
        if name in contacts:
            print(name + ' : ' + contacts[name])
        else:
            print('您输入的姓名不再通讯录中！')

    if instr == 2:
        name = input('请输入联系人姓名：')
        if name in contacts:
            print('您输入的姓名在通讯录中已存在 -->> ', end='')
            print(name + ' : ' + contacts[name])
            if input('是否修改用户资料（YES/NO）：') == 'YES':
                contacts[name] = input('请输入用户联系电话：')
        else:
            contacts[name] = input('请输入用户联系电话：')

    if instr == 3:
        name = input('请输入联系人姓名：')
        if name in contacts:
            del(contacts[name])         # 也可以使用dict.pop()
        else:
            print('您输入的联系人不存在。')
            
    if instr == 4:
        break

print('|--- 感谢使用通讯录程序 ---|')

第·26讲：

0. 尝试编写一个用户登录程序（这次尝试将功能封装成函数）

 小甲鱼代码：

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()