Что произойдет после выполнения этой программы на python

Работа с редактором Python. Общие вопросы. Интерактивный и программный режимы работы. Набор текста программы

Поиск на других ресурсах:

1. Режимы работы Python. Какие режимы работы поддерживаются интегрированной средой разработки Python?

Интегрированная среда разработки IDLE (Integrated Development Environment) Python поддерживает 2 режима работы:

• интерактивный режим. В этом режиме команды выполняются сразу после их вызова. Результат выполнения команд сразу выводится на экран (рисунок 1). Этот режим работы хорошо подходит для написания простых программ и тестирования работы фрагментов кода;
• программный режим. В этом режиме сначала записывается вся программа, а потом эта программа выполняется полностью. Предварительно текст программы нужно сохранить. Программа на языке Python носит имя «сценарий»или «скрипт».

Python на практике / Пишем 3 программы на Питон за 5 минут

Рис. 1. Окно Python в интерактивном режиме

Рис. 2. Окно Python в программном режиме

2. Особенности интерактивного режима

В интерактивном режиме интерпретатор выполняет инструкции и сразу выводит результат. Сохранить эти инструкции в файле нельзя.

Интерактивный режим работы интегрированной среды Python используется для получения мгновенных расчетов, проведения экспериментов, тестирования программ «на лету».

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

3. Как в интерактивном режиме вводятся многострочные инструкции

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

Например.

>>> x=3 >>> y=8 >>> if x>0: # многострочная инструкция y=5 # здесь нужно 2 раза нажать Enter >>>

В приведенном выше коде выполняется многострочная инструкция if . Чтобы выйти из инструкции if нужно два раза нажать клавишу Enter .

4. Особенности программного режима

Программный режим позволяет сохранять программы длительное время. В программном режиме текст программы сначала записывается в файл, затем этот файл выполняется в интегрированной среде. Файлы на языке Python имеют расширение *.py и называются модулями. Модули – это простые текстовые файлы. Код модулей может выполняться сколько угодно.

Интерпретатор Python выполняет весь программный код в модуле.

Файлы модулей, которые запускаются на выполнение непосредственно, еще называются сценариями.

5. Какие недостатки интерактивного режима?

Интерактивный режим имеет следующие взаимосвязанные недостатки:

Как узнать время выполнения программы? #python #программирование

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

6. Каким образом вызвать программный режим? Как выполнить программу в программном режиме?

Если система находится в интерактивном режиме, то программный режим можно вызвать с помощью команды

File->New File

как показано на рисунке 3.

Рис. 3. Команда File->New File

В результате откроется новое окно редактора, в котором нужно ввести текст на языке Python. На рисунке 4 изображено окно файла myprog1.py с текстом программы.

Рис. 4. Окно файла myprog1.py с текстом программы на языке Python

Чтобы запустить файл myprog1.py на выполнение нужно вызвать команду Run из меню Run или нажать клавишу F5 (рисунок 5).

Рис. 5. Команда запуска программы на выполнение

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

============== RESTART: C:/Programs/Python/myprog1.py ============== 10 >>>

Связанные темы

Источник: www.bestprog.net

Асинхронность python на примере

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

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

import time

def waiter():
cook(‘Паста’, 8)
cook(‘Салат Цезарь’, 3)
cook(‘Отбивные’, 16)

def cook(order, time_to_prepare):
print(f’Новый заказ: ‘)
time.sleep(time_to_prepare)
print(order, ‘- готово’)

if __name__ == ‘__main__’:
waiter()

Сохраним файл sync.py .

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

Есть еще одна функция официанта. По внутренней логике официант принимает заказы от посетителей и синхронно передает их повару.

Убедитесь, что установлена версия Python 3.7+ с помощью команды python3 —version на Mac или python —version — на Windows. Если версия меньше 3.7, обновите.

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

Новый заказ: Паста Паста — готово Новый заказ: Салат Цезарь Салат Цезарь — готово Новый заказ: Отбивные Отбивные — готово

Первая асинхронная программа

Теперь конвертируем программу так, чтобы она использовала библиотеку asyncio. Это будет первый шаг для того, чтобы разобраться с тем, как писать асинхронный код. Скопируем файл sync.py в новый файл coros.py со следующим кодом:

import asyncio
import time

async def waiter() -> None:
cook(‘Паста’, 8)
cook(‘Салат Цезарь’, 3)
cook(‘Отбивные’, 16)

