Error running питон

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

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

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

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

Ошибки могут быть разных видов:

• Синтаксические
• Недостаточно памяти
• Ошибки рекурсии
• Исключения

Разберем их по очереди.

Синтаксические ошибки (SyntaxError)

Синтаксические ошибки часто называют ошибками разбора. Они возникают, когда интерпретатор обнаруживает синтаксическую проблему в коде.

Рассмотрим на примере.

a = 8
b = 10
c = a b

File "", line 3
 c = a b
       ^
SyntaxError: invalid syntax

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

Недостаточно памяти (OutofMemoryError)

Ошибки памяти чаще всего связаны с оперативной памятью компьютера и относятся к структуре данных под названием “Куча” (heap). Если есть крупные объекты (или) ссылки на подобные, то с большой долей вероятности возникнет ошибка OutofMemory. Она может появиться по нескольким причинам:

• Использование 32-битной архитектуры Python (максимальный объем выделенной памяти невысокий, между 2 и 4 ГБ);
• Загрузка файла большого размера;
• Запуск модели машинного обучения/глубокого обучения и много другое;

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

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc()), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Ошибка рекурсии (RecursionError)

Эта ошибка связана со стеком и происходит при вызове функций. Как и предполагает название, ошибка рекурсии возникает, когда внутри друг друга исполняется много методов (один из которых — с бесконечной рекурсией), но это ограничено размером стека.

Все локальные переменные и методы размещаются в стеке. Для каждого вызова метода создается стековый кадр (фрейм), внутрь которого помещаются данные переменной или результат вызова метода. Когда исполнение метода завершается, его элемент удаляется.

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

def recursion():
    return recursion()

recursion()

---------------------------------------------------------------------------

RecursionError                            Traceback (most recent call last)

 in 
----> 1 recursion()


 in recursion()
      1 def recursion():
----> 2     return recursion()


... last 1 frames repeated, from the frame below ...


 in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

Ошибка отступа (IndentationError)

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

Пример:

for i in range(10):
    print('Привет Мир!')

  File "", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

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

Программы обычно не обрабатывают исключения, что приводит к подобным сообщениям об ошибке:

Ошибка типа (TypeError)

a = 2
b = 'PythonRu'
a + b

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 a = 2
      2 b = 'PythonRu'
----> 3 a + b


TypeError: unsupported operand type(s) for +: 'int' and 'str'

Ошибка деления на ноль (ZeroDivisionError)

10 / 0

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

 in 
----> 1 10 / 0


ZeroDivisionError: division by zero

Есть разные типы исключений в Python и их тип выводится в сообщении: вверху примеры TypeError и ZeroDivisionError. Обе строки в сообщениях об ошибке представляют собой имена встроенных исключений Python.

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

Теперь рассмотрим встроенные исключения Python.

Встроенные исключения

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

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

• Try: он запускает блок кода, в котором ожидается ошибка.
• Except: здесь определяется тип исключения, который ожидается в блоке try (встроенный или созданный).
• Else: если исключений нет, тогда исполняется этот блок (его можно воспринимать как средство для запуска кода в том случае, если ожидается, что часть кода приведет к исключению).
• Finally: вне зависимости от того, будет ли исключение или нет, этот блок кода исполняется всегда.

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

Ошибка прерывания с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt вызывается при попытке остановить программу с помощью сочетания Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобных ситуаций.

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

try:
    inp = input()
    print('Нажмите Ctrl+C и прервите Kernel:')
except KeyboardInterrupt:
    print('Исключение KeyboardInterrupt')
else:
    print('Исключений не произошло')

Исключение KeyboardInterrupt

Стандартные ошибки (StandardError)

Рассмотрим некоторые базовые ошибки в программировании.

Арифметические ошибки (ArithmeticError)

• Ошибка деления на ноль (Zero Division);
• Ошибка переполнения (OverFlow);
• Ошибка плавающей точки (Floating Point);

Все перечисленные выше исключения относятся к классу Arithmetic и вызываются при ошибках в арифметических операциях.

Деление на ноль (ZeroDivisionError)

Когда делитель (второй аргумент операции деления) или знаменатель равны нулю, тогда результатом будет ошибка деления на ноль.

try:  
    a = 100 / 0
    print(a)
except ZeroDivisionError:  
    print("Исключение ZeroDivisionError." )
