Python ioerror error

Python errors and exceptions

Every programmer encounters errors, both those who are just beginning, and those who have been programming for years. Encountering errors and exceptions can be very frustrating at times, and can make coding feel like a hopeless endeavour. However, understanding what the different types of errors are and when you are likely to encounter them can help a lot! Once you know why you get certain types of errors, they become much easier to fix.

The anatomy of an error

Errors in Python have a very specific form, called a traceback. Let’s examine one:

from errors_01 import favorite_ice_cream
favorite_ice_cream()

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-1-9d0462a5b07c> in <module>()
      1 from errors_01 import favorite_ice_cream
----> 2 favorite_ice_cream()

/Users/jhamrick/project/swc/novice/python/errors_01.pyc in favorite_ice_cream()
      5         "strawberry"
      6     ]
----> 7     print ice_creams[3]

IndexError: list index out of range

This particular traceback has two levels. You can determine the number of levels by looking for the number of arrows on the left hand side. In this case:

1. The first shows code from the cell above, with an arrow pointing to Line 2 (which is favorite_ice_cream()).
2. The second shows some code in another function (favorite_ice_cream, located in the file errors_01.py), with an arrow pointing to Line 7 (which is print ice_creams[3]).

The last level is the actual place where the error occurred. The other level(s) show what function the program executed to get to the next level down. So, in this case, the program first performed a function call to the function favorite_ice_cream. Inside this function, the program encountered an error on Line 7, when it tried to run the code print ice_creams[3].

Long tracebacks

Sometimes, you might see a traceback that is very long – sometimes they might even be 20 levels deep! This can make it seem like something horrible happened, but really it just means that your program called many functions before it ran into the error. Most of the time, you can just pay attention to the bottom-most level, which is the actual place where the error occurred.

So what error did the program actually encounter? In the last line of the traceback, Python helpfully tells us the category or type of error (in this case, it is an IndexError) and a more detailed error message (in this case, it says «list index out of range»).

If you encounter an error and don’t know what it means, it is still important to read the traceback closely. That way, if you fix the error, but encounter a new one, you can tell that the error changed! Additionally, sometimes just knowing where the error occurred is enough to fix it, even if you don’t entirely understand the message.

If you do encounter an error you don’t recognize, try looking at the official documentation on errors. However, note that you may not always be able to find the error there, as it is possible to create custom errors. In that case, hopefully the custom error message is informative enough to help you figure out what went wrong!

from errors_02 import print_friday_message
print_friday_message()

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-2-e4c4cbafeeb5> in <module>()
      1 from errors_02 import print_friday_message
----> 2 print_friday_message()

/Users/jhamrick/project/swc/novice/python/errors_02.py in print_friday_message()
     13 
     14 def print_friday_message():
---> 15     print_message("Friday")

/Users/jhamrick/project/swc/novice/python/errors_02.py in print_message(day)
      9         "sunday": "Aw, the weekend is almost over."
     10     }
---> 11     print messages[day]
     12 
     13 

KeyError: 'Friday'

Syntax errors

When you forget a colon at the end of a line, accidentally add one space too many when indenting under an if statement, or forget a parentheses, you will encounter a syntax error. This means that Python couldn’t figure out how to read your program. This is similar to forgetting punctuation in English:

this text is difficult to read there is no punctuation there is also no capitalization why is this hard because you have to figure out where each sentence ends you also have to figure out where each sentence begins to some extent it might be ambiguous if there should be a sentence break or not

People can typically figure out what is meant by text with no punctuation, but people are much smarter than computers! If Python doesn’t know how to read the program, it will just give up, and inform you with an error. For example:

def some_function()
    msg = "hello, world!"
    print msg
     return msg

  File "<ipython-input-3-6bb841ea1423>", line 1
    def some_function()
                       ^
SyntaxError: invalid syntax

Here, Python tells us that there is a SyntaxError on line 1, and even puts a little arrow in the place where there is an issue. In this case, the problem is that the function definition is missing a colon at the end.

Actually, the function above has two issues with syntax. If we fix the problem with the colon, we see that there is also an IndentationError, which means that the lines in the function definition do not all have the same indentation:

def some_function():
    msg = "hello, world!"
    print msg
     return msg

  File "<ipython-input-4-ae290e7659cb>", line 4
    return msg
    ^
IndentationError: unexpected indent

Both SyntaxError and IndentationError indicate a problem with the syntax of your program, but an IndentationError is more specific: it always means that there is a problem with how your code is indented.

Whitespace: tabs and spaces

A quick note on indentation errors: they can sometimes be insidious, especially if you are mixing spaces and tabs. Because they are both «whitespace», it is difficult to visually tell the difference! The IPython notebook actually gives us a bit of a hint, but not all Python editors will do that. In the following example, the first two lines are using a tab for indentation, while the third line uses four spaces.

def some_function():
	msg = "hello, world!"
	print msg
    return msg

  File "<ipython-input-5-653b36fbcd41>", line 4
    return msg
              ^
IndentationError: unindent does not match any outer indentation level

By default, one tab is equivalent to eight spaces, so the only way to mix tabs and spaces is to make it look like this! In general, is is better to just never use tabs and always use spaces, because it can make things very confusing.

