1. Первые шаги с Python

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

1.1) Что такое программа и что делает Python?

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

1.1.1) Понимание программ

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

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

Здесь на помощь приходят языки программирования. Язык программирования — это удобный для человека способ записи инструкций, которые могут быть переведены в машинный код. Python — один из таких языков программирования, специально разработанный так, чтобы его было особенно легко читать и писать человеку.

1.1.2) Что делает Python особенным

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

Читаемый синтаксис: код на Python читается почти как английский текст. Например, чтобы вывести строку "Hello, World!" в Python, вы пишете:

# hello_simple.py
print("Hello, World!")

Output:

Hello, World!

Сравните это с такими языками, как C или Java, где для решения той же задачи требуется больше шаблонного кода.

Интерпретируемый язык: Python — интерпретируемый язык. Это значит, что вам не нужно заранее компилировать код в машинный код перед запуском. Вместо этого программа под названием интерпретатор Python читает ваш код и выполняет его построчно. Это ускоряет разработку, потому что вы сразу видите результат изменений в коде.

Универсальный и мощный: несмотря на простоту для новичка, Python используется в профессиональной среде для:

• веб‑разработки (сайты и веб‑приложения)
• анализа и визуализации данных
• машинного обучения и искусственного интеллекта
• научных вычислений
• автоматизации и написания скриптов
• разработки игр
• и многого другого

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

1.1.3) Как Python выполняет ваш код

Когда вы пишете код на Python и запускаете его, «под капотом» происходит следующее:

1. Вы пишете код: вы создаёте файл с инструкциями на Python или вводите их прямо в интерактивную оболочку Python.

2. Интерпретатор читает ваш код: интерпретатор Python проверяет код на синтаксические ошибки (ошибки в том, как написан код).

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

4. Выполнение: виртуальная машина Python (Python Virtual Machine, PVM) выполняет байт‑код, производя указанные вами операции.

5. Вывод: вы видите результат работы программы — будь то текст на экране, созданный файл или любое другое действие.

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

1.2) Установка Python и запуск интерпретатора

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

1.2.1) Проверка, установлен ли уже Python

Некоторые операционные системы поставляются с уже установленным Python. Прежде чем что‑то скачивать, давайте проверим, не установлен ли Python у вас.

В Windows:

1. Откройте командную строку (Command Prompt):

   • Нажмите Windows + R, чтобы открыть окно «Выполнить»
   • Введите cmd и нажмите Enter

2. Введите следующую команду и нажмите Enter:

python --version

Если Python установлен, вы увидите примерно такой вывод:

Python 3.11.5

Если появится сообщение об ошибке вроде 'python' is not recognized as an internal or external command, значит, Python не установлен или не добавлен в переменную окружения PATH.

В macOS:

1. Откройте приложение Terminal:

   • Нажмите Command + Space, чтобы открыть Spotlight
   • Введите Terminal и нажмите Enter

2. Введите следующую команду и нажмите Enter:

python3 --version

Note: в macOS обычно используют python3 вместо python, потому что python может указывать на устаревший Python 2.

Если установлен Python 3, вы увидите, например:

Python 3.11.5

В Linux:

1. Откройте терминал (конкретный способ зависит от дистрибутива)

2. Введите команду и нажмите Enter:

python3 --version

Большинство современных дистрибутивов Linux уже содержат предустановленный Python 3.

1.2.2) Загрузка и установка Python

Если Python не установлен или у вас более старая версия, выполните следующие шаги, чтобы установить последнюю.

Установка в Windows:

1. Перейдите на официальный сайт Python: https://www.python.org/downloads/

2. Нажмите кнопку "Download Python" (будет указана последняя версия, например "Download Python 3.11.5")

3. Запустите скачанный установщик (.exe‑файл)

4. Важно: на первом экране установщика поставьте галочку "Add Python to PATH". Это критично — это позволит запускать Python из любой командной строки.

   Что будет, если забыть: если не поставить "Add Python to PATH", вы не сможете запускать Python из командной строки и будете получать ошибку вроде 'python' is not recognized as an internal or external command. В этом случае придётся либо переустановить Python (на этот раз поставив галочку), либо вручную добавить его в PATH, что сложнее для новичков.

5. Нажмите "Install Now" и дождитесь окончания установки.

6. Проверьте установку, открыв новую командную строку и введя:

python --version

Вы должны увидеть номер только что установленной версии.

Установка в macOS:

1. Перейдите на https://www.python.org/downloads/

2. Нажмите кнопку "Download Python" для последней версии

3. Откройте скачанный .pkg‑файл и следуйте инструкциям установщика

4. Проверьте установку, открыв Terminal и введя:

python3 --version

Установка в Linux:

Большинство дистрибутивов Linux уже содержат Python 3, но если нужно установить или обновить его:

Для Ubuntu/Debian‑подобных систем:

sudo apt update
sudo apt install python3

Для Fedora/Red Hat‑подобных систем:

sudo dnf install python3

Проверьте:

python3 --version

1.2.3) Запуск интерпретатора Python

