3. Переменные и базовые типы данных

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

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

К концу этой главы вы будете понимать:

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

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

3.1) Именование и создание переменных

3.1.1) Что такое переменные и зачем они нужны

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

1. Хранить информацию для последующего использования в программе
2. Обращаться к одному и тому же значению много раз без повторного ввода
3. Обновлять значения по мере выполнения программы
4. Делать код читаемым, используя осмысленные имена вместо «сырых» значений

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

# without_variables.py
print("Rectangle area:", 15 * 8)

Это работает, но что, если вам нужно использовать эти размеры несколько раз? И что обозначают 15 и 8? С переменными код становится понятнее и гибче:

# with_variables.py
length = 15
width = 8
area = length * width
print("Rectangle area:", area)  # Output: Rectangle area: 120

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

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

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

variable_name = value

Знак = не означает «равно» в математическом смысле. Вместо этого он означает «присвоить значение справа имени слева». Это важнейшее различие. Когда Python видит такое выражение, он:

1. Вычисляет выражение справа от =
2. Создаёт или обновляет имя переменной слева
3. Заставляет это имя ссылаться на полученное значение

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

# creating_variables.py
age = 25
temperature = 72.5
name = "Alice"
is_student = True
 
print(age)          # Output: 25
print(temperature)  # Output: 72.5
print(name)         # Output: Alice
print(is_student)   # Output: True

Обратите внимание, что нам не нужно объявлять, какой тип данных будет храниться в каждой переменной — Python определяет это автоматически по присваиваемому значению. Это называется динамической типизацией (dynamic typing) и делает Python очень гибким и удобным.

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

# multiple_assignment.py
x, y, z = 10, 20, 30
print(x)  # Output: 10
print(y)  # Output: 20
print(z)  # Output: 30
 
# You can even assign the same value to multiple variables
a = b = c = 100
print(a, b, c)  # Output: 100 100 100

Первая форма (называется распаковка кортежа (tuple unpacking) — о кортежах мы узнаем в главе 14) присваивает каждому имени соответствующее значение по порядку. Вторая форма присваивает одно и то же значение всем трём переменным.

3.1.3) Правила и соглашения именования переменных

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

Требования (обязательны):

1. Имя должно начинаться с буквы (a–z, A–Z) или подчёркивания (_): имена переменных не могут начинаться с цифры.
2. Может содержать буквы, цифры и подчёркивания: после первого символа можно использовать буквы, цифры и подчёркивания в любом сочетании.
3. Не может содержать пробелы или специальные символы: пробелы, дефисы и большинство знаков пунктуации недопустимы.
4. Не может совпадать с ключевым словом Python: Python зарезервировал для себя некоторые слова (например, if, for, while, def и т.д.).
5. Чувствительно к регистру: age, Age и AGE — три разные переменные.

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

# valid_names.py
# Valid variable names
user_age = 30
firstName = "John"
total_2024 = 1000
_private = "hidden"
x = 5
MAX_SIZE = 100
 
# Invalid variable names (these will cause errors)
# 2nd_place = "silver"      # Error: starts with digit
# user-name = "alice"       # Error: contains hyphen
# total amount = 500        # Error: contains space
# class = "Python 101"      # Error: 'class' is a keyword

Соглашения (стоит соблюдать для читаемости):

1. Используйте строчные буквы с подчёркиваниями для обычных переменных: такой стиль называется snake_case и является стандартом в Python.

   python

   user_age = 25
   total_price = 99.99
   is_valid = True

2. Используйте ПРОПИСНЫЕ буквы для констант: значений, которые не должны меняться во время выполнения программы.

   python

   MAX_ATTEMPTS = 3
   PI = 3.14159
   DEFAULT_COLOR = "blue"

3. Используйте описательные имена: имя переменной должно ясно отражать, что она хранит.

   python

   # Good: clear and descriptive
   student_count = 30
   average_temperature = 72.5
    
   # Poor: unclear abbreviations
   sc = 30
   avg_tmp = 72.5
    
   # Poor: too generic
   x = 30
   data = 72.5

4. Избегайте имён из одной буквы, кроме особых случаев: буквы i, j, k приемлемы в качестве счётчиков в циклах (loop), о которых мы узнаем в главе 11, а x, y, z — для координат. В остальных случаях используйте осмысленные имена.

5. Не используйте имена, совпадающие со встроенными функциями: хотя Python это допускает, избегайте имён вроде list, str, int, print и т.п., так как это имена встроенных функций.

Рассмотрим практический пример, демонстрирующий хорошие практики именования:

# good_naming.py
# Constants at the top
SALES_TAX_RATE = 0.08
DISCOUNT_THRESHOLD = 100
 
# Descriptive variable names
item_price = 75.00
quantity = 3
subtotal = item_price * quantity
 
# Clear boolean variable
qualifies_for_discount = subtotal >= DISCOUNT_THRESHOLD
 
if qualifies_for_discount:
    discount = subtotal * 0.10
    subtotal = subtotal - discount
    print("Discount applied: $", discount)
 
tax = subtotal * SALES_TAX_RATE
total = subtotal + tax
 
print("Subtotal: $", subtotal)
print("Tax: $", tax)
print("Total: $", total)
# Output:
# Subtotal: $ 202.5
# Tax: $ 16.2
# Total: $ 218.7

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

3.1.4) Использование переменных в выражениях

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

# using_variables.py
# Create some variables
hours_worked = 40
hourly_rate = 25.50
 
# Use variables in calculations
gross_pay = hours_worked * hourly_rate
print("Gross pay:", gross_pay)  # Output: Gross pay: 1020.0
 
