2. Ваши первые программы на Python

В главе 1 вы узнали, как установить Python, пользоваться интерактивной оболочкой (REPL) и запускать простые файлы‑скрипты. Вы также впервые увидели ошибки и трассировки (tracebacks). Теперь пришло время написать ваши первые настоящие программы на Python — программы, которые выводят информацию, принимают ввод от пользователей и производят осмысленные результаты.

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

2.1) Вывод текста с помощью функции print()

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

2.1.1) Базовый вывод

В самом простом случае print() выводит текст, заключённый в кавычки. Давайте создадим файл‑скрипт и посмотрим, как это работает:

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

Когда вы запускаете этот скрипт, Python выводит:

Hello, World!

Текст в кавычках — "Hello, World!" — называется строкой (string). Строка — это последовательность символов (буквы, цифры, знаки, пробелы), которую Python рассматривает как текст. Мы подробно изучим строки в главе 5, но пока воспринимайте их как способ представления текста в Python.

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

# greetings.py
print("Welcome to Python programming!")
print("This is your first real program.")
print("Python makes programming fun and accessible.")

Output:

Welcome to Python programming!
This is your first real program.
Python makes programming fun and accessible.

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

2.1.2) Вывод нескольких элементов

Функция print() может выводить несколько элементов за один вызов, если разделить их запятыми:

# multiple_items.py
print("Python", "is", "awesome!")
print("I", "am", "learning", "to", "code")

Output:

Python is awesome!
I am learning to code

Когда вы разделяете элементы запятыми, print() автоматически вставляет между ними пробел. Это удобно для комбинирования нескольких фрагментов текста без необходимости вручную добавлять пробелы.

Вы также можете смешивать разные типы данных. Например, можно выводить и текст, и числа:

# mixed_output.py
print("The answer is", 42)
print("Python version", 3.12, "is powerful")

Output:

The answer is 42
Python version 3.12 is powerful

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

2.1.3) Одинарные и двойные кавычки

Python принимает как одинарные ('), так и двойные (") кавычки для строк. Для простого текста они полностью взаимозаменяемы:

# quotes.py
print("This uses double quotes")
print('This uses single quotes')
print("Both work exactly the same way")

Output:

This uses double quotes
This uses single quotes
Both work exactly the same way

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

# apostrophes.py
print("It's a beautiful day!")
print("Python's syntax is clean")

Output:

It's a beautiful day!
Python's syntax is clean

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

# This causes an error:
print('It's a beautiful day!')  # Error! Python sees three separate quotes

Ошибка возникает потому, что Python воспринимает апостроф в "It's" как конец строки, оставляя "s a beautiful day!" как недопустимый код.

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

# quotations.py
print('She said, "Hello!"')
print('The book is called "Python Basics"')

Output:

She said, "Hello!"
The book is called "Python Basics"

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

2.1.4) Вывод пустых строк

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

# spacing.py
print("First section of output")
print("More information here")
print()  # Empty line
print("Second section of output")
print("This is separated from the first section")

Output:

First section of output
More information here
 
Second section of output
This is separated from the first section

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

2.1.5) Специальные символы в строках

Иногда вам нужно включить в вывод специальные символы, которые нельзя просто напечатать или которые имеют особое значение в Python. Например, как сделать перевод строки в середине строки? Или добавить табуляцию для выравнивания? Python предоставляет escape‑последовательности — специальные двухсимвольные комбинации, начинающиеся с обратной косой черты (\), — для представления таких символов.

Эти escape‑последовательности особенно полезны, когда нужно отформатировать вывод определённым образом — создать многострочные сообщения, выровнять столбцы данных или работать с путями к файлам в Windows. По мере написания программ вы будете часто использовать \n.

Наиболее распространённая escape‑последовательность — \n, обозначающая перевод строки (line break):

# newlines.py
print("First line\nSecond line\nThird line")

Output:

First line
Second line
Third line

Последовательность \n говорит Python перейти на новую строку в этой точке строки. Это полезно, когда вы хотите создать несколько строк вывода одним вызовом print().

Другая полезная escape‑последовательность — \t, обозначающая табуляцию (горизонтальный отступ):

# tabs.py
print("Name:\tJohn")
print("Age:\t25")
print("City:\tNew York")

Output:

Name:	John
Age:	25
City:	New York

