Keyerror python как исправить

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python KeyError Exceptions and How to Handle Them

Python’s KeyError exception is a common exception encountered by beginners. Knowing why a KeyError can be raised and some solutions to prevent it from stopping your program are essential steps to improving as a Python programmer.

By the end of this tutorial, you’ll know:

• What a Python KeyError usually means
• Where else you might see a KeyError in the standard library
• How to handle a KeyError when you see it

>>> ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
>>> ages['Michael']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Michael'

 1# ages.py
 2
 3ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4person = input('Get age for: ')
 5print(f'{person} is {ages[person]} years old.')

$ python ages.py
Get age for: Michael
Traceback (most recent call last):
File "ages.py", line 4, in <module>
  print(f'{person} is {ages[person]} years old.')
KeyError: 'Michael'

>>> from zipfile import ZipFile
>>> zip_file = ZipFile('the_zip_file.zip')
>>> zip_file.getinfo('something')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/path/to/python/installation/zipfile.py", line 1304, in getinfo
  'There is no item named %r in the archive' % name)
KeyError: "There is no item named 'something' in the archive"

 1# ages.py
 2
 3ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4person = input('Get age for: ')
 5age = ages.get(person)
 6
 7if age:
 8    print(f'{person} is {age} years old.')
 9else:
10    print(f"{person}'s age is unknown.")

$ python ages.py
Get age for: Michael
Michael's age is unknown.

age = ages.get(person, 0)

 1# parse_api_response.py
 2...
 3# Assuming you got a `response` from calling an API that might
 4# have an error key in the `response` if something went wrong
 5
 6if 'error' in response:
 7    ...  # Parse the error state
 8else:
 9    ...  # Parse the success state

 1# ages.py
 2
 3ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4person = input('Get age for: ')
 5
 6try:
 7    print(f'{person} is {ages[person]} years old.')
 8except KeyError:
 9    print(f"{person}'s age is unknown.")

>>> from zipfile import ZipFile
>>> zip = ZipFile('the_zip_file.zip')
>>> try:
...     zip.getinfo('something')
... except KeyError:
...     print('Can not find "something"')
...
Can not find "something"

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python KeyError Exceptions and How to Handle Them

Отображение – это структура данных в Python, которая отображает один набор в другом наборе значений. Словарь Python является наиболее широко используемым для отображения. Каждому значению назначается ключ, который можно использовать для просмотра значения. Ошибка ключа возникает, когда ключ не существует в сопоставлении, которое используется для поиска значения.

В этой статье мы собираемся обсудить ошибки keyerror в Python и их обработку с примерами. Но прежде чем обсуждать ошибку ключа Python, мы узнаем о словаре.

Словарь (dict) в Python – это дискретный набор значений, содержащий сохраненные значения данных, эквивалентные карте. Он отличается от других типов данных тем, что имеет только один элемент, который является единственным значением. Он содержит пару ключей и значений. Это более эффективно из-за ключевого значения.

Двоеточие обозначает разделение пары ключа и значения, а запятая обозначает разделение каждого ключа. Этот словарь Python работает так же, как и обычный словарь. Ключи должны быть уникальными и состоять из неизменяемых типов данных, включая строки, целые числа и кортежи.

Давайте рассмотрим пример, чтобы понять, как мы можем использовать словарь (dict) в Python:

 
# A null Dictionary  
Dict = {}  
print("Null dict: ")  
print(Dict)  
  
# A Dictionary using Integers  
Dict = {1: 'Hill', 2: 'And', 3: 'Mountin'}  
print("nDictionary with the use of Integers: ")  
print(Dict)  
  
# A Dictionary using Mixed keys  
Dict = {'Name': 'John', 1: [17, 43, 22, 51]}  
print("nDictionary with the use of Mixed Keys: ")  
print(Dict)  
  
# A Dictionary using the dict() method  
Dict = dict({1: 'London', 2: 'America', 3:'France'})  
print("nDictionary with the use of dict(): ")  
print(Dict)  
  
# A Dictionary having each item as a Pair  
Dict = dict([(1, 'Hello'),(2, 'World')])  
print("nDictionary with each item as a pair: ")  
print(Dict) 

Вывод:

Null dict:  
{} 
nDictionary with the use of Integers:  
{1: 'Hill', 2: 'And', 3: 'Mountin'} 
nDictionary with the use of Mixed Keys:  
{'Name': 'John', 1: [17, 43, 22, 51]} 
nDictionary with the use of dict():  
{1: 'London', 2: 'America', 3: 'France'} 
nDictionary with each item as a pair:  
{1: 'Hello', 2: 'World'} 