# Use variables in other expressions
bonus = gross_pay * 0.10
total_pay = gross_pay + bonus
print("Total with bonus:", total_pay)  # Output: Total with bonus: 1122.0
 
# Use variables in strings (we'll learn more about this in Chapter 5)
message = "You worked " + str(hours_worked) + " hours"
print(message)  # Output: You worked 40 hours

Переменные также можно использовать с функциями, которые вы изучили в главе 2:

# variables_with_functions.py
name = input("What is your name? ")
age = input("What is your age? ")
 
greeting = "Hello, " + name + "!"
print(greeting)
 
age_next_year = int(age) + 1
print("Next year you will be", age_next_year, "years old.")
# If user enters "Alice" and "25":
# Output: Hello, Alice!
# Output: Next year you will be 26 years old.

Этот пример также демонстрирует важную идею: функция input() всегда возвращает текст (строку — string), поэтому, если вы хотите выполнять с ним арифметические операции, его нужно сначала преобразовать в число. Мы подробно разберём этот процесс преобразования позже в этой главе (раздел 3.7).

3.2) Присваивание и переназначение переменных

3.2.1) Понимание присваивания

Когда вы присваиваете значение переменной, Python создаёт связь между именем переменной и значением в памяти. Важно понимать, что переменная не «содержит» значение в физическом смысле — это имя, которое ссылается или указывает на значение, хранящееся где‑то в памяти.

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

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

# assignment_basics.py
x = 10
print(x)  # Output: 10
 
# Reassign x to a new value
x = 20
print(x)  # Output: 20
 
# The old value (10) is gone; x now refers to 20

Шаг за шагом произошло следующее:

1. x = 10: Python создаёт в памяти целое число 10 и заставляет имя x ссылаться на него
2. print(x): Python смотрит, на что ссылается x (10), и выводит это
3. x = 20: Python создаёт в памяти целое число 20 и заставляет x ссылаться уже на это новое значение
4. print(x): Python снова смотрит, на что ссылается x (теперь 20), и выводит это

Исходное значение 10 ещё некоторое время существует в памяти, но так как больше ни одна переменная на него не ссылается, механизм автоматического управления памятью Python (называется сборка мусора — garbage collection) в итоге его удалит.

3.2.2) Переназначение и обновление переменных

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

# updating_variables.py
score = 0
print("Initial score:", score)  # Output: Initial score: 0
 
# Add 10 points
score = score + 10
print("After first update:", score)  # Output: After first update: 10
 
# Add 5 more points
score = score + 5
print("After second update:", score)  # Output: After second update: 15
 
# Double the score
score = score * 2
print("After doubling:", score)  # Output: After doubling: 30

Разберём, что происходит в выражении score = score + 10:

1. Python вычисляет правую часть: score + 10
2. Находит текущее значение score (0)
3. Вычисляет 0 + 10, получая 10
4. Присваивает это новое значение (10) переменной score
5. Теперь score ссылается на 10 вместо 0

Такой шаблон настолько распространён, что в Python есть сокращённые операторы для него; мы изучим их в главе 4 (раздел 4.3). Но сейчас важно понять полную форму, потому что она ясно показывает порядок действий: сначала полностью вычисляется правая часть, потом результат присваивается левой.

3.2.3) Независимость переменных

Когда вы присваиваете одну переменную другой, Python копирует не значение, а ссылку (для простых типов вроде чисел и строк это не бросается в глаза). Однако для базовых типов, которые мы изучаем в этой главе, переменные ведут себя независимо после присваивания:

# independent_variables.py
a = 10
b = a  # b now refers to the same value as a (10)
print("a:", a)  # Output: a: 10
print("b:", b)  # Output: b: 10
 
# Change a
a = 20
print("After changing a:")
print("a:", a)  # Output: a: 20
print("b:", b)  # Output: b: 10 (unchanged!)

Когда мы написали b = a, мы заставили b ссылаться на то же значение, на которое в тот момент ссылалась a (10). Когда позже мы изменили a, чтобы она ссылалась на 20, на b это не повлияло — она по‑прежнему ссылается на 10.

Такое поведение очевидно для чисел и строк, но становится сложнее для коллекций (списков (list), словарей и т.д.). Мы подробно изучим это в главе 17, когда будем обсуждать объектную модель Python и семантику ссылок.

3.2.4) Использование переменных до присваивания

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

# undefined_variable.py
print(total)  # Error: NameError: name 'total' is not defined

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

# defined_variable.py
total = 0  # Initialize the variable first
print(total)  # Output: 0
 
# Now we can update it
total = total + 10
print(total)  # Output: 10

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

3.2.5) Обмен значениями переменных

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

# swap_with_temp.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap using a temporary variable
temp = x    # Save x's value
x = y       # Put y's value in x
y = temp    # Put saved value in y
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Однако Python предлагает более элегантный способ с использованием одновременного присваивания:

# swap_pythonic.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap in one line
x, y = y, x
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Это работает потому, что Python сначала полностью вычисляет правую часть (y, x), а уже затем выполняет присваивания. То есть он создаёт временную структуру с текущими значениями y и x, а потом распаковывает их в x и y соответственно. Это наглядный пример философии Python — делать распространённые операции простыми и читаемыми.

3.3) Понятие типов данных и функция type()

3.3.1) Что такое типы данных?

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

Например:

• число 42 — это целое число (integer)
• число 3.14 — это число с плавающей точкой (floating-point number)
• текст "Hello" — это строка (string), то есть последовательность символов
• значение True — это логическое значение (boolean), отражающее истину/ложь

Почему типы данных важны? Потому что разные типы поддерживают разные операции:

# type_operations.py
# You can add numbers
result1 = 10 + 5
print(result1)  # Output: 15
 