def some_function():
	msg = "hello, world!"
	print msg
        return msg

def another_function
  print "Syntax errors are annoying."
   print "But at least python tells us about them!"
  print "So they are usually not too hard to fix."

Variable name errors

Another very common type of error is called a NameError, and occurs when you try to use a variable that does not exist. For example:

print a

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-7-9d7b17ad5387> in <module>()
----> 1 print a

NameError: name 'a' is not defined

Variable name errors come with some of the most informative error messages, which are usually of the form «name ‘the_variable_name’ is not defined».

Why does this error message occur? That’s harder question to answer, because it depends on what your code is supposed to do. However, there are a few very common reasons why you might have an undefined variable. The first is that you meant to use a string, but forgot to put quotes around it:

print hello

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-8-9553ee03b645> in <module>()
----> 1 print hello

NameError: name 'hello' is not defined

The second is that you just forgot to create the variable before using it. In the following example, count should have been defined (e.g., with count = 0) before the for loop:

for number in range(10):
    count = count + number
print "The count is: " + str(count)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-9-dd6a12d7ca5c> in <module>()
      1 for number in range(10):
----> 2     count = count + number
      3 print "The count is: " + str(count)

NameError: name 'count' is not defined

Finally, the third possibility is that you made a typo when you were writing your code. Let’s say we fixed the error above by adding the line Count = 0 before the for loop. Frustratingly, this actually does not fix the error! Remember that variables are case-sensitive, so the variable count is different from Count. We still get the same error, because we still have not defined count:

Count = 0
for number in range(10):
    count = count + number
print "The count is: " + str(count)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-10-d77d40059aea> in <module>()
      1 Count = 0
      2 for number in range(10):
----> 3     count = count + number
      4 print "The count is: " + str(count)

NameError: name 'count' is not defined

for number in range(10):
    # use a if the number is a multiple of 3, otherwise use b
    if (Number % 3) == 0:
        message = message + a
    else:
        message = message + "b"
print message

Item errors

Next up are errors having to do with containers (like lists and dictionaries) and the items within them. If you try to access an item in a list or a dictionary that does not exist, then you will get an error! This makes sense. Think about a real life example: if you asked someone what day they would like to get coffee, and they answered «caturday», you might be a bit annoyed (though, perhaps after being amused that someone thought of the idea of caturday). Python gets similarly annoyed if you try to ask it for an item that doesn’t exist:

letters = ['a', 'b', 'c']
print "Letter #1 is " + letters[0]
print "Letter #2 is " + letters[1]
print "Letter #3 is " + letters[2]
print "Letter #4 is " + letters[3]

Letter #1 is a
Letter #2 is b
Letter #3 is c

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-11-d817f55b7d6c> in <module>()
      3 print "Letter #2 is " + letters[1]
      4 print "Letter #3 is " + letters[2]
----> 5 print "Letter #4 is " + letters[3]

IndexError: list index out of range

Here, Python is telling us that there is an IndexError in our code, meaning we tried to access a list index that did not exist.

We get a similar error in the case of dictionaries:

us_state_capitals = {
    'california': 'sacramento',
    'virginia': 'richmond',
    'new york': 'albany',
    'massachusetts': 'boston'
}

print "The capital of Oregon is: " + us_state_capitals['oregon']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-12-27fa113dd73c> in <module>()
      6 }
      7 
----> 8 print "The capital of Oregon is: " + us_state_capitals['oregon']

KeyError: 'oregon'

In this case, we get a KeyError, which means that the key we requested ('oregon', as the error message tells us) is not present in the dictionary. This might be because it genuinely does not exist in the dictionary, but it could also be due to a typo. This is similar to the case we discussed above, where you can sometimes receive a NameError due to a typo. For example:

us_state_capitals = {
    'california': 'sacramento',
    'virginia': 'richmond',
    'new york': 'albany',
    'massachusetts': 'boston'
}

print "The capital of Massachusetts is: " + us_state_capitals['massachussetts']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-13-ae1dac4c6a45> in <module>()
      6 }
      7 
----> 8 print "The capital of Massachusetts is: " + us_state_capitals['massachussetts']

KeyError: 'massachussetts'

seasons = {
    'spring': ['march', 'april', 'may'],
    'summer': ['june', 'july', 'august'],
    'fall': ['september', 'october', 'november'],
    'winter': ['december', 'january', 'february']
}

print "The first month in spring is: " + seasons['spring'][0]
print "The third month in summer is: " + seasons['summer'][3]
print "The third month in fall is: " + seasons['fal'][3]
print "The second month in winter is: " + seasons['Winter'][1]

File errors

The last type of error we’ll cover today are those associated with reading and writing files: IOError. The «IO» in IOError stands for «input/output», which is just a fancy way of saying «writing/reading».

If you try to read a file that does not exist, you will recieve an IOError telling you so. This is the most common reason why you would receive IOError, and if the error messages says «no such file or directory», then you know you have just tried to access a file that does not exist:

file_handle = open('myfile.txt', 'r')

---------------------------------------------------------------------------
IOError                                   Traceback (most recent call last)
<ipython-input-14-f6e1ac4aee96> in <module>()
----> 1 file_handle = open('myfile.txt', 'r')