Keyerror в Python

Когда мы пытаемся получить доступ к ключу из несуществующего dict, Python вызывает ошибку Keyerror. Это встроенный класс исключений, созданный несколькими модулями, которые взаимодействуют с dicts или объектами, содержащими пары ключ-значение.

Теперь мы знаем, что такое словарь Python и как он работает. Давайте посмотрим, что определяет Keyerror. Python вызывает Keyerror всякий раз, когда мы хотим получить доступ к ключу, которого нет в словаре Python.

Логика сопоставления – это структура данных, которая связывает один фрагмент данных с другими важными данными. В результате, когда к сопоставлению обращаются, но не находят, возникает ошибка. Это похоже на ошибку поиска, где семантическая ошибка заключается в том, что искомого ключа нет в его памяти.

Давайте рассмотрим пример, чтобы понять, как мы можем увидеть Keyerror в Python. Берем ключи A, B, C и D, у которых D нет в словаре Python. Хотя оставшиеся ключи, присутствующие в словаре, показывают вывод правильно, а D показывает ошибку ключа.

 
# Check the Keyerror 
ages={'A':45,'B':51,'C':67} 
print(ages['A']) 
print(ages['B']) 
print(ages['C']) 
print(ages['D']) 

Вывод:

45 
51 
67 
Traceback(most recent call last): 
File "", line 6, in  
KeyError: 'D' 

Механизм обработки ключевой ошибки в Python

Любой, кто сталкивается с ошибкой Keyerror, может с ней справиться. Он может проверять все возможные входные данные для конкретной программы и правильно управлять любыми рискованными входами. Когда мы получаем KeyError, есть несколько обычных методов борьбы с ним. Кроме того, некоторые методы могут использоваться для обработки механизма ошибки ключа.

Обычное решение: метод .get()

Некоторые из этих вариантов могут быть лучше или не могут быть точным решением, которое мы ищем, в зависимости от нашего варианта использования. Однако наша конечная цель – предотвратить возникновение неожиданных исключений из ключевых ошибок.

Например, если мы получаем ошибку из словаря в нашем собственном коде, мы можем использовать метод .get() для получения либо указанного ключа, либо значения по умолчанию.

Давайте рассмотрим пример, чтобы понять, как мы можем обработать механизм ошибки ключа в Python:

 
# List of vehicles and their prices.  
vehicles = {"Car=": 300000, "Byke": 115000, "Bus": 250000} 
vehicle = input("Get price for: ") 
vehicle1 = vehicles.get(vehicle) 
if vehicle1: 
    print("{vehicle} is {vehicle1} rupees.") 
else: 
    print("{vehicle}'s cost is unknown.") 

Вывод:

Get price for: Car 
Car is 300000 rupees. 

Общее решение для keyerror: метод try-except

Общий подход заключается в использовании блока try-except для решения таких проблем путем создания соответствующего кода и предоставления решения для резервного копирования.

Давайте рассмотрим пример, чтобы понять, как мы можем применить общее решение для keyerror:

 
# Creating a dictionary to store items and prices 
items = {"Pen" : "12", "Book" : "45", "Pencil" : "10"} 
try: 
  print(items["Book"]) 
except: 
  print("The items does not contain a record for this key.")   

Вывод:

45 

Здесь мы видим, что мы получаем стоимость книги из предметов. Следовательно, если мы хотим напечатать любую другую пару «ключ-значение», которой нет в элементах, она напечатает этот вывод.

 
# Creating a dictionary to store items and prices 
items = {"Pen" : "12", "Book" : "45", "Pencil" : "10"} 
try: 
  print(items["Notebook"]) 
except: 
  print("The items does not contain a record for this key.")  

Вывод:

The items does not contain a record for this key. 

Заключение

Теперь мы понимаем некоторые распространенные сценарии, в которых может быть выброшено исключение Python Keyerror, а также несколько отличных стратегий для предотвращения их завершения нашей программы.

В следующий раз, когда мы столкнемся с ошибкой Keyerror, мы будем знать, что это, скорее всего, связано с ошибочным поиском ключа словаря. Посмотрев на последние несколько строк трассировки, мы можем получить всю информацию, которая нам понадобится, чтобы выяснить, откуда взялась проблема.

Если проблема заключается в поиске ключа словаря в нашем собственном коде, мы можем использовать более безопасную функцию .get() с возвращаемым значением по умолчанию вместо запроса ключа непосредственно в словаре. Если наш код не вызывает проблемы, блок try-except – лучший вариант для регулирования потока нашего кода.