# You can also "add" strings (concatenation)
result2 = "Hello" + " " + "World"
print(result2)  # Output: Hello World
 
# But you can't add a number and a string directly
# result3 = 10 + "5"  # Error: TypeError: unsupported operand type(s)

Ошибка в последнем примере возникает потому, что Python не знает, как сложить число и строку — это принципиально разные типы данных. Должен ли он преобразовать число в текст и склеить строки? Или наоборот — преобразовать текст в число и выполнить арифметическое сложение? Python требует, чтобы вы явно указали своё намерение, преобразовав одно значение к типу другого (как это сделать, мы изучим в разделе 3.7).

3.3.2) Использование type() для проверки типов данных

Python предоставляет встроенную функцию type(), которая сообщает, к какому типу относится значение или переменная. Это чрезвычайно полезно для понимания ваших данных и отладки:

# checking_types.py
# Check types of literal values
print(type(42))        # Output: <class 'int'>
print(type(3.14))      # Output: <class 'float'>
print(type("Hello"))   # Output: <class 'str'>
print(type(True))      # Output: <class 'bool'>
 
# Check types of variables
age = 25
name = "Alice"
temperature = 98.6
is_valid = False
 
print(type(age))         # Output: <class 'int'>
print(type(name))        # Output: <class 'str'>
print(type(temperature)) # Output: <class 'float'>
print(type(is_valid))    # Output: <class 'bool'>

Вывод <class 'int'> означает «это значение относится к классу (типу) int». В Python типы на самом деле являются классами (подробно о классах мы поговорим в части VIII), но пока можно считать эти термины взаимозаменяемыми.

3.3.3) Динамическая типизация в Python

Python — язык с динамической типизацией (dynamic typing), что означает:

1. Переменные не имеют фиксированных типов: одна и та же переменная может в разное время ссылаться на значения разных типов
2. Типы определяются во время выполнения: Python выясняет типы, когда программа запускается, а не когда вы пишете код
3. Вам не нужно явно объявлять типы: в отличие от ряда других языков, вам не нужно писать, что «эта переменная будет хранить целое число»

Вот пример динамической типизации в действии:

# dynamic_typing.py
x = 42
print(x, "is of type", type(x))  # Output: 42 is of type <class 'int'>
 
x = "Hello"
print(x, "is of type", type(x))  # Output: Hello is of type <class 'str'>
 
x = 3.14
print(x, "is of type", type(x))  # Output: 3.14 is of type <class 'float'>

Обратите внимание: x может ссылаться на значения разных типов в разные моменты программы. Python не возражает — он просто обновляет, на какой тип сейчас ссылается x.

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

# type_confusion.py
value = "100"  # This is a string, not a number!
 
# Trying to do math with it will fail
# result = value + 50  # Error: TypeError: can only concatenate str to str
 
# You need to convert it first
result = int(value) + 50
print(result)  # Output: 150

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

3.3.4) Обзор встроенных типов Python

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

В этой главе мы рассмотрим:

• int: целые числа (целые значения)
• float: числа с плавающей точкой (числа с десятичной точкой)
• str: строки (текст)
• bool: логические значения (True и False)
• NoneType: тип для специального значения None

Мы кратко упомянем комплексные числа (с мнимой частью), но они редко нужны в повседневном программировании. Типам коллекций (таким как списки (list), кортежи, словари и множества) посвящены целые главы в части IV.

3.3.5) Проверка типов на практике

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

# input_types.py
user_input = input("Enter a number: ")
print("You entered:", user_input)
print("Type:", type(user_input))  # Output: Type: <class 'str'>
 
# Even if user types "42", it's still a string!
# To use it as a number, convert it:
number = int(user_input)
print("As a number:", number)
print("Type:", type(number))  # Output: Type: <class 'int'>
 
# Now we can do math with it
doubled = number * 2
print("Doubled:", doubled)

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

Enter a number: 42
You entered: 42
Type: <class 'str'>
As a number: 42
Type: <class 'int'>
Doubled: 84

Это иллюстрирует важный момент: строка "42" и целое число 42 — разные вещи в Python, хотя при выводе они выглядят одинаково. Строка — это последовательность двух символов ('4' и '2'), а целое число — это числовое значение, с которым можно выполнять математические операции.

3.4) Целые и числа с плавающей точкой

3.4.1) Целые числа (int)

Целое число (тип int) — это число без десятичной точки. Целые числа могут быть положительными, отрицательными или нулём, и в Python 3 они могут быть сколь угодно большими — ограничение только по доступной памяти.

# integers.py
# Positive integers
age = 25
year = 2024
population = 8000000000
 
# Negative integers
temperature = -15
debt = -5000
 
# Zero
balance = 0
 
# Very large integers (Python handles these easily)
huge_number = 123456789012345678901234567890
print(huge_number)  # Output: 123456789012345678901234567890
print(type(huge_number))  # Output: <class 'int'>

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

# readable_numbers.py
# These are all the same number
million = 1000000
million = 1_000_000  # Much easier to read!
 
# Works with any size
population = 8_000_000_000
national_debt = 31_000_000_000_000
 
print(million)      # Output: 1000000 (underscores not shown in output)
print(population)   # Output: 8000000000

Вы также можете записывать целые числа в разных системах счисления с помощью специальных префиксов:

# number_bases.py
# Binary (base 2) - prefix 0b
binary = 0b1010  # This is 10 in decimal
print(binary)  # Output: 10
 
# Octal (base 8) - prefix 0o
octal = 0o12  # This is 10 in decimal
print(octal)  # Output: 10
 
# Hexadecimal (base 16) - prefix 0x
hexadecimal = 0xFF  # This is 255 in decimal
print(hexadecimal)  # Output: 255

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