else:  
    print("Успех, нет ошибок!")

Исключение ZeroDivisionError.

Переполнение (OverflowError)

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

try:  
    import math
    print(math.exp(1000))
except OverflowError:  
    print("Исключение OverFlow.")
else:  
    print("Успех, нет ошибок!")

Исключение OverFlow.

Ошибка утверждения (AssertionError)

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Рассмотрим пример. Предположим, есть две переменные: a и b. Их нужно сравнить. Чтобы проверить, равны ли они, необходимо использовать ключевое слово assert, что приведет к вызову исключения Assertion в том случае, если выражение будет ложным.

try:  
    a = 100
    b = "PythonRu"
    assert a == b
except AssertionError:  
    print("Исключение AssertionError.")
else:  
    print("Успех, нет ошибок!")

Исключение AssertionError.

Ошибка атрибута (AttributeError)

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

class Attributes(obj):
    a = 2
    print(a)

try:
    obj = Attributes()
    print(obj.attribute)
except AttributeError:
    print("Исключение AttributeError.")

2
Исключение AttributeError.

Ошибка импорта (ModuleNotFoundError)

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

import nibabel

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

 in 
----> 1 import nibabel


ModuleNotFoundError: No module named 'nibabel'

Ошибка поиска (LookupError)

LockupError выступает базовым классом для исключений, которые происходят, когда key или index используются для связывания или последовательность списка/словаря неверна или не существует.

Здесь есть два вида исключений:

• Ошибка индекса (IndexError);
• Ошибка ключа (KeyError);

Ошибка ключа

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

try:  
    a = {1:'a', 2:'b', 3:'c'}  
    print(a[4])  
except LookupError:  
    print("Исключение KeyError.")
else:  
    print("Успех, нет ошибок!")

Исключение KeyError.

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

try:
    a = ['a', 'b', 'c']  
    print(a[4])  
except LookupError:  
    print("Исключение IndexError, индекс списка вне диапазона.")
else:  
    print("Успех, нет ошибок!")

Исключение IndexError, индекс списка вне диапазона.

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

Ошибка имени возникает, когда локальное или глобальное имя не находится.

В следующем примере переменная ans не определена. Результатом будет ошибка NameError.

try:
    print(ans)
except NameError:  
    print("NameError: переменная 'ans' не определена")
else:  
    print("Успех, нет ошибок!")

NameError: переменная 'ans' не определена

Ошибка выполнения (Runtime Error)

Ошибка «NotImplementedError»
Ошибка выполнения служит базовым классом для ошибки NotImplemented. Абстрактные методы определенного пользователем класса вызывают это исключение, когда производные методы перезаписывают оригинальный.

class BaseClass(object):
    """Опередляем класс"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
	# функция ничего не делает
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Реализует функцию"""
    def do_something(self):
        # действительно что-то делает
        print(self.__class__.__name__ + ' что-то делает!')

SubClass().do_something()
BaseClass().do_something()

SubClass что-то делает!



---------------------------------------------------------------------------

NotImplementedError                       Traceback (most recent call last)

 in 
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


 in do_something(self)
      5     def do_something(self):
      6         # функция ничего не делает
----> 7         raise NotImplementedError(self.__class__.__name__ + '.do_something')
      8
      9 class SubClass(BaseClass):


NotImplementedError: BaseClass.do_something

Ошибка типа (TypeError)

Ошибка типа вызывается при попытке объединить два несовместимых операнда или объекта.

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

try:
    a = 5
    b = "PythonRu"
    c = a + b
except TypeError:
    print('Исключение TypeError')
else:
    print('Успех, нет ошибок!')

Исключение TypeError

Ошибка значения (ValueError)

Ошибка значения вызывается, когда встроенная операция или функция получают аргумент с корректным типом, но недопустимым значением.

В этом примере встроенная операция float получат аргумент, представляющий собой последовательность символов (значение), что является недопустимым значением для типа: число с плавающей точкой.

try:
    print(float('PythonRu'))
except ValueError:
    print('ValueError: не удалось преобразовать строку в float: 'PythonRu'')
else:
    print('Успех, нет ошибок!')

ValueError: не удалось преобразовать строку в float: 'PythonRu'

Пользовательские исключения в Python

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

class UnAcceptedValueError(Exception):   
    def __init__(self, data):    
        self.data = data
    def __str__(self):
        return repr(self.data)