IOError: [Errno 2] No such file or directory: 'myfile.txt'

One reason for receiving this error is that you specified an incorrect path to the file. For example, if I am currently in a folder called myproject, and I have a file in myproject/writing/myfile.txt, but I try to just open myfile.txt, this will fail. The correct path would be writing/myfile.txt. It is also possible (like with NameError and KeyError) that you just made a typo.

Another issue could be that you used the «read» flag instead of the «write» flag. Python will not give you an error if you try to open a file for writing when the file does not exist. However, if you meant to open a file for reading, but accidentally opened it for writing, and then try to read from it, you will get an error telling you that the file was not opened for reading:

file_handle = open('myfile.txt', 'w')
file_handle.read()

---------------------------------------------------------------------------
IOError                                   Traceback (most recent call last)
<ipython-input-15-b846479bc61f> in <module>()
      1 file_handle = open('myfile.txt', 'w')
----> 2 file_handle.read()

IOError: File not open for reading

Введение

В этом уроке вы узнаете о важном средстве языка, без которого крупная программа не может обойтись. Речь пойдет об исключениях. Что это такое, как ими пользоваться и как создавать собственные?

Исключительные ситуации или исключения (exceptions) – это ошибки, обнаруженные при исполнении. Например, к чему приведет попытка чтения несуществующего файла? Или если файл был случайно удален пока программа работала? Такие ситуации обрабатываются при помощи исключений.

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

Простейший пример исключения — деление на ноль:

>>> 100 / 0
Traceback (most recent call last):
  File "", line 1, in
    100 / 0
ZeroDivisionError: division by zero

В данном случае интерпретатор сообщил нам об исключении ZeroDivisionError – делении на ноль.

Traceback

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

Рассмотрим такой пример:

Traceback (most recent call last):
  File "/home/username/Develop/test/app.py", line 862, in _handle
    return route.call(**args)
  File "/home/username/Develop/test/app.py", line 1729, in wrapper
    rv = callback(*a, **ka)
  File "/home/username/Develop/test/__init__.py", line 76, in wrapper
    body = callback(*args, **kwargs)
  File "/home/username/Develop/test/my_app.py", line 16, in index
    raise Exception('test exception')

В данном примере чётко видно, какой путь исполнения у программы. Смотрим снизу вверх и по шагам понимаем, как же мы докатились до такого исключения.

Рассмотрим какие ещё встречаются комментарии к исключениям:

>>> 2 + '1'

Traceback (most recent call last):
  File "", line 1, in
    2 + '1'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

В данном примере при попытке сложить целое число и строку мы получаем исключение TypeError. В описании сразу же становится ясно, что же мы не так написали.

>>> int('qwerty')

Traceback (most recent call last):
  File "", line 1, in
    int('qwerty')
ValueError: invalid literal for int() with base 10: 'qwerty'

Приведение строчки к целому числу приводит к исключению ValueError.

В трэйсе этих двух примеров можно прочесть, что в таком-то файле на такой-то строчке есть ошибки.

На этом список встроенных исключений не заканчивается, в следующем разделе рассмотрены основные исключения и причины их возникновения.

Иерархия исключений

Исключение, которое вы не увидите при выполнении кода – это BaseException – базовое исключение, от которого берут начало остальные.

В иерархии исключений две основные группы:

• Системные исключения и ошибки
• Обыкновенные исключения

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

К системным можно смело отнести:

• SystemExit – исключение, порождаемое функцией sys.exit при выходе из программы.
• KeyboardInterrupt – возникает при прерывании программы пользователем (обычно сочетанием клавиш Ctrl+C).
• GeneratorExit — возникает при вызове метода close объекта generator.

Остальные исключения – это «обыкновенные». Спектр уже готовых исключений велик.

Для Python2 иерархию исключений можно представить так:

Список исключений покрывает большой объем ситуаций и ошибок программиста. Если предупреждения (warning) только просят обратить внимание, то ошибки уже могут остановить исполнение программы.

В Python3 появились новые исключения и иерархия стала такова:

В целом заметно, что при создании Python3 добавлен блок новых исключений. Но даже этих почти 70 исключений не хватает при написании программ на языке Python.

Использование исключений

Мы рассмотрели что такое исключения, какие они бывают и как их анализировать. Но до сих пор явно не рассмотрели такую важную вещь, как их использование.

Начнем с обработки.

Обработка исключений

Давайте рассмотрим случай с делением на 0.

>>> a = 100
>>> b = 0
>>> c = a / b

Данный код приведет к исключению ZeroDivisionError. Чтобы этого не случилось, воспользуемся конструкцией try..except, например, так:

>>> try:
...     a = 100
...     b = 0
...     c = a / b
... except ZeroDivisionError as e:
...     print(e)
...
division by zero

Если исполнить этот код, то на консоль будет выведена строка «integer division or modulo by zero«. Казалось бы, что толком ничего это нам не дало, ошибка все также есть. Однако в блок except можно поместить обработку.

Например, мы условились, что значение переменной c в случае ошибки деления равно -1. Тогда модифицируем код:

>>> try:
...     a = 100
...     b = 0
...     c = a / b
... except ZeroDivisionError as e:
...     c = -1
>>> c
-1