Символ \t создаёт равномерный отступ, выравнивая значения в подобие колонок.

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

# backslash.py
print("The file path is C:\\Users\\Documents")

Output:

The file path is C:\Users\Documents

Мы подробно рассмотрим escape‑последовательности и работу со строками в главе 5. Пока достаточно знать, что \n создаёт новые строки, а \t — табуляции.

2.2) Использование комментариев для объяснения кода

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

2.2.1) Однострочные комментарии

В Python любой текст после символа # в строке является комментарием. Python игнорирует всё от # до конца строки:

# comment_example.py
# This is a comment. Python ignores this line completely.
print("This line runs")  # This comment explains the print statement
# print("This line does NOT run because it's commented out")
print("This line also runs")

Output:

This line runs
This line also runs

Обратите внимание, что второй оператор print() не выполнился, потому что вся строка закомментирована. Это полезно, когда вы хотите временно отключить часть кода, не удаляя её.

Комментарии могут располагаться на отдельной строке или в конце строки с кодом. Оба стиля распространены:

# display_info.py
# Display a welcome message to the user
print("Welcome to the program!")
 
print("Processing data...")  # Inform the user of progress

2.2.2) Когда и как писать хорошие комментарии

Комментарии должны объяснять, зачем вы что‑то делаете, а не просто что делает код. Вот пример плохого комментария:

# Bad comment - just repeats what the code obviously does
print("Hello")  # Print "Hello"

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

Лучший подход:

# Good comment - explains the purpose or context
# Greet the user before requesting their information
print("Hello")

Этот комментарий объясняет, зачем мы выводим "Hello" — это часть более широкого взаимодействия с пользователем.

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

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

Вот пример эффективного комментирования:

# temperature_converter.py
# This program converts temperatures from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
# Display program title
print("Temperature Converter")
print("Fahrenheit to Celsius")
print()
 
# We'll learn how to get user input in section 2.4
# For now, we'll use a fixed temperature value
fahrenheit = 75  # Temperature in Fahrenheit to convert
 
# Perform the conversion using the standard formula
# Subtract 32 first (order matters due to the formula)
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print("Temperature:", fahrenheit, "°F =", celsius, "°C")

Output:

Temperature Converter
Fahrenheit to Celsius
 
Temperature: 75 °F = 23.88888888888889 °C

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

2.2.3) Многострочные комментарии и docstring'и

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

# multi_line_comments.py
# This program demonstrates a longer explanation
# that spans multiple lines. Each line starts
# with a # symbol.
print("Program starts here")

В Python нет специального синтаксиса многострочных комментариев, как в некоторых других языках. Однако есть альтернативный подход с использованием строк в тройных кавычках. Мы узнаем о нём больше в главе 19, когда будем обсуждать docstring'и (документационные строки для функций), но вот предварительный пример:

# docstring_preview.py
"""
This is a multi-line string that can serve as a comment.
It's not technically a comment—it's a string that Python
creates but doesn't use. However, it's often used for
longer explanations at the beginning of files.
"""
print("Program starts here")

Пока что придерживайтесь # для комментариев. Мы рассмотрим строки в тройных кавычках и их правильное использование в последующих главах.

2.2.4) Комментирование кода для тестирования

Комментарии также полезны для временного отключения кода во время тестирования:

# testing.py
print("This always runs")
# print("This is disabled for testing")
print("This also always runs")

Эта техника называется "закомментировать код" (commenting out). Она полезна, когда вы хотите проверить, как ведёт себя программа без определённых строк, но не хотите удалять эти строки навсегда.

2.3) Введение в переменные и присваивание (предварительный обзор)

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

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

2.3.1) Создание переменных с помощью присваивания

Вы создаёте переменную с помощью оператора присваивания (=). Базовый шаблон:

variable_name = value

Имя переменной находится слева, значение — справа, а знак = соединяет их:

# variables_basic.py
message = "Hello, Python!"
print(message)

Output:

Hello, Python!

Что здесь происходит:

1. Python создаёт переменную с именем message.
2. Python сохраняет строку "Hello, Python!" в этой переменной.
3. Когда мы используем message в функции print(), Python извлекает сохранённое значение и выводит его.

Переменные могут хранить разные типы данных. Вот несколько примеров:

# variable_types.py
greeting = "Welcome!"  # A string (text)
age = 25  # A number (integer)
price = 19.99  # A number with a decimal point (float)
is_student = True  # A boolean (True or False)
 
print(greeting)
print(age)
print(price)
print(is_student)

Output:

Welcome!
25
19.99
True

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

2.3.2) Почему переменные полезны

Переменные делают ваш код более гибким и удобным для сопровождения. Сравните два подхода:

Без переменных:

# no_variables.py
print("Welcome, John!")
print("John, your account balance is $1000")
print("Thank you for banking with us, John!")

С переменными:

# with_variables.py
name = "John"
balance = 1000
 
print("Welcome,", name + "!")
print(name, "your account balance is $", balance)
print("Thank you for banking with us,", name + "!")

Обе программы дают схожий вывод, но версия с переменными имеет важные преимущества:

1. Лёгкость изменений: чтобы изменить имя, нужно исправить только одну строку (name = "John"), а не три.
2. Меньше ошибок: вы не можете случайно ошибиться в написании имени в одном из мест.
3. Больше гибкости: позже вы сможете изменить способ получения значения name (например, спросить пользователя).

2.3.3) Повторное присваивание переменным

Переменные могут менять свои значения во время выполнения программы. Это называется повторное присваивание:

# reassignment.py
score = 0
print("Initial score:", score)
 
score = 10
print("After first update:", score)
 
score = 25
print("After second update:", score)

Output:

Initial score: 0
After first update: 10
After second update: 25

Каждый раз, когда вы присваиваете переменной новое значение, Python заменяет старое значение новым. Предыдущее значение отбрасывается.

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

# updating_values.py
count = 5
print("Starting count:", count)
 
count = count + 1  # Add 1 to count
print("After adding 1:", count)
 
count = count + 10  # Add 10 to count
print("After adding 10:", count)

Output:

Starting count: 5
After adding 1: 6
After adding 10: 16

Этот шаблон — count = count + 1 — чрезвычайно распространён в программировании. Он означает: "возьми текущее значение count, прибавь к нему 1 и сохрани результат обратно в count". Мы узнаем о сокращённой записи (count += 1) в главе 4.

2.3.4) Обзор правил именования переменных

Имена переменных в Python должны следовать определённым правилам:

• Они могут содержать буквы, цифры и символ подчёркивания (_).
• Должны начинаться с буквы или подчёркивания (не с цифры).
• Не могут содержать пробелы или специальные символы вроде @, $, % и т.п.
• Не могут совпадать с ключевыми словами Python (зарезервированными словами, такими как print, if, for и т.д.).

Вот несколько допустимых имён переменных:

# valid_names.py
user_name = "Alice"
age2 = 30
_private_value = 42
totalPrice = 99.99

А вот несколько недопустимых имён:

# These cause errors:
# 2age = 30  # Cannot start with a number
# user-name = "Alice"  # Cannot contain hyphens
# total price = 99.99  # Cannot contain spaces
# print = "Hello"  # Cannot use Python keywords

Лучший подход: используйте описательные имена, которые объясняют, что представляет переменная. user_age лучше, чем a, а total_price лучше, чем tp. Мы подробно обсудим соглашения об именовании в главе 3.

2.3.5) Переменные делают программы динамичными

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

# dynamic_greeting.py
name = "Alice"
age = 28
city = "Seattle"
 
print("Personal Information")
print("====================")
print("Name:", name)
print("Age:", age)
print("City:", city)
print()
print("Summary:", name, "is", age, "years old and lives in", city)

Output:

Personal Information
====================
Name: Alice
Age: 28
City: Seattle
 
Summary: Alice is 28 years old and lives in Seattle

Изменяя значения name, age и city в верхней части программы, вы можете настраивать весь вывод, не меняя операторы print(). Это разделение данных и логики — фундаментальный принцип хорошего программирования.

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

2.4) Чтение ввода с клавиатуры с помощью input()

До сих пор все данные в наших программах были "зашиты" в коде — записаны напрямую. Но реальные программы часто должны взаимодействовать с пользователем, принимая вводимую им информацию. Функция input() в Python делает это возможным.

2.4.1) Базовый ввод

Функция input() выводит сообщение (называемое подсказкой — prompt) и ждёт, пока пользователь что‑то введёт и нажмёт Enter. Базовый шаблон:

# basic_input.py
name = input("What is your name? ")
print("Hello,", name + "!")

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

What is your name? Alice
Hello, Alice!

Разберём по шагам:

1. Python выполняет input("What is your name? ").
2. Python выводит подсказку: What is your name? .
3. Программа приостанавливается и ждёт, пока пользователь что‑то введёт.
4. Пользователь вводит Alice и нажимает Enter.
5. Python сохраняет текст "Alice" в переменной name.
6. Программа продолжает выполнение и выводит приветствие.

Текст, который вы передаёте в input(), — это подсказка, то, что видит пользователь перед вводом. Всегда добавляйте пробел в конце подсказки (обратите внимание на пробел после знака вопроса), чтобы отделить подсказку от ввода пользователя и сделать её более читаемой.

2.4.2) input всегда возвращает строку

Это крайне важно понять: input() всегда возвращает строку, даже если пользователь вводит числа:

# input_as_string.py
age = input("How old are you? ")
print("You entered:", age)
print("The type is:", type(age))

Если при запуске вы введёте 25:

How old are you? 25
You entered: 25
The type is: <class 'str'>

Хотя пользователь ввёл 25, Python сохраняет это как строку "25", а не как число 25. Функция type() подтверждает это — она показывает, что age — строка (str), а не целое число.

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

# This causes an error:
age = input("How old are you? ")
next_year_age = age + 1  # Error! Can't add a number to a string

Это вызывает ошибку, потому что Python не знает, как прибавить число 1 к строке "25".

2.4.3) Преобразование ввода в числа

Чтобы использовать ввод как число, нужно явно преобразовать его с помощью int() (для целых чисел) или float() (для десятичных чисел):

# input_conversion.py
age_string = input("How old are you? ")
age = int(age_string)  # Convert string to integer
 
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Если вы запустите это и введёте 25:

How old are you? 25
Next year, you will be 26 years old

Можно также объединить ввод и преобразование в одной строке:

# input_conversion_compact.py
age = int(input("How old are you? "))
next_year = age + 1
print("Next year, you will be", next_year, "years old")

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

1. input("How old are you? ") получает ввод пользователя как строку.
2. int(...) преобразует эту строку в целое число.
3. Целое число сохраняется в переменной age.

Вот пример с использованием float() для десятичных чисел:

# float_input.py
price = float(input("Enter the price: $"))
tax_rate = 0.08
tax = price * tax_rate
total = price + tax
 
print("Price: $", price)
print("Tax: $", tax)
print("Total: $", total)

Если вы запустите это и введёте 19.99:

Enter the price: $19.99
Price: $ 19.99
Tax: $ 1.5992
Total: $ 21.5892

Важно: если пользователь введёт текст, который нельзя преобразовать в число, Python вызовет ошибку. Например, если вы используете int(input("Enter a number: ")), а пользователь напечатает "hello", Python не сможет преобразовать "hello" в целое число и выведет сообщение об ошибке. Мы узнаем, как аккуратно обрабатывать такие ситуации, в главе 27, когда будем изучать обработку исключений (exception handling).

2.4.4) Несколько вводов

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

# multiple_inputs.py
print("Please enter your information:")
print()
 
first_name = input("First name: ")
last_name = input("Last name: ")
age = int(input("Age: "))
city = input("City: ")
 
print()
print("Summary")
print("=======")
print("Name:", first_name, last_name)
print("Age:", age)
print("Location:", city)

Example interaction:

Please enter your information:
 
First name: John
Last name: Smith
Age: 30
City: Boston
 
Summary
=======
Name: John Smith
Age: 30
Location: Boston

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

2.4.5) Создание информативных подсказок

Хорошие подсказки делают ваши программы проще в использовании. Вот несколько рекомендаций:

Будьте конкретны в том, что вы запрашиваете:

# Good prompts
name = input("Enter your full name: ")
temperature = float(input("Enter temperature in Fahrenheit: "))
quantity = int(input("How many items do you want to purchase? "))

Указывайте ожидаемый формат или единицы измерения:

# format_prompts.py
date = input("Enter date (MM/DD/YYYY): ")
phone = input("Enter phone number (XXX-XXX-XXXX): ")
price = float(input("Enter price in dollars (without $): "))