Total_Marks = int(input("Введите общее количество баллов: "))
try:
    Num_of_Sections = int(input("Введите количество разделов: "))
    if(Num_of_Sections < 1):
        raise UnAcceptedValueError("Количество секций не может быть меньше 1")
except UnAcceptedValueError as e:
    print("Полученная ошибка:", e.data)

Введите общее количество баллов: 10
Введите количество разделов: 0
Полученная ошибка: Количество секций не может быть меньше 1

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

Недостатки обработки исключений в Python

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

Дальше пример, где модуль Python timeit используется для проверки времени исполнения 2 разных инструкций. В stmt1 для обработки ZeroDivisionError используется try-except, а в stmt2 — if. Затем они выполняются 10000 раз с переменной a=0. Суть в том, чтобы показать разницу во времени исполнения инструкций. Так, stmt1 с обработкой исключений занимает больше времени чем stmt2, который просто проверяет значение и не делает ничего, если условие не выполнено.

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

import timeit
setup="a=0"
stmt1 = '''
try:
    b=10/a
except ZeroDivisionError:
    pass'''

stmt2 = '''
if a!=0:
    b=10/a'''

print("time=",timeit.timeit(stmt1,setup,number=10000))
print("time=",timeit.timeit(stmt2,setup,number=10000))

time= 0.003897680000136461
time= 0.0002797570000439009

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

Pycharm выдает ошибку «не удается найти модуль __main__» »

Установите Python, Numpy, Matplotlib, Scipy в Windows

Всякий раз, когда я пытаюсь запустить скрипт через Virtualenv в pycharm, я получаю такую ​​ошибку:

Все работает нормально через idle или vs code. Я полагаю, что это должно быть что-то с тем, как я настроил свой pycharm, но понятия не имею, что.

edit: это происходит независимо от того, что я запускаю, даже с простой функцией печати.

изменить: даже при выборе обычного интерпретатора Python, то же самое происходит только в pycharm

• 3 Можете ли вы показать нам свой код?
• Что бы я ни бегал. Даже пробовал простую печать («бла бла») prntscr.com/kn60cu
• 1 Как вы запускаете код? Это не похоже на файл Python, он не заканчивается на .py
• Он заканчивается на py, и это файл python, вы можете видеть, что он заканчивается на test.py и значок python рядом с файлом. Разобрался в чем дело, отправил ответ. спасибо, ребята

Разобрался в чем дело. В окне конфигурации в pycharm мне нужно было выбрать правильный путь к скрипту:

• 2 Путь к сценарию вводит в заблуждение (ИМХО), поскольку он также должен включать файл сценария.

В вашем Pycharm:

1. Выбрать Run — Edit Configurations
2. В Configuration tabs , Выбрать Module name в опции Choose target to run и введите имя вашего файла python
3. Нажмите Apply а также OK кнопка

Или простой способ — когда вы запускаете свой код в первый раз (в новом файле), просто введите клавиатуру Alt+Shift+F10 для запуска и сохранения конфигурации. Во второй раз (после сохранения конфигурации) просто введите Alt+F10 для запуска вашего кода.

• также называется «путь к сценарию»

Перейдите в «Редактировать конфигурацию» и укажите только свое имя файла, например filename.py

Существующий путь ——> C:Usersnp4PycharmProjectsTESTvenv

Попробуйте с этим ——> C:Usersnp4PycharmProjectsTESTvenvMultiSites.py

Я столкнулся с этой проблемой, когда мой cmd был вынужден «Завершить задачу» диспетчером задач. Моя проблема решена, когда я перезапускаю свою IDE.

«Открыть диалоговое окно« Редактировать настройки запуска / отладки »» (вверху, рядом с «Выполнить») «Изменить конфигурации» «Путь к сценарию:» -> выберите правильный путь к сценарию.

В Pycharm (Ubuntu):

1. Создать новый проект
2. Дайте название проекта
3. Щелкните правой кнопкой мыши папку bin
4. Создать новый файл Python
5. Напишите свой код
6. Верхняя правая сторона: Добавить конфигурацию
7. Левая сторона: щелкните правой кнопкой мыши знак «+»
8. Введите полное имя файла
9. Home / Downloads / myfile.py как «Путь к сценарию»
10. python 2.x / 3.x как интерпретатор Python
11. Нажмите «Применить / ОК»