Перед тем как идти дальше, рассмотрим ещё одну возможность.

Пускай у нас файл с данными в файловой системе, и необходимо его прочитать. В этом случае сразу же всплывают несколько исключительных ситуаций, такие как: нет файла, файл битый, файл пустой (по заданию мы знаем, что в нём данные) и другие.

Используя исключения, можно вот так решить эту задачу:

try:
    filepath = 'test_file.txt'
    with open(filepath, 'r') as fio:
        result = fio.readlines()
    if not result:
        raise Exception("File is empty")

except IOError as e:
    result = []
except Exception as e:
    result = []
    print(e)

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

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

try:
    your_code
except (IOError, Exception) as e:
    print(e)

Вызов исключений

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

На сленге программистов «бросить исключение» означает написать код, который при исполнении будет инициировать исключительную ситуацию.

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

Чтобы бросить исключение необходимо воспользоваться raise

Пример:

raise IOError("текст исключения")

где IOError это класс исключения.

Если при обработке исключения вы желаете пробросить его ещё выше, то следует написать такой код:

try:
    your_code
except Exception as e:
    raise

Собственные исключения

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

В минимальном исполнении необходимо наследоваться от какого-нибудь класса в иерархии исключений. Например так:

class MyException(Exception):
    pass

Тогда можно бросить своё исключение:

raise MyException(Exception)

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

Как правило, исключения это очень маленькие классы. Они должны выполняться максимально быстро.

Дополнение: Полная форма try..except

Форма try...except не полная, полной же является try..except..else..finally.

Применение полной конструкции может заметно упростить код, а также сделать его более безопасным.

Представим, что в программе происходит чтение файла и необходимо убедиться, что объект файла был корректно закрыт и что не возникло никакого исключения. Этого можно достичь с применением блока finally.

Иными словами, finally выполняет блок инструкций в любом случае, было ли исключение, или нет. А инструкция else выполняется в том случае, если исключения не было.

В целом, использование полной формы таково:

try:
    исполяем какой-то код
except Exception as e:
    обработка исключения
else:
    код, который будет исполнен в случае, когда не возникает исключения
finally:
    код, который гарантированно будет исполнен последним (всегда исполняется)

Выводы

В уроке рассмотрены вопросы связанные с исключениями:

• Что такое исключение
• Какие типы исключений присутствуют в языке
• Как обрабатывать исключения
• Как вызвать исключения
• Как создавать собственные исключения

Like any programming language, an error in python occurs when a given code fails to follow the syntax rules. When a code does not follow the syntax, python cannot recognize that segment of code, so it throws an error. Errors can be of different types, such as runtime error, syntax error, logical error, etc. IOError errno 2 no such file or directory is one such type of error. Let us first understand each individual term of the error.

Note : Starting from Python 3.3, IOError is an aliases of OSError

What is IOError?

An IOError is thrown when an input-output operation fails in the program. The common input-output operations are opening a file or a directory, executing a print statement, etc. IOError is inherited from the EnvironmentError. The syntax of IOError is:

IOError : [Error number] ‘Reason why the error occurred’: ‘name of the file because of which the error occurred’

Examples of IOError are :

• Unable to execute the open() statement because either the filename is incorrect or the file is not present in the specified location.
• Unable to execute the print() statements because either the disk is full or the file cannot be found
• The permission to access the particular file is not given.

What is errno2 no such file or directory?

The ‘errorno 2 no such file or directory‘ is thrown when you are trying to access a file that is not present in the particular file path or its name has been changed.

This error is raised either by ‘FileNotFoundError’ or by ‘IOError’. The ‘FileNotFoundError’ raises ‘errorno 2 no such file or directory‘ when using the os library to read a given file or a directory, and that operation fails.

The ‘IOError’ raises ‘errorno 2 no such file or directory‘ when trying to access a file that does not exist in the given location using the open() function.

Handling ‘IOError [errorno 2] no such file or directory’

‘IOError errorno 2 no such file or directory‘ occurs mainly while we are handling the open() function for opening a file. Therefore, we will look at several solutions to solve the above error.

We will check if a file exists, raise exceptions, solve the error occurring while installing ‘requirements.txt,’ etc.

Checking if the file exists beforehand

If a file or a directory does not exist, it will show ‘IOError [errorno 2] no such file or directory’ while opening it. Let us take an example of opening a file named ‘filename.txt’.

The given file does not exist and we shall see what happens if we try to execute it.

Since the above text file does not exist, it will throw the IOError.

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    f = open('filename.txt')
IOError: [Errno 2] No such file or directory: 'filename.txt'

To avoid the above error from being thrown, we will use several methods which will first check if the file exists or not. It will execute the open() function only if the file exists.

We have two modules containing functions for checking if a file exists.

1. OS Module
2. Pathlib Module

Using the OS Module

In the os module, there are three functions which can be used:

• os.path.isfile()
• os.path.isdir()
• os.path.exists()

To solve the IOError, we can use either of the above function in a condition statement. We will pass the pathname of the file as an argument to the above functions.

If the file or the directory exists, the function shall return True else False. Bypassing either of the above functions as the conditional statement ensures that python will open a file only if it exists, thus preventing an error from occurring.