3.4.2) Числа с плавающей точкой (float)

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

# floats.py
# Numbers with decimal points
price = 19.99
temperature = 98.6
pi = 3.14159
 
# Very small numbers
electron_mass = 0.00000000000000000000000000000091093837
 
# Very large numbers
speed_of_light = 299792458.0
 
print(price)           # Output: 19.99
print(temperature)     # Output: 98.6
print(electron_mass)   # Output: 9.1093837e-31 (scientific notation)
print(speed_of_light)  # Output: 299792458.0

Обратите внимание, что очень маленькие или очень большие числа выводятся в научной нотации (экспоненциальной форме). Запись 9.1093837e-31 означает «9.1093837 × 10⁻³¹» или «9.1093837, делённое на 10 в 31‑й степени».

Вы также можете записывать float в научной нотации напрямую:

# scientific_notation.py
# These are equivalent
avogadro = 602214076000000000000000.0
avogadro = 6.02214076e23  # Much more readable!
 
# Small numbers
planck = 0.000000000000000000000000000000000662607015
planck = 6.62607015e-34  # Much more readable!
 
print(avogadro)  # Output: 6.02214076e+23
print(planck)    # Output: 6.62607015e-34

Буква e (или E) означает «показатель степени». Число после e говорит, на сколько позиций нужно сдвинуть десятичную точку (положительное — вправо, отрицательное — влево).

3.4.3) Отличия int и float

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

1. Точность и представление:

Целые числа точны — значение 42 представлено без какой‑либо аппроксимации. Числа с плавающей точкой — это приближения, обусловленные тем, как компьютеры хранят десятичные числа в двоичной форме:

# float_precision.py
# This might surprise you!
result = 0.1 + 0.2
print(result)  # Output: 0.30000000000000004
 
# The result isn't exactly 0.3 due to floating-point representation
print(result == 0.3)  # Output: False

Это не ошибка в Python — это фундаментальное ограничение двоичного представления дробных чисел в компьютерах. Мы подробнее обсудим это в главе 4 (раздел 4.10), но пока важно помнить, что вычисления с float могут быть не идеально точными.

2. Операции и результаты:

При выполнении операций с целыми и вещественными числами Python следует определённым правилам:

# int_float_operations.py
# Integer operations
int_result = 10 + 5
print(int_result, type(int_result))  # Output: 15 <class 'int'>
 
# Float operations
float_result = 10.0 + 5.0
print(float_result, type(float_result))  # Output: 15.0 <class 'float'>
 
# Mixed operations: result is always float
mixed_result = 10 + 5.0
print(mixed_result, type(mixed_result))  # Output: 15.0 <class 'float'>
 
# Division always returns float, even with integers
division_result = 10 / 5
print(division_result, type(division_result))  # Output: 2.0 <class 'float'>

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

3. Память и производительность:

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

3.4.4) Когда использовать int, а когда float

Практические рекомендации по выбору между целыми и вещественными числами:

Используйте целые числа, когда:

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

# use_integers.py
student_count = 30  # Can't have 30.5 students
page_number = 42    # Can't be on page 42.7
loop_counter = 0    # Counting iterations

Используйте числа с плавающей точкой, когда:

• представляете измерения (температура, расстояние, вес)
• работаете с деньгами (хотя нужно быть аккуратным с точностью — обсудим в главе 4)
• вычисляете отношения, проценты или средние значения
• допускается приближённое значение

# use_floats.py
temperature = 72.5     # Temperature can be fractional
price = 19.99          # Money amounts have cents
average_score = 87.3   # Averages are often fractional
percentage = 0.15      # 15% as a decimal

3.5) Строковые и булевы литералы (краткий обзор)

В этом разделе мы кратко познакомимся ещё с двумя основными типами данных: строками и булевыми значениями. Строки мы будем подробно изучать в главах 5 и 6, а булевы значения — в главе 7, но вам нужно базовое представление о них уже сейчас, чтобы писать даже простейшие программы.

3.5.1) Основы строк

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

# string_basics.py
# Single quotes
name = 'Alice'
message = 'Hello, World!'
 
# Double quotes (exactly equivalent)
name = "Alice"
message = "Hello, World!"
 
# Print them
print(name)     # Output: Alice
print(message)  # Output: Hello, World!
print(type(name))  # Output: <class 'str'>

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

Зачем нужны оба варианта? В основном ради удобства, когда строка содержит кавычки:

# quotes_in_strings.py
# Use double quotes when string contains single quotes
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Use single quotes when string contains double quotes
speech = 'She said, "Hello!"'
print(speech)  # Output: She said, "Hello!"
 
# Or use escape sequences (we'll learn more in Chapter 5)
sentence = 'It\'s a beautiful day!'  # \' means a literal single quote
speech = "She said, \"Hello!\""     # \" means a literal double quote

Строка может быть пустой (не содержать символов):

# empty_string.py
empty = ""
also_empty = ''
 
print(empty)            # Output: (nothing—it's empty!)
print(len(empty))       # Output: 0 (we'll learn about len() later)
print(type(empty))      # Output: <class 'str'>

Строки можно объединять с помощью оператора + (это называется конкатенацией):

# string_concatenation.py
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name)  # Output: John Doe
 
# Be careful: you can't concatenate strings and numbers directly
age = 25
# message = "I am " + age + " years old"  # Error: TypeError
 
# Convert the number to a string first
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Мы гораздо подробнее изучим строки в главах 5 и 6: экранирование, методы строк, форматирование, обработку текста. Пока запомните, что строки представляют текст и создаются с помощью кавычек.

3.5.2) Основы булевых значений