После установки Python вы можете запускать интерпретатор Python прямо из командной строки или терминала. Интерпретатор — это программа, которая выполняет код Python. Запуск интерпретатора напрямую открывает интерактивную оболочку (REPL), о которой мы будем подробно говорить в следующем разделе. Это отличается от запуска файлового скрипта, о чём мы расскажем в разделе 1.4.

В Windows:

Откройте командную строку и введите:

python

В macOS и Linux:

Откройте Terminal и введите:

python3

Вы должны увидеть что‑то вроде:

Python 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Приглашение >>> показывает, что Python готов принимать команды. Это называется интерактивной оболочкой Python или REPL (Read‑Eval‑Print Loop — «прочитай–вычисли–выведи–повтори»), о которой мы подробно поговорим в следующем разделе.

Чтобы выйти из интерпретатора, вы можете:

• ввести exit() и нажать Enter
• ввести quit() и нажать Enter
• нажать Ctrl + D (в macOS/Linux) или Ctrl + Z, затем Enter (в Windows)

Поздравляем! Вы успешно установили Python и убедились, что интерпретатор работает. Теперь вы готовы писать код на Python.

1.3) Использование интерактивной оболочки Python (REPL)

Интерактивная оболочка Python, часто называемая REPL (Read‑Eval‑Print Loop), — одна из самых полезных возможностей Python для обучения и экспериментов. Она позволяет вводить код на Python и сразу видеть результат, что делает её идеальным инструментом для освоения новых концепций, тестирования небольших фрагментов кода и изучения возможностей Python.

1.3.1) Что такое REPL?

Интерактивная оболочка Python, часто называемая REPL (Read‑Eval‑Print Loop), — одна из самых полезных возможностей Python для обучения и экспериментов. REPL также называют интерактивной оболочкой Python или просто интерактивным интерпретатором — все эти термины обозначают одно и то же: приглашение >>>, куда вы вводите код Python и сразу видите результат.

REPL расшифровывается так:

• Read: Python считывает введённый вами код
• Eval: Python вычисляет (выполняет) этот код
• Print: Python выводит результат
• Loop: Python снова ждёт ввода кода

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

1.3.2) Запуск и использование REPL

Чтобы запустить REPL, откройте командную строку или терминал и введите python (в Windows) или python3 (в macOS/Linux), как мы сделали в предыдущем разделе.

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

Простая арифметика:

>>> 5 + 3
8
>>> 10 * 2
20
>>> 15 / 3
5.0

Обратите внимание, что в REPL не нужно вызывать print() — Python автоматически показывает результат каждого выражения. Это одно из удобств REPL.

Работа с текстом:

>>> "Hello, World!"
'Hello, World!'
>>> "Python" + " is " + "great"
'Python is great'

Если вы вводите просто строку (текст в кавычках), Python показывает её с кавычками — это способ представления строки самим Python. Если вы хотите вывести текст без кавычек, используйте функцию print():

>>> print("Hello, World!")
Hello, World!

Обратите внимание на разницу: при вводе только строки она отображается с кавычками (представление Python), а через print() выводится без кавычек (сам текст).

Сохранение значений в переменные:

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

>>> name = "Alice"
>>> name
'Alice'
>>> age = 25
>>> age
25

Когда вы присваиваете значение переменной (например, name = "Alice"), Python ничего не выводит. Но если ввести только имя переменной, Python покажет её значение.

Использование Python как калькулятора:

>>> 2 + 2
4
>>> (10 + 5) * 2
30
>>> 100 / 4
25.0
>>> 7 % 3
1

REPL отлично подходит для быстрых вычислений и проверки математических выражений.

1.3.3) Многострочный ввод в REPL

Иногда нужно написать код, который занимает несколько строк, например определение функции (function). REPL обрабатывает это, изменяя приглашение. Когда вы начинаете многострочную конструкцию, приглашение меняется с >>> на ..., показывая, что Python ждёт продолжения.

Вот простой пример с функцией (Note: подробно о функциях мы будем говорить в главе 19. Этот пример просто показывает, как REPL обрабатывает многострочный ввод с приглашением продолжения ...):

>>> def greet():
...     print("Hello!")
...
>>> greet()
Hello!

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

1.3.4) Доступ к предыдущим командам

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

• Стрелка вверх: показывает предыдущую команду
• Стрелка вниз: показывает следующую команду (если вы уже вернулись назад)

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

1.3.5) Получение справки в REPL

В REPL Python есть встроенная система помощи. Можно получать информацию об объектах Python, функциях и модулях прямо из оболочки.

Эти средства помощи особенно полезны, когда вы исследуете Python и хотите узнать, какие есть возможности. Например, если вы работаете со строками и хотите увидеть доступные методы, dir(str) покажет все варианты. По мере продвижения по книге вы будете всё чаще использовать эти инструменты для самостоятельного изучения.

>>> help()

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

Можно также получать помощь по конкретным объектам напрямую:

>>> help(print)

Это покажет документацию по функции print(). Для выхода из просмотра нажмите q.

Ещё одна полезная функция — dir(), которая выводит список атрибутов и методов объекта. (Note: атрибуты и методы — это свойства и действия, доступные для объекта; подробнее о них мы будем говорить в главе 43. В главе 22 мы также изучим импорт модулей. Этот пример показывает, как REPL помогает исследовать возможности Python.)