Исключения не должны пугать. Мы можем использовать эти методы, чтобы наши программы выполнялись более предсказуемо, если мы понимаем информацию, представленную нам в их обратных трассировках, и первопричину ошибки.

The Key Error exception in Python is an exception that most programmers encounter especially when they are getting started with Python dictionaries.

In this article you will learn:

• What does key error mean in Python
• How to fix key errors in Python
• How to handle key errors

What does key error mean?

A Key Error is a way for Python to tell you that you are trying to access a key that doesn’t exist in a dictionary.

Here’s an example, I create a file called keyerror.py…

I define a dictionary that contains countries and their capitals.

First I print the capital of Italy….

…then I print the capital of France.

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}

print(countries['Italy'])
print(countries['France'])

And here’s what I get when I run it:

Rome
Traceback (most recent call last):
  File "keyerror.py", line 3, in <module>
    print(countries['France'])
KeyError: 'France'

As you can see the value related to the first key of the dictionary (Italy) is printed as we want.

But something happens with the second print statement.

A KeyError appears in the output, and that’s because…

Python raises a KeyError when you attempt to access a key that doesn’t exist in a dictionary.

In this case the key ‘France’ doesn’t exist in the countries dictionary.

Notice also how Python can tell at which line of the code the exception has occurred. This is very useful to find the cause of the error quickly when you have hundreds or thousands of lines of code.

Core skill: When Python raises an exception a traceback is included. A traceback is used to give you all the details you need to understand the type of exception and to find what has caused it in your code. 

Makes sense?

How do I fix key errors in Python?

There are two very basic fixes for the key error if your program is simple:

1. Avoid referencing the key that doesn’t exist in the dictionary: this can make sense if, for example, the value of the key has been misspelled. It doesn’t apply to this specific case.
2. Add the missing key to the dictionary: in this case we would add ‘France’ as a key to the dictionary as part of its initial definition.

But those are not robust approaches and don’t prevent a similar error from occurring again in the future.

Let’s look instead at other two options…

First option

Tell Python not to return a KeyError if we try to access a key that doesn’t exist in the dictionary, but to return a default value instead.

Let’s say we want to return the default value ‘Unknown’ for any keys not present in the dictionary…

Here is how we can do it using the dictionary get() method:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}
default = 'Unknown'

print(countries.get('Italy', default))
print(countries.get('France', default))

And the output becomes:

Rome
Unknown

So, at least in this way we have more control over the way our program runs.

Second option

Verify if a key exists in a dictionary using the in operator that returns a boolean (True or False) based on the existence of that key in the dictionary.

In the example below I use the in operator together with an if else Python statement to verify if a key exists before accessing its value:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}

if 'France' in countries:
    print("The capital of France is %" % countries['France'])
else:
    print("The capital of France is unknown")

When I run it I see…

The capital of France is unknown

This is also a good option!

How do you handle key errors?

In the previous section I have introduced the dictionary get() method as a way to return a default value if a key doesn’t exist in our dictionary.

But, what happens if we don’t pass the default value as second argument to the get() method?

Let’s give it a try, being familiar with built-in methods makes a big difference when you write your code:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}

print(countries.get('Italy'))
print(countries.get('France'))

Do you know what the output is?

Rome
None

Interestingly this time Python doesn’t raise a KeyError exception…

…the get() method simply returns None if the key doesn’t exist in the dictionary.

This means that we can implement conditional logic in our code based on the value returned by the get() method. Here’s an example:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}
  
capital = countries.get('France')

if capital:
    print("The capital is %s" % capital)
else:
    print("The capital is unknown")

The output is:

The capital is unknown

A nice way to avoid that ugly exception 🙂

Avoiding the KeyError with a For Loop

Often a way to handle errors is by using programming constructs that prevent those errors from occurring.

I have mentioned before that a KeyError occurs when you try to access a key that doesn’t exist in a dictionary.

So, one way to prevent a KeyError is by making sure you only access keys that exist in the dictionary.

Ok, but how?

You could use a for loop that goes through all the keys of the dictionary…

This would ensure that only keys that are present in the dictionary are used in our code.

Let’s have a look at one example:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}

for key in countries:
    print("The capital of %s is %s" % (key, countries[key]))

And the output is…

The capital of Italy is Rome
The capital of Poland is Warsaw
The capital of UK is London

A for loop can be used to go through all the keys in a dictionary and to make sure you don’t access keys that are not part of the dictionary. This prevents the Python KeyError exception from occurring.

The Generic Approach For Exceptions

Finally, a generic approach you can use with any exceptions is the try except block.

This would prevent Python for raising the KeyError exception and it would allow you to handle the exception in the except block.

