Python数据结构之字典

Posted 2022-04-23 涤生大数据

小练习之集合：列表 n1 = [1,3,5,7,12,14,16,18,23]，计算任意元素相加为17的集合

if __name__ == '__main__':
    n1 = [1,3,5,7,12,14,16,18,23]
    list = []
    l = len(n1)
    for i in range(0, l - 1):
        for j in range(i + 1, l):
            if n1[i] + n1[j] == 17:
                n = (n1[i], n1[j])
                list.append(n)
    print(list)

1 字典

之前提到过，元组的优点是可以处理含有任意类型数据的序列，但其元素不可变会带了很多的限制。列表可以做元组可做的事情，处理的是成组的数据，本文所使用的字典是处理成对的数据，主要是通过一个数据匹配到另一个数据，并且效率极高。

先来看Hangman（一个猜单词的双人游戏），玩家猜错一次，计算机就会显示一张绞刑图片，如果最终没能猜对，最终的结果就是显示一个被绞死的人。如下图：

部分代码：

def hangman():
    word = get_valid_word(words)
    word_letters = set(word)  # letters in the word
    alphabet = set(string.ascii_uppercase)
    used_letters = set()  # what the user has guessed

    lives = 7

    # getting user input
    while len(word_letters) > 0 and lives > 0:
       
        print('You have', lives, 'lives left and you have used these letters: ', ' '.join(used_letters))

        
        word_list = [letter if letter in used_letters else '-' for letter in word]
        print(lives_visual_dict[lives])
        print('Current word: ', ' '.join(word_list))

        user_letter = input('Guess a letter: ').upper()
        if user_letter in alphabet - used_letters:
            used_letters.add(user_letter)
            if user_letter in word_letters:
                word_letters.remove(user_letter)
                print('')

对于Hangman游戏来说，既可以使用列表也可以使用字典实现(以上二者皆有使用，需要代码可以联系博主)。对于字典来说，字典的每个键值 key => value 对用 : 分隔开，整个字典会包含在 中，一般如下（千万不要用dict作为变量名）：

 color = 'red' : 1, 'blue' : 2, 'green' : 3

使用键来访问字典值的效率极高，即便字典包含数千个键 - 值对。同样的，字典也可以添加、修改或者删除数据元素。不过，字典也有两个限制：

1. 字典中的键必须是独一无二的，即在 同一个字典中，任何两个键值对的键都不能相同；

2. 键必须是不可变的。因此，字典键不能是列表，也不能是字典。因为键值对在字典中的存储位置是根据键计算得到的。即便键发生细微变化，键值对在字典中的位置也将变化。这可能导致键值对丢失或无法访问。

2 字典函数

Python对于字典的使用也内置了许多功能函数，具体如下表所示：

函数名	返回值含义
dict1.items()	返回一个由字典 dict1 的键值对组成的视图
dict1.keys()	返回一个由字典 dict1 的键组成的视图
dict1.values()	返回一个由字典 dict1 的值组成的视图
dict1.get(key)	返回与 key 相关联的值
dict1.pop(key)	删除键 key 并返回与之相关联的值
dict1.popitem()	删除字典 dict1 中的某个键值对并返回相应的键值
dict1.clear()	删除字典 dict1 的所有元素
dict1.copy()	复制字典 dict1
dict1.fromkeys(s, t)	创建一个新字典，其中的键来自 s，值来自 t
dict1.setdefault(key, v)	如果键 key 包含在字典 dict1 中，则返回其值；否则，返回 v 并将 (key, v) 添加到字典 dict1 中
dict1.update(e)	将 e 中的键 - 值对添加到字典 dict1中；e 可能是字典，也可能是键值对序列

部分示例如下：

同时，对于两个字典来讲，Python也实现了简单的字典比较功能函数，主要有cmp(dict1, dict2)、len(dict)、str(dict)、type(variable)。

在使用中在去感受下字典的需求，也就是上面所提到的使用字典的限制。陈述到这里，我们在回溯一下一开始提到的Hangman游戏，这个程序的代码量相比于开发是少很多的，或许重点更在于需要准备的绞刑图，如下：

希望感兴趣的同志们可以实现一下这个小游戏，需要实现的部分有三个：

1.上面提到的图；
2.随机选取的words；
3.hangman游戏的主体函数部分。

Hangman实现参考

1.绞刑图

view = 
        0: """
                ___________
               | /        | 
               |/        ( )
               |          |
               |         / \\\\
               |
           """,
        1: """
                ___________
               | /        | 
               |/        ( )
               |          |
               |         / 
               |
            """,
        2: """
                ___________
               | /        | 
               |/        ( )
               |          |
               |          
               |
            """,
        3: """
                ___________
               | /        | 
               |/        ( )
               |          
               |          
               |
            """,
        4: """
                ___________
               | /        | 
               |/        
               |          
               |          
               |
            """,
        5: """
                ___________
               | /        
               |/        
               |          
               |          
               |
            """,
        6: """
               |
               |
               |
               |
               |
            """,
        7: "",
    

2.words准备

words = ["aback","abaft","abandoned","abashed","aberrant","abhorrent",
         "abiding","abject","ablaze"]
#数量自己定

3.功能函数部分

1.使用python库和上述两个代码段

import random
from practicce.hangman.words import words
from practicce.hangman.view import view
import string

2.随机从列表中选取word

def get_valid_word(words):
    word = random.choice(words)  # randomly chooses something from the list
    while '-' in word or ' ' in word:
        word = random.choice(words)

    return word.upper()

3.功能函数实现

def hangman():
    word = get_valid_word(words)
    #随机选出的单词
    word_letters = set(word)  
    alphabet = set(string.ascii_uppercase)
    #设置用户输入的单词
    used_letters = set()  

    lives = 7

    while len(word_letters) > 0 and lives > 0:
        
        print('You have', lives, 'lives left and you have used these letters: ', ' '.join(used_letters))

        word_list = [letter if letter in used_letters else '-' for letter in word]
        print(lives_visual_dict[lives])
        print('Current word: ', ' '.join(word_list))

        user_letter = input('Guess a letter: ').upper()
        if user_letter in alphabet - used_letters:
            used_letters.add(user_letter)
            if user_letter in word_letters:
                word_letters.remove(user_letter)
                print('')

            else:
                lives = lives - 1  #
                print('\\nYour letter,', user_letter, 'is not in the word.')

        elif user_letter in used_letters:
            print('\\nYou have already used that letter. Guess another letter.')

        else:
            print('\\nThat is not a valid letter.')

    if lives == 0:
        print(lives_visual_dict[lives])
        print('You died, sorry. The word was', word)
    else:
        print('Greate! You guessed the word', word, '!!')