>>> dir(str)

Это выведет список всех методов, доступных для строковых объектов.

1.3.6) Когда REPL особенно полезен

REPL особенно хорош для следующих задач:

1. Обучение и исследование: когда вы изучаете новую концепцию, REPL позволяет сразу же поэкспериментировать, не создавая файлов.

2. Тестирование небольших фрагментов кода: перед тем как добавить код в программу, можно проверить его работу в REPL.

3. Быстрые вычисления: REPL — это мощный калькулятор, который всегда под рукой.

4. Отладка: когда программа работает неправильно, можно использовать REPL, чтобы отдельно проверить отдельные части кода.

5. Изучение библиотек: когда осваиваете новую библиотеку, можно импортировать её в REPL и интерактивно пробовать функции.

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

1.3.7) Выход из REPL

Когда вы закончили работать в REPL, выйти можно несколькими способами:

>>> exit()

Или:

>>> quit()

Или с помощью комбинаций клавиш:

• Windows: нажмите Ctrl + Z, затем Enter
• macOS/Linux: нажмите Ctrl + D

После выхода вы вернётесь в обычную командную строку или терминал.

1.4) Создание и запуск файловых скриптов на Python

REPL отлично подходит для экспериментов и быстрых тестов, но что делать, если вы хотите сохранить код и запускать его снова? А если вы хотите написать более длинную программу — с десятками или сотнями строк? В таких случаях нужны script files — постоянные файлы с кодом Python, которые можно редактировать, сохранять и запускать многократно.

Хотя REPL прекрасно подходит для экспериментов, большая часть программирования на Python связана с написанием файловых скриптов — текстовых файлов с кодом Python, которые можно сохранять, редактировать и запускать снова и снова. В этом разделе вы создадите свой первый скрипт на Python и научитесь запускать его из командной строки.

1.4.1) Что такое скрипт на Python?

Скрипт на Python — это просто текстовый файл с кодом Python, сохранённый с расширением .py. В отличие от кода, вводимого в REPL, файлы со скриптами:

• являются постоянными — вы можете сохранять их и запускать позднее
• легко редактируются и изменяются
• могут содержать сколько угодно кода
• можно передавать другим людям
• можно запускать автоматически или по расписанию

Скрипт можно сравнить с записанным рецептом, тогда как REPL — это как готовка «с ходу», без записанного рецепта. И то, и другое полезно, но для чего‑то серьёзного вам почти всегда понадобится скрипт.

1.4.2) Выбор текстового редактора

Для создания скриптов на Python нужен текстовый редактор. Не используйте текстовые процессоры вроде Microsoft Word или Google Docs — они добавляют форматирование, которое Python не понимает.

Хорошие варианты для начинающих:

1. IDLE: поставляется вместе с Python. Простой и ориентирован на обучение.

   • В Windows: найдите "IDLE" в меню «Пуск»
   • В macOS/Linux: введите idle3 в терминале

2. Visual Studio Code (VS Code): бесплатный, мощный, широко используемый профессионалами. Отличная поддержка Python через расширения.

   • Скачать: https://code.visualstudio.com/

3. PyCharm Community Edition: полноценная IDE (Integrated Development Environment), специально для Python.

   • Скачать: https://www.jetbrains.com/pycharm/

4. Notepad++ (только Windows): лёгкий и простой редактор.

   • Скачать: https://notepad-plus-plus.org/

5. Sublime Text: быстрый и удобный, с хорошей поддержкой Python.

   • Скачать: https://www.sublimetext.com/

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

1.4.3) Создание первого скрипта на Python

Создадим простой скрипт на Python, который выводит приветственные сообщения.

Шаг 1: Создайте новый файл

Откройте выбранный текстовый редактор и создайте новый файл. Сохраните его под именем hello.py в месте, которое легко запомнить (например, на рабочем столе или в отдельной папке для проектов на Python).

Важно: расширение .py критично. Оно говорит операционной системе и редактору, что это файл Python.

Шаг 2: Напишите код

Введите в файл следующий код:

# hello.py
# My first Python script
 
print("Hello, World!")
print("Welcome to Python programming!")

Строки, начинающиеся с #, — это comments: заметки для людей, читающих код. Python полностью их игнорирует. Комментарии помогают вам помнить, что делает код, и помогают другим понять вашу работу. Мы подробнее поговорим о комментариях в главе 2.

Шаг 3: Сохраните файл

Сохраните файл. Убедитесь, что он сохранён именно как hello.py, а не hello.py.txt или с другим расширением.

Разберём, что делает этот код:

• print("Hello, World!") велит Python вывести на экран текст "Hello, World!".
• print("Welcome to Python programming!") выводит ещё одно сообщение.

Добавим ещё один пример, чтобы восполнить промежуток перед переходом к более сложным скриптам:

# greetings.py
# A script with multiple print statements
 
print("Python is fun!")
print("Let's learn together.")
print("This is exciting!")

Сохраните это как greetings.py. В этом примере используются три оператора print, но ещё нет переменных, что помогает освоиться с базовой структурой перед переходом к более сложным концепциям.

1.4.4) Запуск скрипта из командной строки