async def cook(order: str, time_to_prepare: int) -> None:
print(f’Новый заказ: ‘)
time.sleep(time_to_prepare)
print(order, ‘- готово’)

asyncio.run(waiter())

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

В конце программы заменим if __name__ == ‘__main__’ на новый метод run из модуля asyncio . Что именно делает run ?

По сути, run берет низкоуровневый псевдо-сервер asyncio, который называется рабочим циклом. Этот цикл является координатором, который следит за приостановкой и возобновлением задач из кода. В примере с поваром и официантом вызов «cook(»Паста’)» — это задача, которая выполнится, но также будет приостановлена на 8 секунд. Таким образом после получения запроса он отмечается, а программа переходит к выполнению следующего. После завершения заказа на приготовление пасты цикл продолжит выполнение на следующей строке, где готовится салат «Цезарь».

Команде run нужна функция, которую она будет выполнять, поэтому передаем waiter , которая является основной функцией в этом коде.

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

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

async def waiter() -> None:
await cook(‘Паста’, 8)
await cook(‘Салат Цезарь’, 3)
await cook(‘Отбивные’, 16)

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

Такой код можно читать следующим образом: «вызвать функцию cook и дождаться ( await ) ее результата, прежде чем переходить к следующей строке». Но это не процесс с блокировкой потока. Наоборот, он сообщает циклу следующее: «если есть другие запросы, можешь переходить к их выполнению, пока мы ждем, а мы дадим знать, когда текущий запрос завершится».

Достаточно лишь запомнить, что если есть задачи с await , то сама функция должна быть объявлена с async .

А как же функция cook ? Ее тоже нужно сделать асинхронной, поэтому перепишем ее вот так.

async def cook(order, time_to_prepare):
print(f’Новый заказ: ‘)
await time.sleep(time_to_prepare)
print(order, ‘- готово’)

Но здесь есть одна проблема. Если использовать стандартную функцию time.sleep , то она заблокирует весь процесс выполнения, сделав асинхронную программу бесполезной. В этом случае нужно использовать функцию sleep из модуля asyncio.

async def cook(order, time_to_prepare):
print(f’Новый заказ: ‘)
await asyncio.sleep(time_to_prepare)
print(order, ‘- готово’)

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

Если сейчас запустить программу, то результат будет таким:

Новый заказ: Паста Паста — готово Новый заказ: Салат Цезарь Салат Цезарь — готово Новый заказ: Отбивные Отбивные — готово

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

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

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

Сопрограммы и задачи (coroutines and tasks)

Сопрограммы (coroutines)

Функции waiter и cook трансформируются именно в тот момент, когда перед их определением ставится ключевое слово async . С этого момент их можно считать сопрограммами.

Если попытаться запустить одну из таких прямо, то вернется сообщение с информацией о ней, но сама программа не будет запущена. Попробуем запустить терминал Python и импортировать туда функцию cook из файла coros . Во-первых, нужно закомментировать команду asyncio.run так, чтобы код не выполнялся. После этого файл можно сохранить.

# asyncio.run(waiter())

Затем откроем терминал и сделаем следующее:

Источник: pythonru.com

Цикл while в Python

Цикл while позволяет повторить одно или несколько действий до тех пор, пока заданное условие остается истинным.

Содержание страницы:

1. Цикл while в Python

1.2. Как прервать цикл while

1.3. Флаги в цикле while

2.1. Команда break в цикле while

2.2. Команда continue в цикле while

3. Предотвращение зацикливания в цикле while

4. Цикл while со списками

5. Цикл while со словарями

1. Цикл while в Python

Цикл while в Python используется во многих программах. Он позволяет выполнять программу пока остается истинным условие. Приведем пример перебора числовой последовательности в заданном диапазоне.

>>> number = 1 # присваиваем начальное значение переменной
>>> while number . print(number) # выводим значение number при каждом цикле
. number += 1 # после каждого цикла увеличиваем значение на 1
.
1
2
3
4
5
6
7

Вначале присваиваем значение переменной number. Затем запускаем цикл while до тех пор, пока значение переменной number не будет больше 7. При каждом проходе цикла выводим значение number и затем увеличиваем его на 1. Как только значение number станет больше 7 цикл прекращается.

1.2. Как прервать цикл while на Python.

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