We will use os.path.isfile() when we want to check if a file exists or not, os.path.isdir() to check if a directory exists or not and os.path.exists() to check if a path exists or not.

Since we want to check for a file, we can use either the os.path.isfile() function or os.path.exists() function. We shall apply the function to the above example.

import os

path_name = "filename.txt"

if os.path.isfile(path_name):
  print("File exists")
  f = open(path_name)
  #Execute other file operations here
  f.close()
  
else:
  print("File does not exist! IOError has occured")

First, we have imported the os module. Then we have a variable named ‘path_name‘ which stores the path for the file.

We passed the path_name as an argument to the os.path.isfile() function. If the os.path.isfile() function returns a true value. Then it will print “File exists” and execute the other file operations.

If the file does not exist, then it will print the second statement in the else condition. Unlike the previous case, here, it will not throw an error and print the message.

File does not exist! IOError has occured

Similarly, we can also use os.path.exists() function.

Using the pathlib module

The pathlib module contains three functions – pathlib.Path.exists(), pathlib.Path.is_dir() and pathlib.Path.is_file().

We will use pathlib.Path.is_file() in this example. Just like the os module, we will use the function in an if conditional statement.

It will execute the open() function only if the file exists. Thus it will not throw an error.

from pathlib import Path
path_name = "filename.txt"
p = Path(path_name)
if p.is_file():
  print("File exists")
  f = open(path_name)
  #Execute other file operations here
  f.close()
  
else:
  print("File does not exist! IOError has occured")

Since the file does not exist, the output is :

File does not exist! IOError has occured

Using try – except block

We can also use exception handling for avoiding ‘IOError Errno 2 No Such File Or Directory’. In the try block, we will try to execute the open() function.

If the file is present, it will execute the open() function and all the other file operations mentioned in the try block. But, if the file cannot be found, it will throw an IOError exception and execute the except block.

try:
    f = open("filename.txt")
    #Execute other operations
    f.close()
except IOError as io:
    print(io)

Here, it will execute the except block because ‘filename.txt’ does not exist. Instead of throwing an error, it will print the IOError.

[Errno 2] No such file or directory: 'filename.txt'

We can also print a user defined message in the except block.

try:
    f = open("filename.txt")
    #Execute other operations
    f.close()
except IOError:
    print("File does not exist. IOError has occured")

The output will be:

File does not exist. IOError has occured

IOError errno 2 no such file or directory in requirements.txt

Requirements.txt is a file containing all the dependencies in a project and their version details.

Basically, it contains the details of all the packages in python needed to run the project. We use the pip install command to install the requirements.txt file. But it shows the ‘IOError errno 2 no such file or directory’ error.

!pip install -r requirements.txt

The thrown error is:

ERROR: Could not open requirements file: [Errno 2] No such file or directory: 'requirements.txt'

To solve the above error, we use the pip freeze command. When we use pip freeze, the output will contain the package along with its version.

The output will be in a configuration that we will use with the pip install command.

pip freeze > requirements.txt

Now, we will try to execute the pip install command again. It will no longer throw errors and all the packages will be installed successfully.

Opening file in ‘w+’ mode

While trying to open a text file, the default mode will be read mode. In that case, it will throw the ‘IOError Errno 2 No Such File Or Directory’ error.

f = open("filename.txt")
f.close()
print("Successful")

The output is:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    f = open("filename.txt")
IOError: [Errno 2] No such file or directory: 'filename.txt'

To solve the error, we can open the file in ‘w+’ mode. This will open the file in both – reading and writing mode. If the file does not exist, it will create a new file, and if the file exists, it will overwrite the contents of the file. This way, it will not throw an error.

f = open("filename.txt", 'w+')
f.close()
print("Successful")

The output is:

Successful

Apart from all the above methods, there are some ways to ensure that the IOError does not occur. You have to ensure that you are giving the absolute path as the path name and not simply the name of the file.

Also, see to that there are no escape sequences in the path name of this file.

For example : In path_name = "C:name.txt ", it will consider the 'n' from 'name.txt' as an escape sequence. 

So, it will not be able to find the file 'name.txt'.

Also, Read

• How to Solve “unhashable type: list” Error in Python
• How to solve Type error: a byte-like object is required not ‘str’
• Invalid literal for int() with base 10 | Error and Resolution
• How to Solve TypeError: ‘int’ object is not Subscriptable

This sums up everything about IOError Errno 2 No Such File Or Directory. If you have any questions, do let us know in the comments below.

Until then, Keep Learning!

In software development, different types of errors can occur. They could be syntax errors, logical errors, or runtime errors.

Syntax errors most probably occur during the initial development phase and are a result of incorrect syntax. Syntax errors can be caught easily when the program is compiled for execution.

Logical errors, on the other hand, are a result of improper logical implementation. An example would be a program accessing an unsorted list assuming it to be sorted. Logical errors are the most difficult ones to track.

Runtime errors are the most interesting errors which occur, if we don’t consider all the corner cases. An example would be trying to access a non-existent file.

• Handling Exceptions Using Try and Except
• Multiple Exceptions
• finally Clause
• User-Defined Exceptions
• Logging in Python
• Getting the Stack Trace

In this tutorial, we’ll learn how to handle errors in Python and how to log the errors for a better understanding of what went wrong in the application.