Я исправил это, удалив значения из Возможности переводчика в конфигурациях запуска / отладки. Пытаясь добавить интерпретатор, я добавил путь Python к указанному полю.

После расчистки поля все наладилось.

Ты можешь найти run/debug configuration настройки в раскрывающемся списке слева от значка запуска в правом верхнем углу окна pycharm.

Источник

How to fix python can’t find ‘__main__’ module error in easy 2 ways?

Python can’t find ‘__main__’ module is one of the most common errors that can occur when running a Python script. We’ll cover why this error occurs and provide two different code examples that demonstrate how it can happen. We’ll also show you how to fix the error so that you can continue developing your web applications with Python.

What is __main__ in python?

__main__ is a special name in Python that is used to indicate the source file where the program execution starts. Every Python program has a ‘__main__’ module, and the code within that module is executed when the program is run. The ‘__main__’ module can be located in any file, but it is typically placed in a file named ‘ main.py ‘.

For example, consider the following ‘main.py’ file:

When this program is run, the output will be as follows:

Why does the error occur?

There are two main reasons why the python can’t find ‘__main__’ module error might occur. The first reason is that you haven’t specified the main module in your Python script. The second reason is that your main module is not located in the same directory as your Python script. We’ll discuss each of these reasons in more detail below.

Code example 1

Let’s say you have a Python script named my_script.py and it contains the following code:

If you try to run this script, you’ll get the python can’t find ‘__main__’ module error

This is because we haven’t specified the main module in our script. Python will look for a module named __main__ and, if it can’t find one, it will throw an error. To fix this, we need to add the main module to our script. We can do this by wrapping our code in an if __name__ == «__main__»: block:

Now when we run our script, we get the expected output:

Code example 2

Let’s say you have a Python script named my_script.py and it contains the following code:

And you also have a Python module named some_module.py that contains the following code:

If you try to run my_script.py , you’ll get the following error:

This is because your main module ( my_script.py ) is not located in the same directory as your Python script. When Python tries to import some_module , it will look for it in the current directory (the directory where my_script.py is located). Since it can’t find it there, it will throw an error. You can fix this by moving your Python script to the same directory as your main module:

Now when you run my_script.py , it will be able to find and import some_module.py without any problems.

How to fix the python can’t find ‘__main__’ module error?

As we’ve seen in the examples above, there are two ways to fix the “python can’t find ‘__main__’ module” error. The first way is to add the main module to your Python script. The second way is to move your Python script to the same directory as your main module. Below, we’ll go through both of these strategies in further depth.

Add the main module to your script

If you get this error, it means that you haven’t specified the main module in your Python script. You can fix this by wrapping your code in an if __name__ == «__main__»: block:

When you run your script, Python will look for a module named __main__ and, if it can’t find one, it will throw an error. This block of code will ensure that Python can find your main module and avoid errors like python can’t find ‘__main__’ module

Move your script to the same directory as your main module

If you get this error, it means that your main module is not located in the same directory as your Python script. You can fix this by moving your Python script to the same directory as your main module:

When you run your Python script, it will look for modules in the current directory (the directory where my_script.py is located). By moving my_script.py to the same directory as we’re ensuring that our script can find all of the modules it needs.

Conclusion

In this article, we’ve discussed the “ python can’t find ‘__main__’ module ” error. We’ve seen two different code examples that demonstrate how this error can occur. And we’ve also shown you how to fix the error by either adding the main module to your script or moving your script to the same directory as your main module so that you can continue developing your web applications.

Источник

Python Error Can’t Find Main Module

In this article, we’ll discuss the error can’t find ‘__main__’ module , the causes of it, and how to resolve the error in Python.

Resolve the can’t find ‘__main__’ module Error in Python

We wrote a simple code to print in the PyCharm environment. As we see in the top right corner, the play button or running button is disabled, which means there is no way to run this code.

To be able to read this code, we need to add a configuration or add an interpreter, and then it gives us an execution. But if we click the play button, the program does not run.

The problem is that we don’t have an interpreter to run the codes on PyCharm, or we get an error when running the created interpreter. In our case, we created an interpreter, but still, the code doesn’t run.

So what caused the issue? The first reason is there is no virtual environment, and the second is the Python interpreter cannot find the project folder.