Используйте ясный, дружелюбный язык:

# friendly_prompts.py
print("Welcome to the Temperature Converter!")
print()
temp = float(input("Please enter a temperature in Fahrenheit: "))

Чёткие подсказки уменьшают путаницу у пользователей и делают ваши программы более профессиональными.

2.5) Простые программы по шаблону ввод‑обработка‑вывод

Большинство программ следует общему шаблону, который называется Input‑Process‑Output (IPO) (ввод‑обработка‑вывод):

1. Input (ввод): получение данных от пользователя или из другого источника.
2. Process (обработка): выполнение вычислений или преобразований над данными.
3. Output (вывод): отображение результатов.

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

2.5.1) Пример: конвертер температуры

Создадим полноценную программу, которая конвертирует температуру из градусов Фаренгейта в градусы Цельсия:

# temperature_converter.py
# This program converts a temperature from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
print("Temperature Converter")
print("Fahrenheit to Celsius")
print("=" * 30)  # Print a line of equal signs
print()
 
# INPUT: Get temperature from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# PROCESS: Convert using the formula
celsius = (fahrenheit - 32) * 5 / 9
 
# OUTPUT: Display the result
print()
print("Result:", fahrenheit, "°F =", celsius, "°C")

Example interaction:

Temperature Converter
Fahrenheit to Celsius
==============================
 
Enter temperature in Fahrenheit: 75
 
Result: 75.0 °F = 23.88888888888889 °C

Обратите внимание, как программа ясно следует шаблону IPO:

• Input: получает температуру в градусах Фаренгейта.
• Process: применяет формулу преобразования.
• Output: выводит результат в градусах Цельсия.

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

2.5.2) Пример: калькулятор площади прямоугольника

Вот ещё один пример IPO, вычисляющий площадь прямоугольника:

# rectangle_area.py
# Calculate the area of a rectangle
# Formula: Area = length × width
 
print("Rectangle Area Calculator")
print("=" * 30)
print()
 
# INPUT: Get dimensions from user
length = float(input("Enter the length: "))
width = float(input("Enter the width: "))
 
# PROCESS: Calculate area
area = length * width
 
# OUTPUT: Display the result
print()
print("A rectangle with length", length, "and width", width)
print("has an area of", area, "square units")

Example interaction:

Rectangle Area Calculator
==============================
 
Enter the length: 5.5
Enter the width: 3.2
 
A rectangle with length 5.5 and width 3.2
has an area of 17.6 square units

2.5.3) Пример: калькулятор общей суммы покупок

В этом примере вычисляется итоговая сумма покупки с учётом налога:

# shopping_total.py
# Calculate total cost including tax
 
print("Shopping Total Calculator")
print("=" * 30)
print()
 
# INPUT: Get price and tax rate
price = float(input("Enter item price: $"))
tax_rate = float(input("Enter tax rate (as decimal, e.g., 0.08 for 8%): "))
 
# PROCESS: Calculate tax and total
tax_amount = price * tax_rate
total = price + tax_amount
 
# OUTPUT: Display itemized breakdown
# Note: Comma in print() adds a space after $
print()
print("Purchase Summary")
print("-" * 30)
print("Item price:    $", price)
print("Tax rate:      ", tax_rate * 100, "%")
print("Tax amount:    $", tax_amount)
print("-" * 30)
print("Total:         $", total)

Example interaction:

Shopping Total Calculator
==============================
 
Enter item price: $49.99
Enter tax rate (as decimal, e.g., 0.08 for 8%): 0.08
 
Purchase Summary
------------------------------
Item price:    $ 49.99
Tax rate:       8.0 %
Tax amount:    $ 3.9992
------------------------------
Total:         $ 53.9892

2.6) Базовая отладка через чтение простых сообщений об ошибках

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

Термины "сообщение об ошибке" и "traceback" (трассировка) связаны, но немного различаются: traceback — это полный отчёт, который Python показывает при возникновении ошибки, включая тип ошибки, описание и путь по вашему коду, который привёл к ошибке. Сообщение об ошибке — это последняя строка traceback, описывающая, что пошло не так. В повседневной речи программисты часто используют "сообщение об ошибке" и для обозначения всего traceback.

2.6.1) Понимание сообщений об ошибках