Булево значение (тип bool) — это логическое значение, которое может быть либо True, либо False. Это единственные два булевых значения в Python, и они используются для представления истинности и ложности в логических операциях:

# boolean_basics.py
# Boolean literals
is_sunny = True
is_raining = False
 
print(is_sunny)         # Output: True
print(is_raining)       # Output: False
print(type(is_sunny))   # Output: <class 'bool'>

Важно: значения True и False должны быть написаны именно так, с заглавной буквы в начале. Python чувствителен к регистру, поэтому true, TRUE, false и FALSE работать не будут:

# boolean_case.py
correct = True    # Correct
# wrong = true    # Error: NameError: name 'true' is not defined
# wrong = TRUE    # Error: NameError: name 'TRUE' is not defined

Обычно булевы значения получаются как результат сравнений или логических операций:

# boolean_from_comparisons.py
age = 25
 
# Comparison operators produce boolean results
is_adult = age >= 18
print(is_adult)  # Output: True
 
is_senior = age >= 65
print(is_senior)  # Output: False
 
# You can use booleans in conditions (we'll learn more in Chapter 8)
if is_adult:
    print("You can vote!")  # Output: You can vote!
 
if is_senior:
    print("You get a senior discount!")  # (no output—condition is False)

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

• == : равно
• != : не равно
• < : меньше
• > : больше
• <= : меньше или равно
• >= : больше или равно

# comparison_operators.py
x = 10
y = 20
 
print(x == y)   # Output: False (10 is not equal to 20)
print(x != y)   # Output: True (10 is not equal to 20)
print(x < y)    # Output: True (10 is less than 20)
print(x > y)    # Output: False (10 is not greater than 20)
print(x <= 10)  # Output: True (10 is less than or equal to 10)
print(y >= 20)  # Output: True (20 is greater than or equal to 20)

Важное замечание: не путайте = (присваивание) и == (сравнение):

• x = 10 означает «присвоить значение 10 переменной x»
• x == 10 означает «проверить, равно ли значение x числу 10» (результат — True или False)

# assignment_vs_comparison.py
x = 10        # Assignment: x now refers to 10
result = (x == 10)  # Comparison: is x equal to 10?
print(result)  # Output: True
 
# This is a common mistake for beginners:
# if x = 10:  # Error: SyntaxError (can't use assignment in if condition)
if x == 10:   # Correct: comparison
    print("x is 10")  # Output: x is 10

Мы подробно изучим булевы значения в главе 7, включая логические операторы (and, or, not), понятия истинности/ложности (truthiness/falsiness) и использование булевых значений в условиях. Пока запомните, что булевы значения представляют истину/ложь и чаще всего получаются в результате сравнений.

3.5.3) Строки и булевы значения в контексте

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

# strings_booleans_example.py
# Get user input
name = input("What is your name? ")
age_input = input("What is your age? ")
 
# Convert age to integer
age = int(age_input)
 
# Create boolean conditions
is_adult = age >= 18
is_child = age < 13
 
# Build messages using strings
if is_adult:
    status = "adult"
else:
    status = "minor"
 
# Combine everything in output
print("Hello, " + name + "!")
print("You are an " + status + ".")
 
if is_child:
    print("You are a child.")
 
# When user enters "Alice" and "16":
# Output: Hello, Alice!
# Output: You are a minor.

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

3.6) Значение None и его использование

3.6.1) Что такое None?

В Python есть специальное значение None (тип NoneType), обозначающее отсутствие значения. Это способ Python сказать: «здесь ничего нет» или «значение пока не задано».

# none_basics.py
result = None
print(result)        # Output: None
print(type(result))  # Output: <class 'NoneType'>

None — это не то же самое, что ноль, пустая строка или False; это отдельное значение, которое специально означает «нет значения»:

# none_vs_others.py
x = None
y = 0
z = ""
w = False
 
print(x)  # Output: None
print(y)  # Output: 0
print(z)  # Output: (empty—nothing prints)
print(w)  # Output: False
 
# They're all different types
print(type(x))  # Output: <class 'NoneType'>
print(type(y))  # Output: <class 'int'>
print(type(z))  # Output: <class 'str'>
print(type(w))  # Output: <class 'bool'>

3.6.2) Когда используется None

None встречается во многих распространённых ситуациях.

1. Как заполнитель для значений, которые будут заданы позже:

# none_placeholder.py
# Initialize variables that will be assigned later
user_name = None
user_age = None
 
# Later in the program, after getting user input:
user_name = input("Enter your name: ")
user_age = int(input("Enter your age: "))
 
print("Name:", user_name)
print("Age:", user_age)

2. В качестве значения по умолчанию, возвращаемого функциями, которые явно ничего не возвращают:

Функции (function), которые мы изучим в главе 19, могут возвращать значения. Если функция явно ничего не возвращает, Python автоматически возвращает None:

# none_from_function.py
# The print() function returns None
result = print("Hello!")  # Output: Hello!
print(result)             # Output: None
print(type(result))       # Output: <class 'NoneType'>

Это может показаться странным, но полезно. Так каждая функция что‑то возвращает, даже если это «нет осмысленного значения».

3. Для представления необязательных или отсутствующих данных:

# none_optional.py
# Representing optional middle name
first_name = "John"
middle_name = None  # No middle name
last_name = "Doe"
 
if middle_name is None:
    full_name = first_name + " " + last_name
else:
    full_name = first_name + " " + middle_name + " " + last_name
 
print(full_name)  # Output: John Doe

3.6.3) Проверка на None

Чтобы проверить, равно ли значение None, используйте оператор is (а не ==):

# checking_none.py
value = None
 
# Correct way: use 'is'
if value is None:
    print("Value is None")  # Output: Value is None
 