We need to check if we have installed Python on our system to resolve this issue. In the next step, we create a virtual environment for our project and specify the Python file we want to read.

To check the Python is installed or not, we open our terminal and type “python” and hit enter if you have Python installed on your system, it gives you the version of Python, and if nothing pops up, that means you do not have Python installed on our system. You need to download Python from here.

Let’s create a virtual environment for our project and create an empty folder. After that, we go to the PyCharm environment to delete the interpreter.

1. Click on the top-left corner file.
2. Go to settings. It will open up a project for you and then go to your project.
3. We click on the plus( + ) button where we specifically tell the machine where we want to create our virtual environment.
4. Once the virtual environment is created, you must select it.
5. Click «OK» then «Apply» .

In the next step, we will add configuration.

1. For our project, click on add configuration .
2. Click on add new and select Python .
3. After opening a new window, look at the script path where we have to select our project file, so you have to go through your project or wherever you saved your folder.
4. Once you pick up the script path or the project file, it will automatically pick up the working directory. If it doesn’t, just click on the folder, go to the project folder, and pick it up yourself.
5. Then click «Apply» and «OK» .
6. We will run the code to see if everything is working fine. Click on the play button, and the code is executed successfully here.

To make it short, when you get the can’t find ‘__main__’ module error in Python. We resolve it by doing the following:

1. Adding the main module to your script.
2. Moving your script to the same directory as your main module.

Conclusion

We’ve discussed in this article how to resolve the can’t find ‘__main__’ module error in Python.

Hello! I am Salman Bin Mehmood(Baum), a software developer and I help organizations, address complex problems. My expertise lies within back-end, data science and machine learning. I am a lifelong learner, currently working on metaverse, and enrolled in a course building an AI application with python. I love solving problems and developing bug-free software for people. I write content related to python and hot Technologies.

Источник

Работа с ошибками в Python

Заголовок

Создайте файл solution.py со следующим кодом:

Наш код подразумевает печать содержимого переменной vector.

Запустим написанный скрипт, получим следующий вывод:

Сообщение означает, что при исполнении кода возникла ошибка. При этом Python сообщает нам кое-что ещё. Разберём это сообщение детально.

Чтение Traceback 1

Исходное сообщение нужно мысленно разделить на две части. Первая часть это traceback-сообщение:

Вторая часть — сообщение о возникшей ошибке:

Разберём первую часть. Traceback в грубом переводе означает «отследить назад». Traceback показывает последовательность/стэк вызовов, которая, в конечном итоге, вызвала ошибку.

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

Вторая и третья строки:

показывают информацию о вызове (в нашем случае он один). Во-первых, здесь есть информация о файле, в котором произошёл вызов («solution.py»), затем указан номер строки, где этот вызов происходит («line 1″), в конце стоит информация о том, откуда произошёл вызов (» «). В нашем случае вызов происходит непосредственно из модуля, т.е. не из функции. Наконец, вывод содержит не только номер строки, но и саму строку «for coord in vector:».

Заключительная строка сообщения:

содержит вид (тип) ошибки («NameError»), и после двоеточия содержит подсказку. В данном случае она означает, что имя «vector» не определено.

В самом деле, если взглянуть снова на код, то можно убедиться, что мы нигде не объявили переменную «vector».

Подведём итоги. При попытке запуска мы получили следующий вывод

Он говорит нам о возникновении ошибки. Эта ошибка обнаружилась интерпретатором в первой строке файла «solution.py». Сама ошибка является ошибкой имени и указывает на необъявленное имя — «vector».

Чтение Traceback 2

Оберните код из solution.py в функцию:

Запустим наш код

На этот раз сообщение об ошибке сложнее, однако структура у него та же.

Часть со стеком вызовов увеличилась:

Поскольку «most recent call last», читать будем её сверху вниз.

Вызовов на этот раз два. Первый вызов:

Произошел в пятой строке. Судя по строчке кода, это вызов написанной нами функции print_vector(5) с аргументом 5.

Следом за ней второй вызов:

Этот вызов происходит внутри функции print_vector, содержащейся в файле «solution.py». Вызов находится в строке 2.

Сама же ошибка имеет вид:

Как и в первом примере, сообщение об ошибке содержит её тип и подсказку. В нашем случае произошла ошибка типа. В подсказке же указано, что объект типа int не является итерируемым, т.е. таким объектом, который нельзя использовать в цикле for.