Handling Exceptions in Python

Let’s start with a simple program to add two numbers in Python. Our program takes in two parameters as input and prints the sum. Here is a Python program to add two numbers:

1

def addNumbers(a, b):

2

    print a + b

3

4

addNumbers(5, 10)

Try running the above Python program, and you should have the sum printed.

15

While writing the above program, we didn’t really consider the fact that anything can go wrong. What if one of the parameters passed is not a number?

We haven’t handled that case, hence our program would crash with the following error message:

1

Traceback (most recent call last):

2

  File "addNumber.py", line 4, in <module>

3

    addNumbers('', 10)

4

  File "addNumber.py", line 2, in addNumbers

5

    print a + b

6

TypeError: cannot concatenate 'str' and 'int' objects

We can handle the above issue by checking if the parameters passed are integers. But that won’t solve the issue. What if the code breaks down due to some other reason and causes the program to crash? Working with a program which crashes on being encountered with an error is not a good sight. Even if an unknown error is encountered, the code should be robust enough to handle the crash gracefully and let the user know that something is wrong.

Handling Exceptions Using try and except

In Python, we use the try and except statements to handle exceptions. Whenever the code breaks down, an exception is thrown without crashing the program. Let’s modify the add number program to include the try and except statements.

1

def addNumbers(a, b):

2

    try:

3

        return a + b

4

    except Exception as e:

5

        return 'Error occurred : ' + str(e)

6

7

print(addNumbers('', 10))

Python would process all code inside the try and except statement. When it encounters an error, the control is passed to the except block, skipping the code in between.

As seen in the above code, we have moved our code inside a try and except statement. Try running the program and it should throw an error message instead of crashing the program. The reason for the exception is also returned as an exception message.

The above method handles unexpected exceptions. Let’s have a look at how to handle an expected exception. Assume that we are trying to read a particular file using our Python program, but the file doesn’t exist. In this case, we’ll handle the exception and let the user know that the file doesn’t exist when it happens. Have a look at the file reading code:

1

try:

2

    try:

3

        with open('file.txt') as f:

4

            content = f.readlines()

5

    except IOError as e:

6

        print(str(e))

7

except Exception as e:

8

    print(str(e))

In the above code, we have handled the file reading inside an IOError exception handler. If the code breaks down because the file.txt is unavailable, the error would be handled inside the IOError handler. Similar to the IOError exceptions, there are a lot more standard exceptions like Arithmetic, OverflowError, and ImportError, to name a few.

Multiple Exceptions

We can handle multiple exceptions at a time by clubbing the standard exceptions as shown:

1

try:

2

    with open('file.txt') as f:

3

        content = f.readlines()

4

        print(content)

5

except (IOError,NameError) as e:

6

    print(str(e))

The above code would raise both the IOError and NameError exceptions when the program is executed.

finally Clause

Assume that we are using certain resources in our Python program. During the execution of the program, it encountered an error and only got executed halfway. In this case, the resource would be unnecessarily held up. We can clean up such resources using the finally clause. Take a look at the below code:

1

try:

2

    filePointer = open('file.txt','r')

3

    try:

4

        content = filePointer.readline()

5

    finally:

6

        filePointer.close()

7

except IOError as e:

8

    print(str(e))

If, during the execution of the above code, an exception is raised while reading the file, the filePointer would be closed in the finally block.

User-Defined Exceptions

So far, we have dealt with exceptions provided by Python, but what if you want to define your own custom exceptions? To create user-defined exceptions, you will need to create a class that inherits from the built-in Exception class. An advantage of creating user-defined exceptions is that they will make sense in our programs. For example, suppose you had a program that ensures that the discounted price of an item is not more than the sale price. Let’s create a custom exception for this type of error.

1

class PriceError(Exception):

2

    pass

Next, add the exception as follows:

1

def discount(price,discounted_price):

2

    if  discounted_price > price:

3

            raise PriceError

4

    else: 

5

        print("Discount applied")

In the code above, the raise statement forces the PriceError exception to occur.

Now, if you call the function with values where the disounted_price is greater than the price, you will get an error, as shown below.

1

Traceback (most recent call last):

2

  File "/home/vat/Desktop/errors.py", line 75, in <module>

3

    discount(100,110)

4

  File "/home/vat/Desktop/errors.py", line 70, in discount

5

    raise PriceError

6

__main__.PriceError

The error above does not provide a descriptive message; let’s customize it to give a detailed message of what the error means.

1

class PriceError(Exception):

2

   def __init__(self, price,discounted_price):

3

       self.price = price

4

       self.disounted_price = discounted_price

5

6

   def __str__(self):

7

        return 'Discounted price greater than price'

Now, let’s apply the error and call our function.

1

def discount(price,discounted_price):

2

    if  discounted_price > price:

3

            raise PriceError(price,discounted_price)

4

    else: 

5

        print("Discount applied")

6

7

discount(100,110)

Now, if you call the function, you will get the following error:

1

(base) vaati@vaati-Yoga-9-14ITL5:~/Desktop/EVANTO2022$ python3 errors.py 

2

Traceback (most recent call last):

3

  File "/home/vaati/Desktop/EVANTO2022/errors.py", line 84, in <module>