Теперь, когда вы создали скрипт, давайте его запустим.

Шаг 1: Откройте командную строку / терминал

• Windows: откройте Command Prompt
• macOS/Linux: откройте Terminal

Шаг 2: Перейдите в папку со скриптом

Используйте команду cd (change directory), чтобы перейти в каталог, где вы сохранили hello.py. Например, если вы сохранили его на рабочем столе:

Windows:

cd Desktop

macOS/Linux:

cd ~/Desktop

Если при попытке запуска скрипта вы видите ошибку вроде "No such file or directory", скорее всего, вы находитесь не в той папке. Используйте cd, чтобы перейти в каталог, где находится ваш скрипт.

Чтобы убедиться, что вы в нужном месте, можно вывести список файлов:

Windows:

dir

macOS/Linux:

ls

В списке должен быть файл hello.py.

Шаг 3: Запустите скрипт

Windows:

python hello.py

macOS/Linux:

python3 hello.py

Вы должны увидеть:

Hello, World!
Welcome to Python programming!

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

1.4.5) Как выполняется скрипт

Когда вы запускаете скрипт Python, происходит следующее:

1. Вы вводите команду для запуска скрипта
2. Операционная система запускает интерпретатор Python
3. Интерпретатор читает весь файл со скриптом
4. Он проверяет код на синтаксические ошибки (ошибки в записи кода)
5. Если ошибки есть, Python выводит сообщение об ошибке и прекращает работу
6. Если ошибок нет, интерпретатор выполняет код построчно сверху вниз
7. Любой вывод (через print()) отображается
8. Когда скрипт заканчивает работу, управление возвращается в командную строку

1.4.6) Более сложный пример

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

# simple_variable.py
# Using a variable for the first time
 
message = "Hello, Python!"
print(message)

Output:

Hello, Python!

Этот пример связывает понятия простых операторов print() и переменных. Теперь посмотрим на скрипт с несколькими переменными:

# student_info.py
# A script that uses variables and multiple print statements
 
name = "Alice"
age = 25
city = "New York"
 
print("Student Information")
print("-------------------")
print("Name:", name)
print("Age:", age)
print("City:", city)

Сохраните файл как student_info.py и запустите:

Windows:

python student_info.py

macOS/Linux:

python3 student_info.py

Output:

Student Information
-------------------
Name: Alice
Age: 25
City: New York

Этот скрипт показывает:

• создание переменных (подробнее о переменных мы поговорим в главе 3)
• использование нескольких операторов print()
• вывод как литерального текста, так и значений переменных

1.4.7) Рекомендации по работе со скриптами

Даже на этом раннем этапе полезно выработать правильные привычки:

1. Используйте понятные имена файлов: называйте файлы в соответствии с их назначением. student_info.py лучше, чем test.py или program1.py, потому что через полгода по названию будет легче вспомнить, что делает файл.

2. Держите скрипты в порядке: создайте отдельную папку для проектов на Python. Не раскидывайте скрипты по всему компьютеру. Так проще находить свои работы и поддерживать порядок.

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

4. Один скрипт — одна основная задача: каждый скрипт должен иметь одну главную цель. Не пытайтесь запихнуть несколько несвязанных задач в один файл. Это упрощает понимание и поддержку кода.

5. Часто тестируйте: запускайте скрипт по мере написания, а не ждите, пока напишете 100 строк. Запускайте после каждых нескольких строк. Так вы будете раньше замечать ошибки, когда их проще исправить.

1.5) Первый взгляд на ошибки и трассировки (traceback)

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

1.5.1) Типы ошибок

Python различает две основные категории ошибок:

Syntax Errors: ошибки в том, как вы написали код — нарушения грамматических правил Python. Python обнаруживает их до начала выполнения программы. Можно сравнить синтаксические ошибки с грамматическими ошибками в тексте — Python просто не понимает, что вы пытаетесь сказать.

Exceptions: ошибки, возникающие во время выполнения кода. Синтаксис в порядке, но при выполнении что‑то пошло не так. Исключения похожи на проблемы «во время выполнения» — Python понимает вашу команду, но не может её выполнить.

Рассмотрим обе категории на примерах.

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

Syntax error возникает, когда код нарушает правила Python. В этом случае Python даже не начинает его выполнение — он не понимает написанное.

Example 1: Missing Colon

Создайте файл syntax_error1.py:

# syntax_error1.py
# This code has a syntax error
 
if 5 > 3
    print("Five is greater than three")

При попытке запуска:

python syntax_error1.py

Вы увидите:

  File "syntax_error1.py", line 4
    if 5 > 3
            ^
SyntaxError: expected ':'

Python сообщает вам несколько вещей:

• В каком файле ошибка: syntax_error1.py
• В какой строке ошибка: строка 4
• Где в строке ошибка: символ ^ указывает место
• Тип ошибки: SyntaxError
• Полезное пояснение: expected ':'

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

# syntax_error1_fixed.py
# Fixed version
 
if 5 > 3:
    print("Five is greater than three")

Output:

Five is greater than three

Example 2: Mismatched Quotes

# syntax_error2.py
# Another syntax error example
 
message = "Hello, World!'
print(message)