В нашем коде возникла ошибка. Её вызвала последовательность вызовов. Первый вызов произошел непосредственно из модуля — в строке 5 происходит вызов функции print_vector(5). Внутри этой функции ошибка возникла в строчке 2, содержащей проход по циклу. Сообщение об ошибке означает, что итерироваться по объекту типа int нельзя. В нашем случае мы вызвали функцию print_vector от числа (от 5).

Некоторые ошибки с примерами кода

Ошибки в синтаксисе

Наиболее частая ошибка, которая возникает в программах на Python — SyntaxError: когда какое-то утверждение записано не по правилам языка, например:

Тот же тип ошибки возникнет, если забыть поставить двоеточие в цикле:

При неправильном использовании пробелов и табуляций в начале строки возникает IndentationError:

А теперь посмотрим, что будет, если в первой строке цикла воспользоваться пробелами, а во второй — табуляцией:

NameError возникает при обращении к несуществующей переменной:

Ошибки в логике

Напишем простую программу на деление с остатком и сохраним как sample.py:

Возникла ошибка TypeError, которая сообщает о неподходящем типе данных. Исправим программу:

запустим на неподходящих данных:

Возникнет ValueError. Эту ошибку ещё можно воспринимать как использование значения вне области допустимых значений (ОДЗ).

Теперь запустим программу на числовых данных:

При работе с массивами нередко возникает ошибка IndexError. Она возникает при выходе за пределы массива:

Что будет, если вызвать бесконечную рекурсию? Опишем её в программе endless.py

Через некоторое время после запуска возникнет RecursionError:

Источник

Python-tutorial

Handling Errors in Python

So we have scripts which run just fine as long as the information we give them is what they expect. Errors appear when the script/program encounters conditions it does not know how to handle. This is not as scary as it sounds and it is very nice to have scripts which you can feel confident are not going to “crash” as soon as someone else tries to use them.

What can go wrong?

Running your script on your own system may be working perfectly but is it also going to work on another system?

A brief list of what can commonly go wrong:

1. Syntax errors such as typos or incorrect arguments
2. Files needed by the script can’t be found or accessed
3. A list created dynamically may not get created at all or items in the list expected at a certain index (location) are missing
4. Values passed in as arguments may not be what was expected by the script

Syntax errors

As you create your script, it is very common to have syntax errors, that is, typos, incorrectly named methods or passing in the wrong number of arguments to a method. Catching these early is easier with an editor like Spyder.

1. Run the following code and see the error — also note how Spyder highlights the problem.

if (1 == 1)
    print("This is a syntax error")

You should see an output showing that something is missing (what should this be?):

if (1 == 1)
               ^
SyntaxError: invalid syntax

Syntax errors will prevent the code from running in the first place. Errors which only appear when your program is running are known as “Runtime Errors”. We will now see how to deal with this.

Catching errors

Fortunately, we can catch these errors and then do something about them before they abruptly end our program.
The structure is a “try-except-finally” block of code which is wrapped around your code.

try:
  prnt("This is a name error")  #misspelt print so no method found
except NameError as e:
  print("Caught this error:", e)
finally:
  print("I'm always going to run this bit")

The finally section is optional

“Continue anyway” errors

When running in a loop and the error is minor, such as the first line in a text file is blank and you just want to skip it, use continue in the except block to tell the program to go to the next instruction.

“Stop running if this occurs” errors

When running in a loop and the error is major and you cannot continue without the information:

1. use break and the loop will end
2. use pass and the program will pass to the next instruction
3. sys.exit() exit() quit() and os._exit(0) will kill the Python interpreter so avoid if possible or at least use with caution

Reading Files

So, we will see how to put this in a script which reads the gapminder data as we have done in previous lessons.
Files can be missing or not accessible so we will include error catching to notify us of these problems.

Previously:

import pandas

data = pandas.read_csv('data/gapminder_gdp_oceania.csv')
print(data)

1. We will change the hard-coded filename to variables
2. We will also use variable called sep from a library called os which separates filenames according to operating system so this code can be run on Mac, Unix or Windows

import pandas
from os import sep

filename = datadir + sep + fname
data = pandas.read_csv(filename)
print(data)

1. Now put the code in a try: block

import pandas
from os import sep