prompt = «nВведите любое слово, и оно будет выведено наоборот»
prompt += «nЕсли надоело введите команду ‘стоп’.n»
message = »
while message != «стоп»:
message = input(prompt)
if message != «стоп»:
print(message[::-1])
else:
print(«Программа завершена»)

В начале создаем сообщение prompt (посказку) которое объясняет пользователю что за программа и как ее можно завершить. Затем создается переменная message и ей присваивается пустое значение. Важно переменную message определить до запуска цикла, присвоить ей можно любое значение или пустую строку.

При запуске цикла while идет проверка совпадает ли значение message с условием продолжения цикла. При каждом выполнение цикла на экран выводятся правила цикла и условия его завершения. Дальше можно запустить команду if-else для проверки условия, если пользователь не ввел строку «стоп», то выводим строку пользователя на экран в обратном порядке с помощью сегментации строки [: : -1].

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.
python лучший язык программирования
яинавориммаргорп кызя йишчул nohtyp

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.
123456789
987654321

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.
стоп
Программа завершена

Пока пользователь не введет слово «стоп», цикл будет начинаться заново.

1.3. Флаги в цикле while на Python

Если программа должна выполняться при нескольких условиях, то лучше определить одну переменную — флаг. Переменная — флаг сообщает, должна ли программа выполняться при каждом цикле. Для флага достаточно определить два состояния True — в котором программа продолжит выполнение и False — завершение программы. В результате в начале цикла while достаточно проверить всего одно условие для запуска программы, а все остальные проверки организовать в остальном коде.

prompt = «nВведите любое слово, и оно будет выведено наоборот»
prompt += «nЕсли надоело введите команду ‘стоп’n»
active = True
while active:
message = input(prompt)
if message == «стоп»:
active = False
print(«Программа завершена»)
else:
print(message[::-1])

В примере переменной active присваивается True и программа будет выполняться до тех пор, пока переменная active не станет равной False. Результат работы этой программы ничем не будет отличаться от программы в разделе 1.2. Вот что получим мы на выходе.

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’
Python
nohtyP

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’
стоп
Программа завершена

Программа завершится если пользователь введет «стоп». После этого переменная active становится равной False и действие цикла прекращается.

2.1. Команда break в цикле while на Python

С помощью команды break так же можно прервать цикл while. Цикл, который начинается с while True выполняется бесконечно, пока не будет выполнена команда break .

prompt = «nВведите столицу США с заглавной буквы: »
active = True
while active:
capital = input(prompt)
if capital == ‘Вашингтон’:
print(‘Совершенно верно’)
break
else:
print(f» не является столицей США»)

В результате цикл while будет выполняться до тех пор, пока не будет введен правильный ответ, после чего сработает команда break и произойдет выход из цикла.

Введите столицу США с заглавной буквы: Лондон
Лондон не является столицей США

Введите столицу США с заглавной буквы: Москва
Москва не является столицей США

Введите столицу США с заглавной буквы: Вашингтон
Совершенно верно

2.2. Команда continue в цикле while на Python

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

>>> number = 0
>>> while number < 20:
. number += 1
. if number % 2 == 1:
. continue
. print(number, end=’ ‘)
.
2 4 6 8 10 12 14 16 18 20 >>>

Сначала создадим переменную number и присвоим ей начальное значение. После идет проверка условий цикла что значение number меньше 20. При входе в цикл значение number увеличивается на 1 и затем команда if проверяет остаток от деления на 2. Если остаток равен одному, то число не четное, команда continue приказывает Python игнорировать остаток кода и цикл запускается заново. Если остаток от деления равен нулю, то число выводится на экран и так до того пока number будет равен 20, затем условия цикла while не будут выполнены и цикл прекратится.

3. Предотвращение зацикливания в циклах while на Python

В каждом цикле должно быть предусмотрена возможность завершения, чтобы цикл while не выполнялся бесконечно. Например, если в предыдущем примере мы пропустили бы строку number += 1 , то значение number всегда будет равно 0 и цикл будет продолжаться до бесконечности

>>> number = 0
>>> while number < 20:
. if number % 2 == 1:
. continue
. print(number, end=’ ‘)
.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .

Для предотвращения зацикливания в терминальном окне введите Ctrl + C и всегда заранее проверяйте все условия цикла while и пути выхода из него.

4. Цикл while со списками в Python