This is how you can do it in our example:

countries = {'Italy': 'Rome', 'Poland': 'Warsaw', 'UK': 'London'}
  
try:
    print('The capital of France is %s' % countries['France'])
except KeyError:
    print('The capital of France is unknown')

As you can see, in this case, the except block is written specifically to handle the KeyError exception.

In this case we could have also used a generic exception (removing KeyError)…

try:
    print('The capital of France is %s' % countries['France'])
except:
    print('The capital of France is unknown')

So, do we really need to specify the exception type?

It can be very handy if the try code block could raise multiple types of exceptions and we want to handle each type differently.

Conclusion

Now you have a pretty good idea on how to handle the KeyError exception in Python.

Few options are available to you, choose the one you prefer…

Are you gonna use the get() method or the in operator?

Do you prefer the try except approach?

Let me know in the comments below 🙂

Are you getting started with Python?

I have created a checklist for you to quickly learn the basics of Python. You can download it here for free.

Исключения Python KeyError и как их обработать

>>> ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
>>> ages['Michael']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Michael'

 1 # ages.py
 2
 3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4 person = input('Get age for: ')
 5 print(f'{person} is {ages[person]} years old.')

$ python ages.py
Get age for: Michael
Traceback (most recent call last):
File "ages.py", line 4, in 
  print(f'{person} is {ages[person]} years old.')
KeyError: 'Michael'

>>> from zipfile import ZipFile
>>> zip_file = ZipFile('the_zip_file.zip')
>>> zip_file.getinfo('something')
Traceback (most recent call last):
File "", line 1, in 
File "/path/to/python/installation/zipfile.py", line 1304, in getinfo
  'There is no item named %r in the archive' % name)
KeyError: "There is no item named 'something' in the archive"

 1 # ages.py
 2
 3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4 person = input('Get age for: ')
 5 age = ages.get(person)
 6
 7 if age:
 8     print(f'{person} is {age} years old.')
 9 else:
10     print(f"{person}'s age is unknown.")

$ python ages.py
Get age for: Michael
Michael's age is unknown.

age = ages.get(person, 0)

 1 # parse_api_response.py
 2 ...
 3 # Assuming you got a `response` from calling an API that might
 4 # have an error key in the `response` if something went wrong
 5
 6 if 'error' in response:
 7     ...  # Parse the error state
 8 else:
 9     ...  # Parse the success state

 1 # ages.py
 2
 3 ages = {'Jim': 30, 'Pam': 28, 'Kevin': 33}
 4 person = input('Get age for: ')
 5
 6 try:
 7     print(f'{person} is {ages[person]} years old.')
 8 except KeyError:
 9     print(f"{person}'s age is unknown.")

>>> from zipfile import ZipFile
>>> zip = ZipFile('the_zip_file.zip')
>>> try:
...     zip.getinfo('something')
... except KeyError:
...     print('Can not find "something"')
...
Can not find "something"

In this article let us learn

• what KeyError exceptions are,
• why they occur,
• how to prevent them from occurring and
• if they still occur then what are the crucial information we need to log for future debugging and
• how to log this information.

In our journey to become a Proficient Python craftsman, we need to learn to design un-crashable code and this article is a step towards that goal!

If this is the first time ever seeing a python program crash, I recommend reading the article in the link below to hone your Exception Handling skills before continuing with this one.

Exceptions in Python: Everything You Need To Know!

There are 3 main ways to handle KeyError Exceptions in Python. The first 2 ways are about preventing them. We can prevent the error

• by using the get() method
• by using the setdefault() method

These 2 methods are provided to us by the dict class

The 3rd way is to

• Catch them from the except and logging the information needed to debug later.

For those of you in a hurry, use the table of content below to jump to your section of interest.

Let us start by learning what KeyError means.

What is KeyError?

A dictionary is a built-in data-structure in Python used to store key-value pairs.
For example, this line of code

superDict = {'a':'aquaman', 'b':'batman'}

will create a dictionary like this

Here, the dictionary superDict is initialized with 2 key-value pairs.

Now say we wish to access the dict with a key which is not already present inside it like this

print(superDict['c']) # Expecting catwoman here!

Then python will raise a KeyError like this.

Traceback (most recent call last):

  File "<ipython-input-2-7080830d124d>", line 1, in <module>
    c = superDict['c'] # Expecting cat-woman here!

KeyError: 'c'

I am guessing you experienced something similar to this before getting here. So make sure if the key-value pair you are trying to access has been initialized properly.

To summarize, When working with dicts in Python, if we are trying to use a Key that does not match any of the keys stored inside the dict object, Python will raise a KeyError