# Also correct: use 'is not'
if value is not None:
    print("Value has a value")
else:
    print("Value is None")  # Output: Value is None
 
# While == works, 'is' is preferred for None
if value == None:  # This works but is not idiomatic Python
    print("Value is None")  # Output: Value is None

Почему лучше использовать is, а не ==? Оператор is проверяет, ссылаются ли два имени на один и тот же объект в памяти (подробнее об этом в главе 17). Поскольку объект None в Python существует в единственном экземпляре, is одновременно эффективнее и точнее для такой проверки. Конструкция is None — стандартный идиоматический приём в Python.

3.6.4) None в реальных задачах

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

# none_practical.py
# Simulate looking up a user's age
# (In real programs, we'd use functions and dictionaries from later chapters)
 
user_name = input("Enter a name (Alice, Bob, or Charlie): ")
 
# Check each name and assign age or None
if user_name == "Alice":
    user_age = 25
elif user_name == "Bob":
    user_age = 30
elif user_name == "Charlie":
    user_age = 35
else:
    user_age = None  # User not found
 
# Check if we found the user
if user_age is not None:
    print(user_name, "is", user_age, "years old")
else:
    print(user_name, "not found")
 
# When user enters "Alice":
# Output: Alice is 25 years old
# When user enters "David":
# Output: David not found

В этом примере None однозначно обозначает «пользователь не найден», что отличается от ситуации, когда найден пользователь с возрастом 0 (это было бы корректное значение для новорождённого).

3.6.5) None и пустые значения

Важно различать None и пустые значения:

# none_vs_empty.py
# These are all different
nothing = None
zero = 0
empty_string = ""
# Note: We'll learn about lists in Chapter 13
# empty_list = []
 
print(nothing is None)       # Output: True
print(zero is None)          # Output: False
print(empty_string is None)  # Output: False
 
# None means "no value"
# 0 means "the number zero"
# "" means "text with no characters"

Каждое из этих значений отражает разную идею:

• None: отсутствие значения
• 0: конкретное числовое значение (ноль)
• "": строка, которая существует, но не содержит символов

Понимание этого различия поможет вам писать более ясные и корректные программы.

3.7) Базовое приведение типов с помощью int(), float() и str()

3.7.1) Зачем нужно приведение типов

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

Преобразование типа (type conversion, или приведение типов — type casting) — это превращение значения одного типа в значение другого типа. Python предоставляет встроенные функции для наиболее распространённых преобразований:

• int(): преобразование к целому числу
• float(): преобразование к числу с плавающей точкой
• str(): преобразование к строке

Рассмотрим каждую из этих функций более подробно.

3.7.2) Преобразование к целому с помощью int()

Функция int() преобразует значение к типу int. Основные случаи использования:

Преобразование float в int:

# float_to_int.py
# int() truncates (cuts off) the decimal part
x = int(3.14)
y = int(3.99)
z = int(-2.7)
 
print(x)  # Output: 3 (not 4—it doesn't round!)
print(y)  # Output: 3 (not 4—it truncates!)
print(z)  # Output: -2 (truncates toward zero)

Важно: int() не округляет — он просто отбрасывает дробную часть (обрезает по направлению к нулю). Это частый источник путаницы у начинающих, которые ожидают, что int(3.9) вернёт 4.

Преобразование строк в целые числа:

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

# string_to_int.py
# Convert string containing a number
age_str = "25"
age_int = int(age_str)
 
print(age_str, type(age_str))  # Output: 25 <class 'str'>
print(age_int, type(age_int))  # Output: 25 <class 'int'>
 
# Now we can do math with it
next_year = age_int + 1
print("Next year:", next_year)  # Output: Next year: 26
 
# Practical example with input()
user_age = int(input("Enter your age: "))
print("In 10 years, you'll be", user_age + 10)

Что происходит при некорректных преобразованиях?

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

# invalid_int_conversion.py
# These work
print(int("123"))    # Output: 123
print(int("-456"))   # Output: -456
print(int("  789 ")) # Output: 789 (whitespace is ignored)
 
# These don't work
# print(int("12.5"))   # Error: ValueError: invalid literal for int()
# print(int("hello"))  # Error: ValueError: invalid literal for int()
# print(int("12 34"))  # Error: ValueError: invalid literal for int()

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

Преобразование булевых значений в целые:

Булевы значения можно преобразовывать в int: при этом True превращается в 1, а False — в 0:

# bool_to_int.py
print(int(True))   # Output: 1
print(int(False))  # Output: 0
 
# This is sometimes useful in calculations
is_premium = True
is_student = False
 
# Calculate discount (10% for premium, 5% for students)
discount = int(is_premium) * 0.10 + int(is_student) * 0.05
print("Discount:", discount)  # Output: Discount: 0.1

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

3.7.3) Преобразование к float с помощью float()

Функция float() преобразует значение к типу float.

Преобразование целых чисел в float:

# int_to_float.py
x = float(42)
y = float(-17)
z = float(0)
 
print(x, type(x))  # Output: 42.0 <class 'float'>
print(y, type(y))  # Output: -17.0 <class 'float'>
print(z, type(z))  # Output: 0.0 <class 'float'>

Преобразование строк в float:

# string_to_float.py
# Convert string containing decimal number
price_str = "19.99"
price_float = float(price_str)
 
print(price_str, type(price_str))    # Output: 19.99 <class 'str'>
print(price_float, type(price_float))  # Output: 19.99 <class 'float'>
 
# Strings without decimal points work too
x = float("42")
print(x, type(x))  # Output: 42.0 <class 'float'>
 
# Scientific notation strings work
big = float("1.5e10")
print(big)  # Output: 15000000000.0

