理论与实践

数据输入输出

任务

条件语句

任务

for循环

任务

字符串

任务

while循环

任务

列表

任务

二维数组

任务

字典

任务

集合

任务

函数与递归

任务

课程 8. Dictionary

难度：

任务«根据值对键进行排序»

💻 Python

在大学里，老师记录了词汇考试的结果，其中键是学生姓名，值是所获得的评分。需要编写一个程序，确定获得最高评分的学生姓名。

输入格式

第一行输入一个整数 & nbsp; n & nbsp; (1 & le; & nbsp; n & nbsp; & le; 100) & ndash; 表示小组中的学生人数。
接下来的 & nbsp; n & nbsp; 行以如下格式输入每个学生的信息： & nbsp; "Name" "Evaluation" ，其中 & nbsp; "Name" & nbsp; & ndash; 由拉丁字母组成的字符串（长度不超过20个字符），& nbsp; "Evaluation" & ndash; 一个从0到100的整数

输出格式

程序应推断出获得最高评分的学生姓名。如果多名学生拥有相同的最高评分，则显示其中任意一位学生的姓名。

示例

输入

3
alice: 95
Bob: 80
Charlie: 95

输出

爱丽丝

提示

Useful methods for working with dictionaries in Python

Dictionaries are one of the most powerful and flexible data structures in Python. To use them effectively, it is important to know the basic methods. Let's take a closer look at them.

The `keys() method`

Returns all dictionary keys as a special representation object dict_keys.

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
keys = my_dict.keys()
print(keys)  # Output: dict_keys(['key1', 'key2', 'key3'])

A useful tip: The dict_keys object is iterable, meaning you can use it in a for loop. However, this is not a list. If you need a list of keys (for example, for index access), simply convert it using the list() function.

key_list = list(my_dict.keys())
print(key_list[0]) # Output: key1

The `values() method`

Returns all dictionary values as a representation object dict_values.

values = my_dict.values()
print(values) # Output: dict_values(['value1', 'value2', 'value3'])

A useful tip: Like dict_keys, dict_values can be iterated, but it is not a list. The conversion to list() also works if you need a list of values. This is convenient, for example, to check for the presence of a value.

The `items() method`

Returns all key-value pairs as a dict_items object, where each pair is represented as a tuple.

items = my_dict.items()
print(items) # Output: dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

A useful tip: This method is incredibly convenient for iterating through a dictionary when you need both a key and a value at the same time. This is considered the most "Pythonic" way to bypass the dictionary.

for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

`get() method`

Returns the value by key. If there is no key, it returns the default value (or None if it is not specified).

value = my_dict.get("key1")
print(value) # Output: value1

value_nonexistent = my_dict.get("key4", "there is no such key")
print(value_nonexistent) # Output: there is no such key

A useful tip: Use get() instead of direct access through square brackets (my_dict["key4"]) when you are not sure if the key exists in the dictionary. This will avoid the KeyError error and the crash of the program. This is much safer when working with data that comes from external sources.

The `popitem() method`

Deletes and returns the last added key-value pair as a tuple.

last_item = my_dict.popitem()
print(last_item) # Output: ('key3', 'value3')
print(my_dict) # Output: {'key1': 'value1', 'key2': 'value2'}

A useful tip: This method works according to the LIFO (Last-In, First-Out) principle. It is useful when you need to process dictionary elements in the reverse order of their addition. (Guaranteed LIFO order is supported in Python 3.7+).

The `update() method`

Updates the dictionary by adding key-value pairs from another dictionary or from an iterable object with pairs.

# The original my_dict dictionary is already without 'key3'
my_dict.update({"key4": "value4", "key1": "new value1"})
print(my_dict)
# Output: {'key1': 'new value1', 'key2': 'value2', 'key4': 'value4'}

A useful tip: Note that if the key from the updating dictionary already exists in the original one, its value will be overwritten. update() is an effective way to merge two dictionaries.

Nested dictionaries

Dictionaries can contain other dictionaries as values. This allows you to create complex hierarchical data structures very similar to the JSON format.

nested_dict = {
    "key1": {"plugg1": "value1"},
"key2": {"plugg2": "value2"}
}

# Accessing the nested value
print(nested_dict["key1"]["plugg1"]) # Output: value1

An example of a multidimensional structure in dictionaries

students = {
    "Alice": {"age": 25, "grades": [88, 92, 85]},
    "Bob": {"age": 22, "grades": [79, 85, 80]},
    "Charlie": {"age": 23, "grades": [90, 87, 85]}
}

# Getting Alice's age
print(students["Alice"]["age"]) # Output: 25

# Getting the first grade Bob
print(students["Bob"]["grades"][0]) # Output: 79

# Adding a new student
students["David"] = {"age": 24, "grades": [82, 79, 88]}
print(students)

A useful tip: When working with nested dictionaries, the risk of getting a KeyError increases. For secure access to the embedded data, you can use a chain of calls get().

# Safely obtaining the age of a student, which may not be
age = students.get("Eve", {}).get("age", "Unknown")
print(age) # Output: Unknown

Here students.get("Eve", {}) will return an empty dictionary {}, since there is no student "Eve", and already this empty dictionary will be called .get("age", ...), which will prevent the error.