Python provides some cool tricks to make sure our programs don’t crash if such errors occur.

To prevent KeyError Exceptions python provides us with 2 useful methods as part of the dictionary class.

• get() method and
• setdefault() method

Both these methods are useful in 2 different scenarios, let us see how to use them and which one to use in what scenario.

Let us first start with the get() method.

Method#1: Preventing KeyError Exceptions using the get() method

Have a look at the code below

superDict = {'a':'aquaman', 'b':'batman'}
x = superDict.get('c', 'catwoman')
print(x)

Here if the superDict does not contain the key ‘c’, the get() method will set the value for the variable x to be ‘catwoman‘ instead of throwing an exception.

Running the code above will result in the output below

catwoman

Now if we have a look at the objects created by this program, you will see that the dictionary superDict will still have only 2 key-value pairs and the variable x will contain the string ‘catwoman’ as shown below.

This can be also seen at the python prompt

>> superDict
{'a': 'aquaman', 'b': 'batman'}

>> x
'catwoman'

When to use the get() method?

If you wish to avoid KeyError Exception and avoid adding any key-value pairs to the dictionary then use the get() method.

Method#2: Preventing KeyError Exceptions using the setdefault() method

Have a look at the code below.

superDict = {'a':'aquaman', 'b':'batman'}
c = superDict.setdefault('c', 'catwoman')
d = superDict.get('d', 'duperman?!')
print(c)
print(d)

In line-2 we have used to setdefault() method to avoid KeyError and in line-3 we have used the get() method to avoid KeyError. Note that both the keys ‘c’ and ‘d’ are not available in our superDict

Let us run this code and see what happens.

catwoman
duperman?!

As you can see the code ran fine without KeyErrors!

Let us have a quick look at our dictionary superDict!

As you can see in the screenshot above, the setdefault() method has added the new key-value pair ‘c’:’catwoman’ to our superDict, and the get() method has not added anything.

When to use setdefault() method?

Use setdefault() method if you want to avoid KeyError Exception and add a key-value pair to your dictionary in the process.

Method#3: Logging important information about KeyError from the except clause

There are situations/cases where you cannot do much about preventing KeyErrors and all you can do is log the information and debug the exception later on. In such situations, we need to log the important information so that we have the clues necessary to debug this issue.

Let us see what information can we get from KeyError exceptions and how to log them.

Let us start by looking at the error message that the interpreter throws at us by manually forcing a KeyError using the raise statement.

raise KeyError

Running the line of code above leaves us with the following error message

Traceback (most recent call last):

  File "<ipython-input-1-0783d6d4a852>", line 1, in <module>
    raise KeyError

KeyError

As you can see, we are given the exact line number (line 1) and the type of exception (KeyError), both of which are crucial information to help us debug the exception later on. But if we let the python interpreter crash our program, we will not be able to log this information, also the user of our program might not enjoy the view of such a technical/scary error message.

If this is your first raise statement and you are curious to learn more about how to use this tool to enhance your python proficiency, I recommend adding the article in the link below to your reading list and read that after you finish reading this one!

Python: Manually throw/raise an Exception using the “raise” statement

Coming back to this article, let us see how to log the necessary information using try-except clauses.

import traceback

try:
  superDict = {'a':'aquaman', 'b':'batman'}
  print(superDict['c'])
except KeyError as err:
  print("Unknown key: ", err)
  traceback.print_exc()

In the code above, we have placed the problematic code in the try clause and we are using an except clause to catch KeyError exceptions. As soon as catching we are assigning the caught exception object to the variable named err and printing out the information contained inside that object using the line print(“Unknown key: “, err)

We have also imported the traceback module in Python which is used in the last line to help us understand which line of code caused the error.

Running the code above, we can see something like

Unknown key:  'c'
Traceback (most recent call last):
  File "/home/balaji/.config/spyder-py3/temp.py", line 5, in <module>
    print(superDict['c'])
KeyError: 'c'

As you can see we have printed out the error message just as we wanted!

If you look closely, there are 3 pieces of information in this error message

1. The value inside the caught exception object (err), which is the string ‘c’, the key that caused the error!
2. The traceback showing where in our code this exception was raised from, line-3 in this case and
3. The exception type, which is KeyError

If you are curious to know how to control the logging of each individual piece so that you can have a tidier error log, I have an entire article dedicated to just that!
You can read that in the link below.

Python Exceptions: Getting and Handling Error Messages as strings.

And with that, I will conclude this article.

I hope you found this article useful on your journey of python mastery!

Feel free to share this article with your friends and colleagues!