Для изменения списков в процессе обработки удобно использовать цикл while . К примеру, у нас есть целый список пользователей, который может состоять из тысяч пользователей и нам нужно будут удалить всех пользователей с определенным именем. Нам уже известно, что метод remove() для списков удаляет лишь первое вхождение заданного значения в список, но нам нужно удалить их все. В этом случае мы можем запустить цикл while :

>>> login = [‘qwerty’, ‘arfa’, ‘bond’, ‘chelsy’, ‘qwerty’, ‘serg’, ‘cat’, ‘qwerty’]
>>> while ‘qwerty’ in login:
. login. remove (‘qwerty’)
.
>>> print(login)
[‘arfa’, ‘bond’, ‘chelsy’, ‘serg’, ‘cat’]

В результате при запуске цикла while проверяется условия нахождения ‘qwerty’ в списке login. Затем после первого удаления из списка, цикл запускается снова и Python проверяет наличие ‘qwerty’ в списке заново и так до тех, пор пока будет выполняться условие цикла while .

5. Цикл while со словарями в Python

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

interview = <>
active = True
while active:
# Запрашиваем имя и ответ на вопрос
name = input («nКак вас зовут? «)
question = input («Какая марка автомобиля вам нравиться «)
# Создаем список с ответами и добавляем первый ответ
answers = []
answers. append (question)
# Ответ сохраняем в словаре «имя: список ответов»
interview[name] = answers

# Запускаем второй цикл с возможностью добавления еще ответов к одному пользователю
active_2 = True
while active_2:
repeat = input («Желаете добавить еще один автомобиль? (yes/no) «)
if repeat == ‘no’:
active_2 = False
else :
question_n = input («Какая марка автомобиля вам еще нравиться «)
# Добавляем ответ в список
answers. append (question_n)

# Вопрос о продолжение опроса
repeat = input («Желаете продолжить опрос? (yes/no) «)
if repeat == ‘no’:
active = False
print(«nОпрос завершен, все результаты:»)

# Переберем словарь и посмотрим ответы
for name, questions in interview.items():
print(f» n name.title()> любит автомобили марки:»)
for question in questions:
print(f» t question.title()>»)

В начале программы создаем словарь interview в который в будущем будем добавлять посетителя с его ответами. Затем устанавливаем флаг продолжения опроса active = True. Пока active = True Python будет выполнять цикл while . При запуске цикла посетителю предлагается представиться и ввести ответ на заданный вопрос.

Затем сразу создадим список ответов answers на всякий случай, если посетитель захочет дать несколько ответов и добавляем его в словарь. После запускаем второй цикл while с вопросом добавить еще один ответ. Количество ответов бесконечно, и посетитель сам решает, когда прервать программу. Если ответов больше нет, то возвращаемся к первому циклу и предлагаем ввести нового посетителя с опросом. После окончания цикла while выведем на экран всех посетителей и их ответы. Если запустить программу и ввести несколько пользователей с ответами, то результат будет выглядеть так:

Как вас зовут? bob
Какая марка автомобиля вам нравиться: audi
Желаете добавить еще один автомобиль? (yes/no) yes
Какая марка автомобиля вам еще нравиться: bmw
Желаете добавить еще один автомобиль? (yes/no) yes
Какая марка автомобиля вам еще нравиться: ford
Желаете добавить еще один автомобиль? (yes/no) no
Желаете продолжить опрос? (yes/no) yes

Как вас зовут? Artem
Какая марка автомобиля вам нравиться: porshe
Желаете добавить еще один автомобиль? (yes/no) no
Желаете продолжить опрос? (yes/no) no

Опрос завершен, все результаты:

Bob любит автомобили марки:
Audi
Bmw
Ford

Artem любит автомобили марки:
Porshe

Источник: pythonclass.ru

Обрабатываем исключения в Python: try и except

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

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

Для обработки большей части этих ошибок как исключений в Python есть блоки try и except .

Синтаксис конструкции try и except

Для начала разберем синтаксис операторов try и except в Python. Общий шаблон представлен ниже:

try: # В этом блоке могут быть ошибки except : # Сделай это для обработки исключения; # выполняется, если блок try выбрасывает ошибку else: # Сделай это, если блок try выполняется успешно, без ошибок finally: # Этот блок выполняется всегда

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

Блок try

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

Блок except

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

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

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