Некорректные преобразования:

Как и int(), функция float() выбрасывает ValueError при некорректных строках:

# invalid_float_conversion.py
# These work
print(float("3.14"))      # Output: 3.14
print(float("  2.5  "))   # Output: 2.5 (whitespace ignored)
print(float("-0.5"))      # Output: -0.5
print(float("inf"))       # Output: inf (infinity)
 
# These don't work
# print(float("hello"))   # Error: ValueError
# print(float("1.2.3"))   # Error: ValueError

Преобразование булевых значений в float:

# bool_to_float.py
print(float(True))   # Output: 1.0
print(float(False))  # Output: 0.0

3.7.4) Преобразование к строке с помощью str()

Функция str() преобразует любое значение в его строковое представление.

Преобразование чисел в строки:

# number_to_string.py
# Convert integer
age = 25
age_str = str(age)
print(age_str, type(age_str))  # Output: 25 <class 'str'>
 
# Convert float
price = 19.99
price_str = str(price)
print(price_str, type(price_str))  # Output: 19.99 <class 'str'>
 
# Now we can concatenate with other strings
message = "The price is $" + price_str
print(message)  # Output: The price is $19.99

Это особенно полезно при формировании сообщений:

# building_messages.py
name = "Alice"
age = 25
height = 5.6
 
# Without str(), this would cause an error
# message = "Name: " + name + ", Age: " + age  # Error!
 
# With str(), it works
message = "Name: " + name + ", Age: " + str(age) + ", Height: " + str(height)
print(message)  # Output: Name: Alice, Age: 25, Height: 5.6

Преобразование булевых значений в строки:

# bool_to_string.py
is_valid = True
is_error = False
 
print(str(is_valid))  # Output: True
print(str(is_error))  # Output: False
 
# Useful in messages
status = "Status: " + str(is_valid)
print(status)  # Output: Status: True

Преобразование None в строку:

# none_to_string.py
value = None
value_str = str(value)
print(value_str)        # Output: None
print(type(value_str))  # Output: <class 'str'>
 
# The string "None" is different from the value None
print(value is None)      # Output: True
print(value_str is None)  # Output: False
print(value_str == "None")  # Output: True

3.7.5) Шаблоны преобразования типов на практике

Вот более полный пример, демонстрирующий распространённые шаблоны преобразования:

# conversion_patterns.py
# Get user input (always strings)
name = input("Enter your name: ")
age_str = input("Enter your age: ")
height_str = input("Enter your height in feet: ")
 
# Convert to appropriate types
age = int(age_str)
height = float(height_str)
 
# Perform calculations
age_in_months = age * 12
height_in_inches = height * 12
 
# Convert back to strings for output
print("Hello, " + name + "!")
print("You are " + str(age_in_months) + " months old.")
print("Your height is " + str(height_in_inches) + " inches.")
 
# Alternative: use multiple arguments to print() (no conversion needed)
print("Hello,", name + "!")
print("You are", age_in_months, "months old.")
print("Your height is", height_in_inches, "inches.")
 
# When user enters "Alice", "25", and "5.5":
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.

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

3.7.6) Диаграмма потоков преобразования типов

Ниже — визуальное представление распространённых преобразований типов:

Ключевые моменты о преобразованиях:

• int → float: всегда безопасно, просто добавляется .0
• float → int: дробная часть отбрасывается (не округляется)
• Any → str: всегда безопасно, значение превращается в текстовое представление
• str → int/float: работает только если строка содержит корректное числовое представление
• bool → int/float: True превращается в 1/1.0, False — в 0/0.0

3.7.7) Распространённые ошибки при преобразовании типов

Вот некоторые типичные ошибки, которые совершают новички при приведении типов.

Ошибка 1: забыли преобразовать пользовательский ввод

# conversion_mistake1.py
# Wrong: trying to do math with string
age = input("Enter your age: ")
# next_year = age + 1  # Error: TypeError
 
# Right: convert first
age = int(input("Enter your age: "))
next_year = age + 1
print("Next year:", next_year)

Ошибка 2: преобразование там, где оно не нужно

# conversion_mistake2.py
# Unnecessary: print() handles conversion automatically
age = 25
print("Age:", age)  # This works fine
 
# No need for:
print("Age:", str(age))  # Unnecessary str() conversion

Ошибка 3: попытка преобразовать некорректные строки

# conversion_mistake3.py
# This will crash if user enters non-numeric input
# age = int(input("Enter your age: "))  # Crashes on "twenty"
 
# We'll learn to handle this safely in Chapter 27

Ошибка 4: ожидание, что int() будет округлять

# conversion_mistake4.py
# Wrong expectation: int() truncates, doesn't round
x = int(3.7)
print(x)  # Output: 3 (not 4!)
 
# If you want rounding, use round()
x = round(3.7)
print(x)  # Output: 4

3.8) Получение строковых представлений с помощью str() и repr()

3.8.1) Разница между str() и repr()

В Python есть два способа получить строковое представление объекта: str() и repr(). Хотя они могут показаться похожими, у них разные назначения:

• str(): создаёт «красивое», человеко‑читаемое строковое представление
• repr(): создаёт «официальное», однозначное строковое представление, предназначенное для разработчиков

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

# str_vs_repr.py
# For numbers, they're usually the same
x = 42
print(str(x))   # Output: 42
print(repr(x))  # Output: 42
 
# For strings, they differ
text = "Hello"
print(str(text))   # Output: Hello
print(repr(text))  # Output: 'Hello' (includes quotes!)
 
# For strings with special characters, repr() shows escape sequences
message = "Hello\nWorld"
print(str(message))   # Output: Hello
                      #         World (newline is interpreted)