При запуске:

  File "syntax_error2.py", line 4
    message = "Hello, World!'
              ^
SyntaxError: unterminated string literal (detected at line 4)

Проблема в том, что строка начинается с двойной кавычки ("), а заканчивается одинарной ('). Python требует совпадающих кавычек. Исправим, используя одинаковые кавычки:

# syntax_error2_fixed.py
# Fixed version
 
message = "Hello, World!"
print(message)

Output:

Hello, World!

1.5.3) Исключения времени выполнения

Runtime exceptions (или просто «исключения») возникают, когда код синтаксически корректен, но при выполнении случается ошибка.

Example 1: NameError

# name_error.py
# This code will cause a NameError
 
print(greeting)

При запуске:

python name_error.py

Вы увидите:

Traceback (most recent call last):
  File "name_error.py", line 4, in <module>
    print(greeting)
          ^^^^^^^^
NameError: name 'greeting' is not defined

Это называется traceback. Разберём её:

• Строка "Traceback (most recent call last):" означает, что далее следует трассировка — путь, по которому выполнение дошло до ошибки.
• Информация о файле и строке: File "name_error.py", line 4, in <module> показывает, в каком файле и в какой строке произошла ошибка.
• Проблемная строка: print(greeting) показывает, какой именно код не сработал.
• Тип ошибки: NameError — тип возникшей ошибки.
• Описание ошибки: name 'greeting' is not defined объясняет, что вы пытаетесь использовать переменную, которая не определена.

Чтобы исправить, нужно сначала определить переменную:

# name_error_fixed.py
# Fixed version
 
greeting = "Hello!"
print(greeting)

Output:

Hello!

Example 2: TypeError

# type_error.py
# This code will cause a TypeError
 
number = 5
text = "The number is "
result = text + number
print(result)

При запуске:

Traceback (most recent call last):
  File "type_error.py", line 6, in <module>
    result = text + number
             ~~~~~^~~~~~~~
TypeError: can only concatenate str (not "int") to str

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

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

# type_error_fixed.py
# Fixed version
 
number = 5
text = "The number is "
result = text + str(number)
print(result)

Output:

The number is 5

Example 3: ZeroDivisionError

Что будет, если попробовать делить на ноль?

# zero_division.py
# This code will cause a ZeroDivisionError
 
result = 10 / 0
print(result)

При запуске:

Traceback (most recent call last):
  File "zero_division.py", line 4, in <module>
    result = 10 / 0
             ~~~^~~
ZeroDivisionError: division by zero

Эта ошибка достаточно очевидна: делить на ноль нельзя. Математически это не определено, поэтому Python вызывает ошибку.

1.5.4) Эффективное чтение трассировок

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

1. Начните с нижней строки: сначала посмотрите на тип ошибки и её сообщение.
2. Поймите ошибку: что Python сообщает о проблеме?
3. Найдите место ошибки: посмотрите на имя файла и номер строки.
4. Проверьте строку кода: откройте эту строку в файле.
5. При необходимости двигайтесь назад: иногда реальная причина кроется в строке выше той, на которую указывает Python.

1.5.5) Частые ошибки новичков

Вот несколько ошибок, с которыми вы почти наверняка столкнётесь в процессе изучения Python:

Ошибки отступов (Indentation Errors):

Python использует отступы (пробелы или табуляцию в начале строки) для обозначения блоков кода. Неверные отступы вызывают ошибки:

# indentation_error.py
# Incorrect indentation
 
print("First line")
    print("Second line")  # This line is incorrectly indented

Ошибка:

  File "indentation_error.py", line 5
    print("Second line")
    ^
IndentationError: unexpected indent

Опечатки и ошибки в регистре (Spelling Mistakes):

В Python важен регистр букв. Print — это не то же самое, что print:

# spelling_error.py
# Incorrect capitalization
 
Print("Hello")  # Should be print, not Print

Ошибка:

Traceback (most recent call last):
  File "spelling_error.py", line 4, in <module>
    Print("Hello")
    ^^^^^
NameError: name 'Print' is not defined

Отсутствующие круглые скобки (Missing Parentheses):

В Python 3 функция print требует круглых скобок:

# missing_parentheses.py
# Missing parentheses
 
print "Hello"  # Should be print("Hello")

Ошибка:

  File "missing_parentheses.py", line 4
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

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

1.5.6) Стратегии работы с ошибками

Когда вы сталкиваетесь с ошибкой:

1. Не паникуйте: ошибки — это нормально. Каждый программист видит их постоянно.

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

3. Проверьте номер строки: перейдите к указанной строке и посмотрите, что в ней не так.

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

5. Проверьте частые ошибки: отсутствующие двоеточия, несоответствующие кавычки, неверные отступы и опечатки встречаются очень часто.

6. Исправляйте по шагам: исправляйте по одной вещи и каждый раз тестируйте.

7. Используйте REPL: если вы в чём‑то не уверены, попробуйте это в REPL.

8. Ищите сообщение об ошибке в интернете: если вы не понимаете сообщение, поищите его. Часто вы найдёте объяснение и решение.

1.5.7) Полный пример с ошибками и исправлением