inputdir = "data"
fname = "gapminder_gdp_oceania.csv"

try:
    filename = inputdir + sep + fname
    data = pandas.read_csv(filename)
    if (not data.empty):
       print(data.iloc[0, 0])

except OSError as e:
    print("ERROR: Unable to find or access file:", e)
    pass

Looping through a directory

Often, you will be using a Python script to read files in a directory.

1. We will add a loop for our files:

inputdir = "data"

try:
    for fname in listdir(inputdir):
        print(fname)
        filename = inputdir + sep + fname
        data = pandas.read_csv(filename)
        if (not data.empty):
           print(data.iloc[0, 0])

except OSError as e:
    print("ERROR: Unable to find or access file:", e)
    pass

Making a dynamic script

Finally, we will allow the directory to be loaded from outside the script.

1. Now we will incorporate our argument parser from the previous lesson so the directory can be specified when we run the script rather than having to change the code
2. Don’t forget the special line if __name__ == '__main__': so we can run from the terminal console

import pandas
import argparse
from os import sep, listdir

if __name__ == '__main__':
  parser = argparse.ArgumentParser(prog='Read CSV Files',
                                  description='''Reads a directory and extracts first cell from each file''')
  parser.add_argument('--filedir', action='store', help='Directory containing files', default="data")

  args = parser.parse_args()
  inputdir = args.filedir

  try:
      for fname in listdir(inputdir):
          print(fname)
          filename = inputdir + sep + fname
          data = pandas.read_csv(filename)
          if (not data.empty):
             print(data.iloc[0, 0])

  except OSError as e:
      print("ERROR: Unable to find or access file:", e)
      pass

Challenge

Take this one step further and put your code into methods.

Challenge

Combine all our csv files into an excel file.

TIPS

1. The glob library is very good at filtering files from a directory based on their filenames. For example, selecting all CSV files, or all files with numbers in the filename.
   • files = glob.glob('data/*.csv') — the data directory can be replaced by an argument
2. Pandas has a method to write to an Excel file called to_excel and you will need a special file writer called ExcelWriter from the pandas library
   • writer = pandas.ExcelWriter(outputfile, engine='xlsxwriter') — sets up the file writer
   • (fsheet, _) = splitext(basename(f2)) — extract just the filename from the file using basename() from os.path library
   • data.to_excel(writer, sheet_name=fsheet) — write the data to the writer with an Excel sheet named as the filename

import argparse
import glob
from os import sep, listdir, R_OK, access
from os.path import join, basename, splitext

import pandas

if __name__ == "__main__":
    parser = argparse.ArgumentParser(prog='Combine CSV files to an Excel file',
                                     description='''
            Reads a directory and combines csv files into an excel file

             ''')
    parser.add_argument('--filedir', action='store', help='Directory containing files', default="data")
    parser.add_argument('--output', action='store', help='Output file name', default="output.xlsx")

    args = parser.parse_args()

    inputdir = args.filedir
    outputfile = args.filedir + sep + args.output

    print("Input directory:", inputdir)
    if access(inputdir, R_OK):
        seriespattern = '*.csv'
        writer = pandas.ExcelWriter(outputfile, engine='xlsxwriter')
        try:
            files = glob.glob(join(inputdir, seriespattern))
            print("Files:", len(files))
            for f2 in files:
                print(f2)
                (fsheet, _) = splitext(basename(f2))
                data = pandas.read_csv(f2)
                if (not data.empty):
                    data.to_excel(writer, sheet_name=fsheet)
            print("Files combined to: ", outputfile)

        except ValueError as e:
            print("ERROR: ", e)

        except OSError as e:
            print("ERROR: Unable to find or access file:", e)
            pass
        finally:
            writer.save()
            writer.close()
    else:
        print("Cannot access directory: ", inputdir)

As you do more and more programming, you will naturally encounter a lot of errors (or bugs). Causing, understanding, and fixing errors is an important part of programming. Python will do its best to run anything that you tell it to run, but if it can’t understand what you’re asking, then it won’t run the program. All the same, Python will try to tell you a little bit of information about what went wrong, in order to help you try to fix it.

Here are two Python errors.

In this first example, we forget to use the parenthesis that are required by print(...). Python does not understand what you are trying to do.

Here is a second example of a bug in Python.

In the second example, we forget to define the greeting variable. Python knows what you want it to do, but since no greeting has been defined, an error occurs.