При попытке выполнить код внутри блока try также существует вероятность возникновения нескольких ошибок.

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

В результате вы можете столкнуться с IndexError , KeyError и FileNotFoundError . В таком случае нужно добавить столько блоков except , сколько ошибок ожидается – по одному для каждого типа ошибки.

Блок else

Блок else запускается только в том случае, если блок try выполняется без ошибок. Это может быть полезно, когда нужно выполнить ещё какие-то действия после успешного выполнения блока try . Например, после успешного открытия файла вы можете прочитать его содержимое.

Блок finally

Блок finally выполняется всегда, независимо от того, что происходит в других блоках. Это полезно, когда вы хотите освободить ресурсы после выполнения определенного блока кода.

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

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

Обработка ZeroDivisionError

Рассмотрим функцию divide() , показанную ниже. Она принимает два аргумента – num и div – и возвращает частное от операции деления num/div .

def divide(num,div): return num/div

Вызов функции с разными аргументами возвращает ожидаемый результат:

res = divide(100,8) print(res) # Output # 12.5 res = divide(568,64) print(res) # Output # 8.875

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

divide(27,0)

Вы видите, что программа выдает ошибку ZeroDivisionError :

# Output ————————————————————————— ZeroDivisionError Traceback (most recent call last) in () —-> 1 divide(27,0) in divide(num, div) 1 def divide(num,div): —-> 2 return num/div ZeroDivisionError: division by zero

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

1. В блоке try поместите вызов функции divide() . По сути, вы пытаетесь разделить num на div (try в переводе с английского — «пытаться», — прим. перев.).
2. В блоке except обработайте случай, когда div равен 0, как исключение.
3. В результате этих действий при делении на ноль больше не будет выбрасываться ZeroDivisionError. Вместо этого будет выводиться сообщение, информирующее пользователя, что он попытался делить на ноль.

Вот как все это выглядит в коде:

try: res = divide(num,div) print(res) except ZeroDivisionError: print(«You tried to divide by zero 🙁 «)

При корректных входных данных наш код по-прежнему работает великолепно:

divide(10,2) # Output # 5.0

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

divide(10,0) # Output # You tried to divide by zero 🙁

Обработка TypeError

В этом разделе мы разберем, как использовать try и except для обработки TypeError в Python.

Рассмотрим функцию add_10() . Она принимает число в качестве аргумента, прибавляет к нему 10 и возвращает результат этого сложения.

def add_10(num): return num + 10

Вы можете вызвать функцию add_10() с любым числом, и она будет работать нормально, как показано ниже:

result = add_10(89) print(result) # Output # 99

Теперь попробуйте вызвать функцию add_10() , передав ей в качестве аргумента не число, а строку.

add_10 («five»)

Ваша программа вылетит со следующим сообщением об ошибке:

————————————————————————— TypeError Traceback (most recent call last) in () —-> 1 add_10(«five») in add_10(num) 1 def add_10(num): —-> 2 return num + 10 TypeError: can only concatenate str (not «int») to str

Сообщение об ошибке TypeError: can only concatenate str (not «int») to str говорит о том, что можно сложить только две строки, а не добавить целое число к строке.

• В блок try мы помещаем вызов функции add_10() с my_num в качестве аргумента. Если аргумент допустимого типа, исключений не возникнет.
• В противном случае срабатывает блок except , в который мы помещаем вывод уведомления для пользователя о том, что аргумент имеет недопустимый тип.

Это показано ниже:

my_num = «five» try: result = add_10(my_num) print(result) except TypeError: print(«The argument `num` should be a number»)

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

The argument `num` should be a number

Обработка IndexError

Если вам приходилось работать со списками или любыми другими итерируемыми объектами, вы, вероятно, сталкивались с IndexError .

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

В этом примере список my_list состоит из 4 элементов. Допустимые индексы — 0, 1, 2 и 3 и -1, -2, -3, -4, если вы используете отрицательную индексацию.

Поскольку 2 является допустимым индексом, вы видите, что элемент с этим индексом ( C++ ) распечатывается:

my_list = [«Python»,»C»,»C++»,»JavaScript»] print(my_list[2]) # Output # C++

Но если вы попытаетесь получить доступ к элементу по индексу, выходящему за пределы допустимого диапазона, вы столкнетесь с IndexError :