Когда Python сталкивается с ошибкой, он выводит traceback — подробный отчёт о том, что произошло. Рассмотрим простой пример:

# error_example.py
print("Starting the program")
print("This line works fine"
print("This line might not be reached")

Когда вы пытаетесь запустить этот код, Python выводит:

  File "error_example.py", line 2
    print("This line works fine"
                                ^
SyntaxError: '(' was never closed

Разберём, что сообщает это сообщение об ошибке:

1. Имя файла: error_example.py — файл, в котором возникла ошибка.
2. Номер строки: line 2 — место, где Python обнаружил проблему.
3. Фрагмент кода: показывает проблемную строку со стрелкой ^, указывающей, где Python заметил ошибку.
4. Тип ошибки: SyntaxError — тип возникшей ошибки.
5. Описание: '(' was never closed — человекочитаемое объяснение.

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

2.6.2) Распространённые типы ошибок для начинающих

Рассмотрим наиболее частые ошибки, с которыми вы столкнётесь вначале, и способы их исправления.

SyntaxError: Invalid Syntax

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

Отсутствует двоеточие:

# missing_colon.py
name = input("What is your name? ")
if name == "Alice"  # Missing colon
    print("Hello, Alice!")

Error:

  File "missing_colon.py", line 2
    if name == "Alice"
                     ^
SyntaxError: expected ':'

Примечание: мы ещё не изучали операторы if — мы рассмотрим их в главе 8. Этот пример лишь демонстрирует вид ошибки.

Несогласованные кавычки:

# mismatched_quotes.py
message = "Hello, world!'
print(message)

Error:

  File "mismatched_quotes.py", line 1
    message = "Hello, world!'
              ^
SyntaxError: unterminated string literal (detected at line 1)

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

NameError: Name Not Defined

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

# name_error.py
print("Starting calculation")
result = total + 10  # 'total' was never created
print(result)

Error:

Traceback (most recent call last):
  File "name_error.py", line 2, in <module>
    result = total + 10
             ^^^^^
NameError: name 'total' is not defined

Python сообщает, что не знает, что такое total, потому что вы никогда не создавали эту переменную. Исправление — определить total до использования:

# name_error_fixed.py
print("Starting calculation")
total = 0  # Define the variable first
result = total + 10
print(result)

Распространённые причины NameError:

• опечатки в именах переменных (totla вместо total);
• использование переменной до присваивания ей значения;
• полное забывание о создании переменной.

TypeError: Unsupported Operand Type(s)

Эта ошибка появляется, когда вы пытаетесь выполнить операцию над несовместимыми типами:

# type_error.py
age = input("How old are you? ")
next_year = age + 1  # Can't add a number to a string
print("Next year:", next_year)

Error:

Traceback (most recent call last):
  File "type_error.py", line 2, in <module>
    next_year = age + 1
                ~~~~^~~
TypeError: can only concatenate str (not "int") to str

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

# type_error_fixed.py
age = int(input("How old are you? "))  # Convert to integer
next_year = age + 1
print("Next year:", next_year)

ValueError: Invalid Literal

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

# value_error.py
age = int(input("How old are you? "))
print("You are", age, "years old")

Если пользователь введёт текст вместо числа:

How old are you? twenty
Traceback (most recent call last):
  File "value_error.py", line 1, in <module>
    age = int(input("How old are you? "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'twenty'

Python сообщает, что не может преобразовать строку "twenty" в целое число. Пользователь должен ввести число вроде 20.

Важно: сейчас, если пользователи вводят некорректные данные, ваша программа "падает" с ошибкой. Это нормально для программ начинающего уровня. В главе 27 мы узнаем, как аккуратно обрабатывать такие ситуации с помощью обработки исключений (exception handling), позволяя программе восстанавливаться после ошибок и просить пользователя повторить ввод.

2.6.3) Внимательное чтение traceback

Когда возникает ошибка, Python показывает traceback, который "прослеживает" ошибку через ваш код. Для простых программ traceback короткий:

# simple_traceback.py
print("Starting program")
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello,", name)
print("Next year you'll be", age + 1)

Если пользователь введёт некорректный ввод для возраста:

Starting program
Enter your name: Alice
Enter your age: abc
Traceback (most recent call last):
  File "simple_traceback.py", line 3, in <module>
    age = int(input("Enter your age: "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

Traceback показывает:

1. Имя файла и номер строки, где возникла ошибка.
2. Саму строку кода, вызвавшую проблему.
3. Тип ошибки и описание.

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

2.6.4) Распространённые стратегии отладки

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

1. Внимательно прочитайте сообщение об ошибке

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

2. Посмотрите на номер строки

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

3. Проверьте типичные ошибки

• пропущенные или несогласованные кавычки;
• пропущенные закрывающие скобки или квадратные скобки;
• пропущенные двоеточия (для операторов, которые мы изучим позже, таких как if, for, while);
• опечатки в именах переменных;
• забытое преобразование ввода в числа.

4. Используйте print() для проверки значений

Если вы не уверены, что идёт не так, добавьте операторы print(), чтобы увидеть, какие значения содержат ваши переменные:

# debugging_with_print.py
price = input("Enter price: ")
print("DEBUG: price =", price, "type =", type(price))  # Debugging line
 
tax = price * 0.08  # This will cause an error
print("Tax:", tax)

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

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

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

# isolating_error.py
name = input("Enter name: ")
# age = int(input("Enter age: "))  # Commented out for testing
# city = input("Enter city: ")  # Commented out for testing
print("Name:", name)

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

6. Начните с упрощённой версии

Если программа не работает, упростите её до самого минимума:

# simplified_version.py
# Start with just the basic structure
print("Program starting")
# Add one feature at a time and test

Когда упрощённая версия заработает, добавляйте возможности по одной, тестируя после каждого добавления.

2.6.5) Предотвращение ошибок

Хотя отладка важна, ещё лучше — предотвращать ошибки заранее:

Пишите код постепенно

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

# incremental_development.py
# Step 1: Get input and test
name = input("Enter name: ")
print("DEBUG: Got name:", name)
 
# Step 2: Add more input and test
# age = int(input("Enter age: "))
# print("DEBUG: Got age:", age)
 
# Step 3: Add processing and test
# ... and so on

Используйте понятные имена переменных

Ясные имена переменных помогают избегать ошибок:

# Clear variable names make errors less likely
user_age = int(input("Enter your age: "))
next_year_age = user_age + 1

Добавляйте комментарии, чтобы объяснить логику

Комментарии помогают вам (и другим) понять, что код должен делать, что упрощает обнаружение ситуаций, когда он делает что‑то другое:

# temperature_with_comments.py
# Get temperature in Fahrenheit from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# Convert to Celsius using the standard formula: C = (F - 32) × 5/9
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print(fahrenheit, "°F =", celsius, "°C")

Тестируйте с разными вводами

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

• нормальные значения: 25, 100;
• ноль: 0;
• отрицательные числа: -10;
• десятичные числа: 3.14;
• очень большие числа: 1000000.

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

2.6.6) Когда просить о помощи

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

1. Внимательно прочитайте сообщение об ошибке — убедитесь, что вы понимаете, что в нём говорится.
2. Найдите ошибку в интернете — скопируйте сообщение об ошибке (без ваших конкретных имён переменных) и поищите его онлайн. Многие ошибки уже встречались и решались другими.
3. Тщательно проверьте код — ищите опечатки, пропущенную пунктуацию и распространённые ошибки.
4. Создайте минимальный пример — сократите код до наименьшей версии, которая по‑прежнему воспроизводит ошибку.

Когда вы обращаетесь за помощью, предоставьте:

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

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

Теперь вы познакомились с фундаментальными строительными блоками программирования на Python: выводом результатов с помощью print(), документированием кода комментариями, хранением данных в переменных, получением пользовательского ввода с помощью input(), следованием шаблону ввод‑обработка‑вывод и отладкой простых ошибок.

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

Ключевые выводы из этой главы:

• используйте print(), чтобы выводить текст и другую информацию пользователю;
• используйте комментарии (#), чтобы объяснять код и документировать свои мысли;
• храните данные в переменных, используя оператор присваивания (=);
• получайте пользовательский ввод с помощью input() и при необходимости преобразуйте его в числа;
• структурируйте программы по шаблону ввод‑обработка‑вывод;
• внимательно читайте сообщения об ошибках — они помогают вам исправлять проблемы;
• пишите код постепенно и часто тестируйте, чтобы раньше находить ошибки.

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