4

    discount(100,110)

5

  File "/home/vaati/Desktop/EVANTO2022/errors.py", line 79, in discount

6

    raise PriceError(price,discounted_price)

7

__main__.PriceError: Discounted price greater than price

Logging in Python

When something goes wrong in an application, it becomes easier to debug if we know the source of the error. When an exception is raised, we can log the required information to track down the issue. Python provides a simple and powerful logging library. Let’s have a look at how to use logging in Python.

1

try:

2

    logging.info('Trying to open the file')

3

    filePointer = open('file.txt','r')

4

    try:

5

        logging.info('Trying to read the file content')

6

        content = filePointer.readline()

7

        print(content)

8

    finally:

9

        filePointer.close()

10

except IOError as e:

11

    logging.error('Error occurred ' + str(e))

As seen in the above code, first we need to import the logging Python library and then initialize the logger with the log file name and logging level. There are five logging levels: DEBUG, INFO, WARNING, ERROR, and CRITICAL. Here we have set the logging level to INFO, so any message that has the level INFO will be logged.

Getting the Stack Trace

In the above code we had a single program file, so it was easier to figure out where the error had occurred. But what do we do when multiple program files are involved? In such a case, getting the stack trace of the error helps in finding the source of the error. The stack trace of the exception can be logged as shown:

1

import logging

2

3

# initialize the log settings

4

logging.basicConfig(filename = 'app.log', level = logging.INFO)

5

6

try:

7

    filePointer = open('appFile','r')

8

    try:

9

        content = filePointer.readline()

10

    finally:

11

        filePointer.close()

12

except IOError as e:

13

    logging.exception(str(e))

If you try to run the above program, on raising an exception the following error would be logged in the log file:

1

ERROR:root:[Errno 2] No such file or directory: 'appFile'

2

Traceback (most recent call last):

3

  File "readFile.py", line 7, in <module>

4

    filePointer = open('appFile','r')

5

IOError: [Errno 2] No such file or directory: 'appFile'

Wrapping It Up

In this tutorial, we saw how to get started with handling errors in Python and using the logging module to log errors. We saw the usage of try, except, and finally statements, which are quite useful when dealing with error handling in Python. For more detailed information, I would recommend reading the official documentation on logging. Also have a look at the documentation for handling exceptions in Python.

This post has been updated with contributions from Esther Vaati. Esther is a software developer and writer for Envato Tuts+.

Did you find this post useful?

I’m a software engineer by profession and love to write tutorials and educational stuff.

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

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

Стандартные исключения

Ниже приведен список стандартных исключений доступных в Python:

Утверждения в Python

Утверждение является осознанной проверкой, которую вы можете включить или выключить, когда вы проводите тестирование программы.

• Самый простой способ создать утверждение, является приравнять его к заявление raise-if (или быть более точным, заявление raise-if-not). Выражение проверяется, и если результат приходит ложным, возбуждается исключение.
• Утверждения выполняются оператором assert, новейшим ключевым словом Python, введенным в версии 1.5.
• Программисты часто размещают утверждения в начале функции для проверки допустимого ввода и после вызова функции для проверки допустимого вывода.

Заявление assert

Когда встречается оператор assert, Python оценивает сопровождающие выражение, которое, мы надеемся, верно. Если выражение ложно, Python вызывает исключение AssertionError.

Синтаксис assert:

assert Expression[, Аргументы]

Если утверждение не удается, Python использует ArgumentExpression в качестве аргумента для AssertionError. Исключение AssertionError может быть перехвачено и обработано, как и любое другое исключение, используя заявление try-except. Если они не обработаны, они завершат программу и произведут обратную трассировку.

Пример

Вот функция, которая преобразует заданную температуру от градусов Кельвина до градусов по Фаренгейту. Так как 0° К это абсолютный 0, то получается, что функция вываливается, если он видит отрицательную температуру:

#!/usr/bin/python3
def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Холоднее абсолютного нуля!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

Когда этот код выполниться, он выдаст следующий результат:

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Холоднее абсолютного нуля!"
AssertionError: Холоднее абсолютного нуля!

Что такое исключение?

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

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

Обработка исключения

Если у вас есть какой-то подозрительный код, который может вызвать исключение, вы можете защитить свою программу путем размещения подозрительного кода в блоке try:. Блок try: включает в себя, заявление except:, следует блок кода, который обрабатывает проблему как можно элегантнее.

Синтаксис

Вот простой синтаксис блоков try….except…else:

try:
   Вы делаете свою работу
   ......................
except ExceptionI:
   Если есть ExceptionI, то выполняется этот блок.
except ExceptionII:
   Если есть ExceptionII, то выполняется этот блок.
   ......................
else:
   Если исключений нет, выполняется этот блок.

Вот несколько важных моментов, о вышеупомянутом синтаксисе:

• Один оператор может попытаться иметь несколько заявлений. Это полезно, когда блок попытка содержит заявления, которые могут бросить различные типы исключений.
• Кроме того, можно предоставить универсальное предложение, которое обрабатывает любое исключение.
• После класса except, можно добавить класс else. Код else-block выполниться, если код в блоке try: не вызывает исключение.
• else-block является хорошим местом для кода, который не нужно попробовать: защита блока.