print(my_list[4])
————————————————————————— IndexError Traceback (most recent call last) in () 1 my_list = [«Python»,»C»,»C++»,»JavaScript»] —-> 2 print(my_list[4]) IndexError: list index out of range

Теперь вы уже знакомы с шаблоном, и вам не составит труда использовать try и except для обработки данной ошибки.

В приведенном ниже фрагменте кода мы пытаемся получить доступ к элементу по индексу search_idx .

search_idx = 3 try: print(my_list[search_idx]) except IndexError: print(«Sorry, the list index is out of range»)

Здесь search_idx = 3 является допустимым индексом, поэтому в результате выводится соответствующий элемент — JavaScript .

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

search_idx = 4 try: print(my_list[search_idx]) except IndexError: print(«Sorry, the list index is out of range»)

Вместо этого отображается сообщение о том, что search_idx находится вне допустимого диапазона индексов:

Sorry, the list index is out of range

Обработка KeyError

Вероятно, вы уже сталкивались с KeyError при работе со словарями в Python.

Рассмотрим следующий пример, где у нас есть словарь my_dict .

my_dict = search_key = «non-existent key» print(my_dict[search_key])

В словаре my_dict есть 3 пары «ключ-значение»: key1:value1 , key2:value2 и key3:value3 .

Теперь попытаемся получить доступ к значению, соответствующему несуществующему ключу non-existent key .

Как и ожидалось, мы получим KeyError :

————————————————————————— KeyError Traceback (most recent call last) in () 1 my_dict = 2 search_key = «non-existent key» —-> 3 my_dict[search_key] KeyError: ‘non-existent key’

Вы можете обработать KeyError почти так же, как и IndexError .

• Пробуем получить доступ к значению, которое соответствует ключу, определенному search_key .
• Если search_key — валидный ключ, мы распечатываем соответствующее значение.
• Если ключ невалиден и возникает исключение — задействуется блок except, чтобы сообщить об этом пользователю.

Все это можно видеть в следующем коде:

try: print(my_dict[search_key]) except KeyError: print(«Sorry, that’s not a valid key!») # Output: # Sorry, that’s not a valid key!

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

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

try: print(my_dict[search_key]) except KeyError as error_msg: print(f»Sorry, is not a valid key!»)

Обратите внимание, что теперь в сообщении об ошибки указано также и имя несуществующего ключа:

Sorry, ‘non-existent key’ is not a valid key!

Обработка FileNotFoundError

При работе с файлами в Python часто возникает ошибка FileNotFoundError .

В следующем примере мы попытаемся открыть файл my_file.txt, указав его путь в функции open() . Мы хотим прочитать файл и вывести его содержимое.

Однако мы еще не создали этот файл в указанном месте.

my_file = open(«/content/sample_data/my_file.txt») contents = my_file.read() print(contents)

Поэтому, попытавшись запустить приведенный выше фрагмент кода, мы получим FileNotFoundError :

————————————————————————— FileNotFoundError Traceback (most recent call last) in () —-> 1 my_file = open(«my_file.txt») FileNotFoundError: [Errno 2] No such file or directory: ‘my_file.txt’

А с помощью try и except мы можем сделать следующее:

• Попробуем открыть файл в блоке try .
• Обработаем FileNotFoundError в блоке except , сообщив пользователю, что он попытался открыть несуществующий файл.
• Если блок try завершается успешно и файл действительно существует, прочтем и распечатаем содержимое.
• В блоке finally закроем файл, чтобы не терять ресурсы. Файл будет закрыт независимо от того, что происходило на этапах открытия и чтения.

try: my_file = open(«/content/sample_data/my_file.txt») except FileNotFoundError: print(f»Sorry, the file does not exist») else: contents = my_file.read() print(contents) finally: my_file.close()

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

Sorry, the file does not exist

Теперь рассмотрим случай, когда срабатывает блок else . Файл my_file.txt теперь присутствует по указанному ранее пути.

Вот содержимое этого файла:

Теперь повторный запуск нашего кода работает должным образом.

На этот раз файл my_file.txt присутствует, поэтому запускается блок else и содержимое распечатывается, как показано ниже:

Надеемся, теперь вы поняли, как обрабатывать исключения при работе с файлами.

Заключение

В этом руководстве мы рассмотрели, как обрабатывать исключения в Python с помощью try и except.

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

Надеемся, вам понравился этот урок. Успехов в написании кода!

Источник: pythonist.ru