print(repr(message))  # Output: 'Hello\nWorld' (shows the \n literally)

3.8.2) Когда использовать str()

Используйте str(), когда вам нужно читаемое представление для конечных пользователей:

# using_str.py
price = 19.99
quantity = 3
 
# Create user-friendly messages
message = "Total: $" + str(price * quantity)
print(message)  # Output: Total: $59.97
 
# str() is what print() uses automatically
print("Total: $", price * quantity)  # Output: Total: $ 59.97

Функция str() предназначена для создания вывода, понятного человеку, даже если при этом теряется некоторая техническая точность. Когда вы вызываете print(), Python автоматически вызывает str() для переданных значений.

3.8.3) Когда использовать repr()

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

# using_repr.py
# Debugging: see exactly what's in a variable
text = "Hello\nWorld"
print("Debug info:", repr(text))  # Output: Debug info: 'Hello\nWorld'
 
# Compare two similar-looking strings
str1 = "42"
str2 = "42 "  # Has trailing space
 
print(str1)       # Output: 42
print(str2)       # Output: 42  (space not obvious)
print(repr(str1)) # Output: '42'
print(repr(str2)) # Output: '42 ' (space is visible!)

Функция repr() показывает именно то, что «видит» Python, включая детали, которые могут быть невидимы в обычном выводе. Это делает её незаменимой при отладке.

3.8.4) Цель repr(): представления, по которым можно воссоздать объект

Идеально repr() должно выдавать строку, по которой интерпретатор Python может воссоздать исходный объект. Для базовых типов это работает:

# repr_recreate.py
# For numbers
x = 42
x_repr = repr(x)
print(x_repr)  # Output: 42
 
# You could use this to recreate x
x_recreated = eval(x_repr)  # eval() evaluates a string as Python code
print(x_recreated)  # Output: 42
 
# For strings
text = "Hello"
text_repr = repr(text)
print(text_repr)  # Output: 'Hello'
 
# This could recreate the string
text_recreated = eval(text_repr)
print(text_recreated)  # Output: Hello

Важное замечание: функция eval() выполняет строку как код Python. Мы упоминаем её здесь только для пояснения цели repr(), но никогда не используйте eval() для непроверенного ввода — это серьёзный риск безопасности. Более безопасные альтернативы мы обсудим в последующих главах.

3.8.5) Практические примеры использования str() и repr()

Пример 1: отладка строковых проблем

# debugging_strings.py
# User input might have unexpected whitespace
user_input = "  Alice  "
 
print("User entered:", user_input)         # Output: User entered:   Alice  
print("Debug view:", repr(user_input))     # Output: Debug view: '  Alice  '
 
# Now the extra spaces are obvious!
cleaned = user_input.strip()  # Remove leading/trailing whitespace
print("Cleaned:", repr(cleaned))  # Output: Cleaned: 'Alice'

Пример 2: сравнение разных типов

# comparing_types.py
# These look similar but are different
num = 42
text = "42"
 
print("Number:", num)       # Output: Number: 42
print("Text:", text)        # Output: Text: 42
 
print("Number repr:", repr(num))   # Output: Number repr: 42
print("Text repr:", repr(text))    # Output: Text repr: '42'
 
# repr() makes the difference clear
print("Are they equal?", num == text)  # Output: Are they equal? False

3.8.6) str() и repr() для других типов

Посмотрим, как str() и repr() работают с типами, которые мы уже изучили:

# str_repr_types.py
# Integers
x = 42
print("int str:", str(x))    # Output: int str: 42
print("int repr:", repr(x))  # Output: int repr: 42
 
# Floats
y = 3.14159
print("float str:", str(y))   # Output: float str: 3.14159
print("float repr:", repr(y)) # Output: float repr: 3.14159
 
# Booleans
b = True
print("bool str:", str(b))   # Output: bool str: True
print("bool repr:", repr(b)) # Output: bool repr: True
 
# None
n = None
print("None str:", str(n))   # Output: None str: None
print("None repr:", repr(n)) # Output: None repr: None
 
# Strings (where they differ most)
s = "Hello\nWorld"
print("string str:", str(s))   # Output: string str: Hello
                                #                     World
print("string repr:", repr(s)) # Output: string repr: 'Hello\nWorld'

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

Используйте str(), когда:

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

Используйте repr(), когда:

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

Помните:

• print() автоматически использует str() для своих аргументов
• для большинства базовых типов результаты str() и repr() совпадают или очень похожи
• для строк repr() добавляет кавычки и показывает управляющие последовательности
• repr() предназначено для однозначного и (по возможности) пригодного к восстановлению представления

Итоги главы

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

Переменные:

• переменные — это имена, которые ссылаются на значения в памяти
• создаются с помощью присваивания: variable_name = value
• могут быть переназначены в любой момент
• должны соблюдать правила именования и желательно следовать соглашениям стиля
• используйте описательные имена, чтобы код был самодокументируемым

Типы данных:

• каждое значение в Python имеет тип
• используйте type(), чтобы проверить тип значения
• Python — язык с динамической типизацией: переменная может ссылаться на значения разных типов в разное время
• разные типы поддерживают разные операции

Базовые типы:

• int: целые числа (положительные, отрицательные и ноль) произвольной длины
• float: числа с плавающей точкой, подвержены ограничению точности
• str: текст, заключённый в кавычки (одинарные или двойные)
• bool: логические значения True или False
• None: специальное значение, обозначающее отсутствие значения

Приведение типов:

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

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

• str(): человеко‑читаемое представление для конечных пользователей
• repr(): однозначное представление для разработчиков и отладки
• print() по умолчанию использует str()

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

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