Пример

Этот пример открывает файл, записывает содержимое в файл и выходит корректно, потому что нет никаких проблем:

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("Это мой тестовый файл для обработки исключений!!")
except IOError:
   print ("Ошибка: не удается найти файл или прочитать данные")
else:
   print ("Запись содержимого в файл произведена успешно")
   fh.close()

Данный код выдаст следующий результат:

Запись содержимого в файл произведена успешно

Пример

В этом примере попытаемся открыть файл, в котором у вас нет разрешения на запись, поэтому он вызывает исключение:

#!/usr/bin/python3

try:
   fh = open("testfile", "r")
   fh.write("Это мой тестовый файл для обработки исключений!!")
except IOError:
   print ("Ошибка: не удается найти файл или прочитать данные")
else:
   print ("Запись содержимого в файл произведена успешно")

Данный код выдаст следующий результат:

Ошибка: не удается найти файл или прочитать данные

Класс except без исключений

Вы можете также использовать заявление except без каких-либо исключений, определенных следующим образом:

try:
   Вы делаете свою работу
   ......................
except:
   Если есть какие-либо исключения, то выполняется этого блока.
   ......................
else:
   Если исключений нет, выполняется этот блок.

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

Класс except с несколькими исключениями

Вы также можете использовать заявление except, для обработки нескольких исключений следующим образом:

try:
   Вы делаете свою работу
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   Если есть какое-либо исключение из данного списка исключений, 
   то выполняется этот блок.
   ......................
else:
   Если исключений нет, выполняется этот блок.

Класс try-finally

Вы можете использовать блок finally: вместе с блоком try:. Блок finally: представляет собой место, куда можно поместить любой код, который должен выполнится, вызовет ли блок try исключение или нет. Синтаксис заявление try-finally следующий:

try:
   Вы делаете свою работу;
   ......................
   Из-за каких-либо исключений, это может быть пропущено.
finally:
   Это всегда будет исполнено.
   ......................

Пример

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("Это мой тестовый файл для обработки исключений!!")
finally:
   print ("Ошибка: не удается найти файл или прочитать данные")
   fh.close()

Если у вас нет разрешения на открытие файла в режиме записи, то это приведет к следующему результату:

Ошибка: не удается найти файл или прочитать данные

Тот же пример можно записать более аккуратно следующим образом:

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   try:
      fh.write("Это мой тестовый файл для обработки исключений!!")
   finally:
      print ("Собираюсь закрыть файл")
      fh.close()
except IOError:
   print ("Ошибка: не удается найти файл или прочитать данные")

Когда исключение в блоке try выполниться, немедленно переходит к блоку finally. После того как все операторы в блоке finally выполнятся, то возбуждается исключение снова и обрабатывается заявление except, если присутствует в следующем более высокого уровня заявление try-except.

Аргумент в исключении

Исключение может иметь argument, который является значением, которое дает дополнительную информацию о проблеме. Содержание аргумента зависит от исключения. Вы фиксируете аргумент исключения, предоставляя переменную в предложении except следующим образом:

try:
   Вы делаете свою работу
   ......................
except ExceptionType as Argument:
   Значение аргумента можно напечатать здесь...

Если вы пишете код для обработки исключения, вы можете указать переменную, следующую за именем исключения в предложении except. Если вы перехватываете несколько исключений, вы можете иметь переменную в виде кортежа с исключениями.

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

Пример

Ниже приведен пример для одного исключения:

#!/usr/bin/python3

# Определить функцию.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("Аргумент не содержит чиселn", Argument)

# Вызов функции выше здесь.
temp_convert("xyz")

Данный код выдаст следующий результат:

Аргумент не содержит чисел
invalid literal for int() with base 10: 'xyz'

Исключение raise

Вы можете вызвать исключения несколькими способами, используя оператор raise. Общий синтаксис для заявления raise выглядит следующим образом:

Синтаксис

raise [Exception [, args [, traceback]]]

Здесь Exception представляет собой тип исключения (например, NameError) и arg является значением для аргумента исключения. Аргумент является необязательным; если не прилагается, аргумента в исключении нет.

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

Пример

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

def functionName( level ):
   if level <1:
      raise Exception(level)
      # Приведенный ниже код не будет выполнен
      # если мы вызовем исключение
   return level

Например, чтобы захватить исключение выше, мы должны написать пункт except следующим образом:

try:
   Бизнес-логика здесь...
except Exception as e:
   Обработка исключений здесь e.args...
else:
   Остальная часть кода здесь...

Следующий пример иллюстрирует использование средств исключения:

#!/usr/bin/python3
def functionName( level ):
   if level <1:
      raise Exception(level)
      # Приведенный ниже код не будет выполнен
      # если мы вызовем исключение
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("ошибка в аргументе уровня",e.args[0])

Это выдаст следующий результат:

ошибка в аргументе уровня -10

Исключения определенные пользователем

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

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

В блоке try , определенный пользователем возбуждаются исключение и ловится за блоком except. Переменная е используются для создания экземпляра класса NetworkError.

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Поэтому, как только вы определили класс выше, вы можете вызвать исключение следующим образом:

try:
   raise Networkerror("Плохое имя хоста")
except Networkerror,e:
   print e.args