A syntax error happens when Python can’t understand what you are saying. A run-time error happens when Python understands what you are saying, but runs into trouble when following your instructions.

In English, a syntax error would be like the sentence

Please cat dog monkey.

The grammar of this sentence does not make sense. From the perspective of English grammar, it is missing a verb (action). You cannot understand what you are being asked to do. Syntax means the same thing as grammar.

In English, a run-time error would be like the sentence

Please eat the piano.

The sentence makes sense from a grammatical perspective — there is a verb and noun in the right place — so you know what you are being asked to do. But, you will encounter problems once you start trying to eat the piano (except maybe if you are a termite). This is called a run-time error because it occurs after the program starts running.

We also will talk about logic errors at the end, which means that your program runs without crashing, but still produces the wrong result. An example would be

Please close the back door so that the bugs don’t come in.

This would be a logic error if the front door is also open: even though the command makes sense and you can close the back door, this doesn’t actually accomplish the goal of keeping the bugs out since they’ll still come in the front door.

Common Syntax Errors in Python

Here are a few additional examples of syntax errors that can occur in Python. One very general thing that can occur is that Python will encounter a special symbol in a place that it doesn’t expect.

Python says SyntaxError: invalid syntax and points with ^ to the exclamation point. The problem is that ! has no meaning in Python. The syntax error would go away if we had put print("Hello, World!") instead, because then Python would understand that the ! is part of the text with Hello, World.

Here is another syntax error that is more subtle.

The problem is that class is a special word in Python. if you had written course instead of class it would have been fine. Click here to see the list of all special «keywords» in Python.

If you are using quotes around text and you forget the second one, or you are using parentheses and forget the second one, you will get syntax errors:

In this error, EOL is short for End Of Line: Python expected another " but the line ended before it was found.

Similarly, EOF is short for End Of File: Python kept looking for a ) but the program file ended before it was found.

Sometimes two very similar syntax errors can give two very different error messages. But, every error message is indeed trying to tell you something helpful.

Run-Time Errors

Here are a few common run-time errors. Python is able to understand what the program says, but runs into problems when actually performing the instructions.

• using an undefined variable or function. This can also occur if you use capital letters inconsistently in a variable name:
• dividing by zero, which makes no sense in mathematics. (Why? Since 0 times any number is 0, there is no solution to 1 = X * 0, so 1/0 is undefined.)
• using operators on the wrong type of data

You will find more ways of producing errors as you learn more about Python.

What is the technical difference between syntax and run-time errors? Here is an example comparing a run-time error to a syntax error. Look at the output of each program. The program with the run-time error created some output, but the one with the syntax error did not. This is because Python runs in two steps: Python checks if your program has correct syntax, in order to determine its structure and parts. If no syntax errors were encountered in step 1, then the program is executed. So, a program with a syntax error will execute no steps at all, but a program with a run-time error will execute the steps that happened before the error occured.

Logic Errors

Your program might run without crashing (no syntax or run-time errors), but still do the wrong thing. For example, perhaps you want a program to calculate the average of two numbers: the average of x and y is defined as

Why doesn’t this program work?

The average should be

but the program prints 5.0 instead! The error this time has to do with the «order of operations» in arithmetic. When you write x + y / 2, this has the same mathematical meaning as . To fix the problem, the third line of our program should be written as average = (x + y) / 2, which makes clear to Python that we really want the value , where we add first and divide afterwards.

You can have logic errors because you designed a program incorrectly, or because you didn’t write code that follows the design correctly (like the average example). Logic errors can be difficult to spot, especially in a longer program, but as you get better at writing code you will also get better at avoiding logic errors. Lesson 6D will give some tips on avoiding logic errors.

Exercises

Now that the lesson is complete, we have three exercises on debugging (fixing errors in programs). You can try to spot the errors before running the programs, or you can run them first and use Python’s response to determine what needs fixing.

Each program below comes with some code already written for you. You only need to change a few characters (letters/symbols/numbers) to fix each program. The grader will reject any solution that changes too many characters from the original version. This unusual exercise format is meant to be similar to real-world debugging, where people often accidentally include a typo—can you find and fix the typos rather than redoing the whole solution? Select Reset code to default if you need to bring back the original version.

Once you have squashed all of the bugs, move on to the next lesson!