Рассмотрим скрипт с несколькими ошибками и исправим их по шагам. Эта программа должна выводить информацию о студенте и считать его возраст через 10 лет:

Исходный вариант (с ошибками):

# buggy_student.py
# This program has several errors
 
student_name = "Alice
student_age = 25
 
print("Name:", student_name)
print("Age:" student_age)
print("In 10 years, you will be", student_age + "10")

При запуске возникает несколько ошибок. Исправим их по очереди:

Error 1: Unterminated string

  File "buggy_student.py", line 4
    student_name = "Alice
                   ^
SyntaxError: unterminated string literal (detected at line 4)

Fix: добавить закрывающую кавычку:

student_name = "Alice"

После исправления ошибки 1 появляется Error 2: Missing comma

  File "buggy_student.py", line 8
    print("Age:" student_age)
                 ^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Fix: добавить запятую между строкой и переменной:

print("Age:", student_age)

После исправления ошибки 2 появляется Error 3: Type error

Traceback (most recent call last):
  File "buggy_student.py", line 9, in <module>
    print("In 10 years, you will be", student_age + "10")
                                      ~~~~~~~~~~~~^~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Fix: использовать число 10 как целое, а не строку:

print("In 10 years, you will be", student_age + 10)

Итоговая исправленная версия:

# buggy_student_fixed.py
# Fixed version of the program
 
student_name = "Alice"
student_age = 25
 
print("Name:", student_name)
print("Age:", student_age)
print("In 10 years, you will be", student_age + 10)

Output:

Name: Alice
Age: 25
In 10 years, you will be 35

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

1.6) Когда использовать интерактивную оболочку, а когда — файловые скрипты

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

1.6.1) Используйте интерактивную оболочку (REPL), когда:

1. Осваиваете новые концепции

Когда вы изучаете что‑то новое, REPL даёт мгновенную обратную связь:

>>> # Testing string methods
>>> text = "hello world"
>>> text.upper()
'HELLO WORLD'
>>> text.title()
'Hello World'
>>> text.capitalize()
'Hello world'

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

2. Тестируете небольшие фрагменты кода

Перед тем как добавить код в программу, проверьте его в REPL:

>>> # Testing a calculation
>>> price = 19.99
>>> quantity = 3
>>> total = price * quantity
>>> total
59.97
>>> # Looks good, now I can add this to my script

3. Делаете быстрые вычисления

REPL всегда доступен как калькулятор:

>>> # How many seconds in a day?
>>> 24 * 60 * 60
86400
>>> # What's 15% of 250?
>>> 250 * 0.15
37.5

4. Отлаживаете код

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

>>> # My script isn't working. Let me test this part:
>>> numbers = [1, 2, 3, 4, 5]
>>> sum(numbers) / len(numbers)
3.0
>>> # This works, so the problem must be elsewhere

Note: о списках (lists) мы будем говорить в главе 13. Этот пример показывает, как REPL помогает тестировать отдельные фрагменты кода.

1.6.2) Используйте файловые скрипты, когда:

1. Пишете программы, которые хотите сохранить

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

# temperature_converter.py
# A program to convert Fahrenheit to Celsius
 
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5/9
print("Temperature:", fahrenheit, "°F is", round(celsius, 1), "°C")

Output:

Temperature: 98.6 °F is 37.0 °C

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

2. Пишете многострочные программы

Хотя многострочный код можно писать и в REPL, для чего‑то существенного это неудобно. Используйте файловый скрипт:

# grade_calculator.py
# Calculate final grade from multiple scores
 
homework = 85
midterm = 78
final = 92
 
# Calculate weighted average
final_grade = (homework * 0.3) + (midterm * 0.3) + (final * 0.4)
 
print("Final Grade:", final_grade)

Output:

Final Grade: 85.3

3. Хотите делиться кодом с другими

Файловые скрипты легко пересылать, в отличие от сессий REPL:

# greeting.py
# A simple greeting program
 
name = input("What is your name? ")
print("Hello,", name + "! Welcome to Python.")

Note: о функции input() мы поговорим в главе 2. Этот пример показывает, как скрипты можно передавать другим.

Вы можете отправить этот файл кому‑то ещё, и он сможет запустить его у себя.

4. Создаёте многоразовые инструменты

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

# file_counter.py
# Count files in a directory
 
import os
 
directory = "."  # Current directory
files = [f for f in os.listdir(directory) if os.path.isfile(f)]
print("Number of files:", len(files))

Note: о модуле os и импорте модулей мы поговорим в главе 22, о списковых включениях — в главе 34. Этот пример показывает, как файловые скрипты могут служить многоразовыми инструментами.

5. Разрабатываете сложную логику

Для чего‑то, что содержит несколько функций, классов или сложную логику, используйте файловые скрипты:

# password_checker.py
# Check password strength
 
def check_password_strength(password):
    """Check if a password meets basic requirements."""
    if len(password) < 8:
        return "Too short"
    if not any(c.isupper() for c in password):
        return "Needs uppercase letter"
    if not any(c.isdigit() for c in password):
        return "Needs number"
    return "Strong password"
 
# Test the function
test_password = "MyPass123"
result = check_password_strength(test_password)
print("Password '" + test_password + "':", result)

Output:

Password 'MyPass123': Strong password

Note: о функциях (functions) мы будем говорить в главе 19. Этот пример показывает, как скрипты позволяют организовывать сложную логику.

6. Автоматизируете задачи

Скрипты прекрасно подходят для автоматизации:

# backup_reminder.py
# Remind user to backup files
 
import datetime
 
today = datetime.date.today()
day_of_week = today.strftime("%A")
 
if day_of_week == "Friday":
    print("Don't forget to backup your files!")
else:
    print("Backup reminder: Next backup on Friday")

Note: о модуле datetime мы будем говорить в главе 39. Этот пример показывает, как скрипты могут автоматизировать задачи.

1.6.3) Практичный рабочий процесс

Профессиональные программисты на Python обычно сочетают использование REPL и файловых скриптов:

Example Workflow:

1. Explore in REPL: попробуйте новую концепцию или посчитайте что‑то.
2. Prototype in REPL: создайте небольшую рабочую версию.
3. Move to Script: когда всё работает, поместите код в файловый скрипт.
4. Expand in Script: добавьте новые функции, обработку ошибок и т. д.
5. Debug with REPL: если что‑то ломается, тестируйте части программы в REPL.
6. Finalize Script: допишите, протестируйте и сохраните финальную версию.

1.6.4) Конкретный пример

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

Step 1: Explore in REPL

>>> # What's the formula? Area = π * r²
>>> # Let me use a simple approximation for π
>>> 3.14159 * 5 * 5
78.53975
>>> # Looks right!

Step 2: Create a Script

Теперь, когда вы уверены, что всё работает, создайте circle_area.py:

# circle_area.py
# Calculate the area of a circle
 
radius = 5
pi = 3.14159
area = pi * radius * radius
 
print("Radius:", radius)
print("Area:", area)

Output:

Radius: 5
Area: 78.53975

Step 3: Enhance the Script

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

# circle_area_enhanced.py
# Calculate area for multiple circles
 
radii = [3, 5, 7, 10]
pi = 3.14159
 
for radius in radii:
    area = pi * radius * radius
    print("Circle with radius", radius, "has area", round(area, 2))

Output:

Circle with radius 3 has area 28.27
Circle with radius 5 has area 78.54
Circle with radius 7 has area 153.94
Circle with radius 10 has area 314.16

Note: о циклах for (for loops) мы поговорим в главе 11. В главе 2 мы научимся делать такую программу интерактивной, запрашивая радиус у пользователя.

Такой подход — сначала экспериментировать в REPL, затем оформлять решение в виде файлового скрипта — типичен для разработки программ на Python.

1.6.5) Основные выводы

Сильные стороны REPL:

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

Ограничения REPL:

• код не сохраняется
• неудобен для большого многострочного кода
• им сложно делиться
• не подходит для сложных программ

Сильные стороны файловых скриптов:

• код сохраняется постоянно
• его легко редактировать и изменять
• можно делиться с другими
• подходят для сложных программ
• можно запускать многократно
• можно автоматизировать запуск

Ограничения файловых скриптов:

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

Лучший подход — комбинировать оба инструмента: REPL — для обучения, быстрых тестов и экспериментов, а файловые скрипты — для всего, что вы хотите сохранить, передать или запускать многократно.

1.7) Какую версию Python использует эта книга (и почему это важно)

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

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

1.7.1) Python 2 против Python 3

Самое большое разделение в истории Python — между Python 2 и Python 3.

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

Python 3 был выпущен в 2008 году как крупный редизайн, исправляющий эти проблемы. При этом он не совместим обратно с Python 2: код, написанный для Python 2, часто не работал в Python 3 без изменений.

Много лет обе версии сосуществовали. Однако с 1 января 2020 года Python 2 снят с поддержки. Это означает:

• для Python 2 больше нет обновлений и исправлений безопасности
• всё новое развитие Python идёт вокруг Python 3
• все крупные библиотеки перешли на Python 3
• изучать Python 2 сегодня не рекомендуется

Эта книга использует только Python 3. Все примеры кода написаны для Python 3 и могут не работать в Python 2.

1.7.2) Минорные версии Python 3

Внутри Python 3 есть минорные версии (3.6, 3.7, 3.8, 3.9, 3.10, 3.11, 3.12 и т. д.). Каждая минорная версия добавляет новые возможности и улучшения, сохраняя при этом обратную совместимость с предыдущими версиями Python 3.

Эта книга написана для Python 3.11 и новее, но большинство примеров будет работать в Python 3.8 и выше.

Чтобы узнать версию Python:

python --version  # Windows
python3 --version  # macOS/Linux

Вы увидите, например:

Python 3.11.5

Если вы видите:

Python 2.7.18

значит, у вас запущен устаревший Python 2. Установите Python 3 по инструкции из раздела 1.2.

1.7.3) Важные различия, с которыми вы можете столкнуться

Если вы читаете старые учебники или код в интернете (особенно старые уроки и ответы на Stack Overflow до 2020 года), вы можете встретить синтаксис, который не работает в Python 3. Вот самые распространённые отличия:

1. print как оператор и как функция

Python 2:

print "Hello, World!"  # No parentheses

Python 3:

print("Hello, World!")  # Parentheses required

В Python 3 print — это функция, и нужны круглые скобки. Это самое заметное отличие.

2. Поведение деления

Эти изменения сделали Python более последовательным и безопасным. Например, превращение print в функцию позволяет обращаться с ним как с любой другой функцией, а то, что / всегда делает вещественное деление, устраняет распространённый источник ошибок.

Python 2:

>>> 5 / 2
2  # Integer division
>>> 5.0 / 2
2.5  # Float division

Python 3:

>>> 5 / 2
2.5  # Always float division
>>> 5 // 2
2  # Integer division (floor division)

В Python 3 оператор / всегда выполняет вещественное деление. Для целочисленного деления используйте //.

3. Функция input()

Python 2:

name = raw_input("Enter your name: ")  # Returns string
age = input("Enter your age: ")  # Evaluates input as Python code (dangerous!)

Python 3:

name = input("Enter your name: ")  # Always returns string
age = int(input("Enter your age: "))  # Convert to int if needed

В Python 3 input() всегда возвращает строку, что безопаснее и логичнее.

4. Строки и Unicode

Python 3 намного лучше работает с текстом (Unicode), чем Python 2. Все строки в Python 3 по умолчанию являются Unicode, что сильно упрощает работу с международным текстом.

1.7.4) Возможности по версиям Python 3

Разные версии Python 3 вводили новые возможности. Важно знать следующее:

Python 3.6 (декабрь 2016):

• f‑строки для форматирования строк (мы будем активно их использовать)

# f_string_example.py
name = "Alice"
print("Hello, " + name + "!")

Output:

Hello, Alice!

Note: f‑строки мы изучим в главе 6. Пока что мы используем простую конкатенацию строк с помощью +.

Python 3.8 (октябрь 2019):

• оператор «морж» (:=) для присваивания в выражениях (мы поговорим о нём в главе 40)

Python 3.10 (октябрь 2021):

• структурное сопоставление с образцом (match и case) (мы рассмотрим его в главе 12)

Python 3.11 (октябрь 2022):

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

Python 3.12 (октябрь 2023):

• дальнейшие улучшения производительности
• новые возможности аннотаций типов
• улучшенный синтаксис f‑строк

1.7.5) Какую версию лучше использовать?

Рекомендуется использовать Python 3.11 или новее, если есть возможность. Причины:

1. Лучшие сообщения об ошибках: в Python 3.11 они стали гораздо более понятными для новичков.

2. Лучшая производительность: Python 3.11 быстрее ранних версий.

3. Современные возможности: вы получите доступ ко всем новейшим средствам языка.

4. Запас на будущее: код, написанный для Python 3.11, будет работать и в будущих версиях.

Тем не менее, для изучения по этой книге подойдёт любая версия Python 3.8 и выше. Основные концепции остаются одинаковыми.

1.7.6) Проверка доступности возможностей

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

Например, если вы используете Python 3.5 или раньше, возможно, вам придётся использовать более старый способ форматирования строк:

# format_example.py
# Works in all Python 3 versions
name = "Alice"
print("Hello, {}!".format(name))

Output:

Hello, Alice!

1.7.7) Как оставаться в курсе

Новые минорные версии Python выходят примерно раз в год. Хотя нет необходимости обновляться сразу, полезно оставаться относительно актуальным:

• Проверяйте обновления каждые несколько месяцев
• Читайте заметки о релизах, чтобы узнать о новых возможностях
• Обновляйтесь, когда удобно, особенно ради исправлений безопасности
• Тестируйте свой код после обновления, чтобы убедиться в совместимости

Найти релизы Python и документацию можно на https://www.python.org/.

1.7.8) Совместимость версий в этой книге

В этой книге:

• Все примеры кода работают в Python 3.11+
• Большинство примеров работает в Python 3.8+
• Версионные особенности явно помечены (например, «Требуется Python 3.10+»)
• При необходимости приводятся альтернативные подходы для старых версий

Видя пример кода в этой книге, вы можете уверенно набирать его в Python 3.11 или новее и ожидать именно такого результата, как показано.

1.7.9) Замечание о коде Python 2, который вы можете встретить в интернете

Ища помощь по Python в интернете, вы можете наткнуться на примеры для Python 2. Важно уметь их распознавать.

Признаки кода для Python 2:

• print без скобок: print "Hello"
• функция raw_input()
• деление, выдающее целое: 5 / 2 равно 2
• старый стиль форматирования строк: "Hello %s" % name
• комментарии вроде «Python 2» или указание версии 2.x

Что делать:

• ищите аналоги для Python 3
• добавляйте «python 3» к поисковым запросам
• проверяйте дату — материалы до 2020 года часто относятся к Python 2
• пользуйтесь официальной документацией Python 3: https://docs.python.org/3/

Поздравляем! Вы завершили главу 1 и сделали свои первые шаги в мире Python. Теперь вы знаете:

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

Теперь вы готовы переходить к главе 2, где будете писать свои первые полноценные программы на Python, подробно разберёте функцию print() и начнёте работать с вводом пользователя. Основа, которую вы заложили в этой главе, будет поддерживать всё дальнейшее обучение.