Переменные в Python

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

Переменная в Python это имя, связанное с объектом в памяти. Создают ее одним присваиванием, без объявления типа: age = 28. Тип Python определяет сам по значению, и он может поменяться по ходу работы программы, поэтому ту же переменную можно сделать строкой: age = "двадцать восемь". В имени разрешены буквы, цифры и знак подчеркивания, начинаться с цифры и совпадать с ключевым словом языка оно не может, а по соглашению PEP 8 переменные пишут строчными буквами через подчеркивание: user_name.

Зачем нужны переменные? Как их правильно задавать? И почему в одном языке тип указывать надо, а в другом нет? Я программирую уже кучу лет и учил сотни студентов, и могу сказать: переменные в Python это штука, которая кажется простой, но без нее никуда. Если вы только начинаете, это первое, что стоит зафиксировать у себя в голове.

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

Кратко

• Переменная это имя, привязанное к объекту в памяти, а не ячейка с данными. Присваивание перевешивает имя на другой объект.
• Объявлять тип заранее не нужно: достаточно одного присваивания, тип берется из значения и может поменяться во время работы программы.
• В имени можно использовать буквы, цифры и подчеркивание. Начинать с цифры нельзя, ключевые слова занимать нельзя, а регистр важен: name и Name это разные переменные.
• По PEP 8 переменные пишут в snake_case, константы заглавными буквами. Константы язык не охраняет, заглавные буквы это договоренность между людьми.
• Имена ищутся по правилу LEGB: локальная область, объемлющая, глобальная, встроенная. Присваивание внутри функции создает локальное имя, и чтобы записать во внешнее, нужны global или nonlocal.
• Аннотация вида age: int = 25 ничего не проверяет во время выполнения: это подсказка для редактора кода и для анализаторов вроде mypy.

Что такое переменные в Python?

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

В Python переменная это просто имя, которое указывает на какой-то объект в памяти компа. И это, кстати, не как в некоторых других языках, где все работает по-другому. Когда вы пишете:

x = 5

Вы не создаете "ячейку памяти с именем x", а даете имя "x" объекту со значением 5. Это важно понимать, потому что объясняет многие особенности поведения переменных в Python.

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

• Хранить данные для последующего использования
• Делать код более читаемым и понятным
• Избегать повторения одинаковых значений
• Передавать информацию между различными частями программы

Как создать переменную в Python

Создание переменных в Python поражает своей простотой. Помню, как мои знакомые, изучавшие C++ или Java, удивлялись: "И все? Не нужно писать int или string?"

Действительно, в Python все максимально просто:

# Создаем переменные разных типов
name = "Алексей"
age = 28
height = 1.75
is_student = True

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

Крутая штука: в Python не надо заранее объявлять переменные, как в некоторых других языках, где ты сначала пишешь int x; и только потом лепишь туда значение. Здесь просто берешь и присваиваешь, и бам, переменная уже есть. Когда я только начинал кодить, эта фича реально спасала мозги, особенно после языков, где надо все заранее расписывать.

# Можно присваивать значения нескольким переменным одновременно
x, y, z = 1, 2, 3

# Или одно значение нескольким переменным
a = b = c = 100

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

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

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

# Начинаем с числа
counter = 42
print(f"counter = {counter}, тип: {type(counter)}")

# Меняем на строку
counter = "Теперь это строка"
print(f"counter = {counter}, тип: {type(counter)}")

# А теперь список
counter = [1, 2, 3]
print(f"counter = {counter}, тип: {type(counter)}")

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

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

Правила именования переменных в Python

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

Технические требования:

# Правильные имена
user_name = "Иван"
age2 = 25
_private_var = "секрет"
MAX_VALUE = 100

# Неправильные имена (вызовут ошибку)
# 2age = 25        # нельзя начинать с цифры
# user-name = "Иван"  # дефис запрещен
# for = 10         # зарезервированное слово

Основные правила:

• Имя может содержать буквы (включая русские), цифры и знак подчеркивания: справочник языка разрешает любые буквы, не только латинские
• Нельзя начинать с цифры
• Python чувствителен к регистру: Name и name это разные переменные
• Нельзя использовать зарезервированные слова (for, if, class и т.д.)

Проверим зарезервированные слова:

import keyword
print(keyword.kwlist)  # Покажет все зарезервированные слова

В том же модуле рядом с kwlist лежит keyword.softkwlist, он появился в Python 3.9. Это мягкие ключевые слова: _, case, match и type. Особый смысл у них только внутри своих конструкций, а в остальном коде они годятся как обычные имена, match = 5 работает.

Лучшие практики именования переменных

За годы программирования я выработал несколько принципов, которые делают код понятнее. Все они опираются на раздел про именование в PEP 8. Вот они:

1. Используйте snake_case (стандарт PEP 8)

# Хорошо
user_name = "Петр"
total_amount = 1500
is_authenticated = True

# Плохо (но технически корректно)
userName = "Петр"  # camelCase не принят в Python
TotalAmount = 1500  # PascalCase тоже

2. Делайте имена описательными

# Хорошо
monthly_salary = 50000
user_age = 30
discount_percentage = 15

# Плохо
s = 50000  # что это за s?
u = 30     # что означает u?
d = 15     # непонятно

Помню случай из практики: программист использовал переменную x для хранения количества дней до дедлайна проекта. Через месяц даже он сам не помнил, что означает эта x.

3. Константы пишите большими буквами

PI = 3.14159
MAX_ATTEMPTS = 3
DATABASE_URL = "postgresql://localhost/mydb"

4. Используйте понятные сокращения

# Приемлемо
num_users = 100
temp_file = "temp.txt"

# Избегайте криптичных сокращений
usr_cnt = 100  # что это?
tf = "temp.txt"  # неясно

Основные типы данных переменных в Python

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

# Числовые типы
integer_number = 42                    # int - целое число
float_number = 3.14                   # float - число с плавающей точкой
complex_number = 2 + 3j               # complex - комплексное число

# Строковый тип
text = "Привет, мир!"                 # str - строка
multiline_text = """Многострочный
текст тоже
поддерживается"""

# Логический тип
is_active = True                      # bool - булево значение
is_completed = False

# Коллекции
numbers_list = [1, 2, 3, 4, 5]       # list - список
coordinates = (10, 20)               # tuple - кортеж
unique_items = {1, 2, 3}             # set - множество
user_data = {"name": "Анна", "age": 25}  # dict - словарь

# Проверяем типы
print(f"Тип {integer_number}: {type(integer_number)}")
print(f"Тип {text}: {type(text)}")
print(f"Тип {numbers_list}: {type(numbers_list)}")

Интересный факт: в Python все является объектами. Даже простое число 42 это объект со своими методами:

number = 42
print(number.bit_length())  # Количество битов для представления числа

Область видимости переменных в Python

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

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

• Local: локальная область видимости
• Enclosing: объемлющая область видимости
• Global: глобальная область видимости
• Built-in: встроенная область видимости

# Глобальная переменная
global_var = "Я глобальная"

def outer_function():
    # Переменная в объемлющей области
    enclosing_var = "Я в объемлющей области"
    
    def inner_function():
        # Локальная переменная
        local_var = "Я локальная"
        
        # Можем обращаться ко всем уровням
        print(f"Локальная: {local_var}")
        print(f"Объемлющая: {enclosing_var}")
        print(f"Глобальная: {global_var}")
        print(f"Встроенная: {len([1, 2, 3])}")  # len - встроенная функция
    
    inner_function()

outer_function()

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

Глобальные и локальные переменные

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

# Глобальная переменная
balance = 1000

def withdraw_money(amount):
    # Это создаст НОВУЮ локальную переменную!
    balance = balance - amount  # Ошибка!
    return balance

# Правильный способ №1: возвращаем значение
def withdraw_money_correct(current_balance, amount):
    return current_balance - amount

# Правильный способ №2: используем global
def withdraw_money_global(amount):
    global balance
    balance = balance - amount
    return balance

# Пример использования
print(f"Изначальный баланс: {balance}")
new_balance = withdraw_money_correct(balance, 100)
print(f"Баланс после снятия: {new_balance}")

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

Удаление переменных с помощью del

Иногда нужно явно удалить переменную из памяти. Для этого используется оператор del:

# Создаем переменную
large_data = list(range(1000000))
print(f"Размер списка: {len(large_data)}")

# Удаляем переменную
del large_data

# Попытка обращения вызовет ошибку
try:
    print(large_data)
except NameError:
    print("Переменная large_data больше не существует")

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

Аннотации типов (Type Hints) в Python

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

# Без аннотаций типов
def calculate_discount(price, discount):
    return price * (1 - discount / 100)

# С аннотациями типов  
def calculate_discount_typed(price: float, discount: float) -> float:
    return price * (1 - discount / 100)

# Аннотации для переменных
name: str = "Анна"
age: int = 25
height: float = 1.68
is_student: bool = True

# Сложные типы (с Python 3.9 импорт не нужен)
grades: list[int] = [5, 4, 5, 3]
student_data: dict[str, int] = {"математика": 5, "физика": 4}

В листинге выше современная запись: с Python 3.9 встроенные типы принимают параметр сами, поэтому для list и dict импорт из typing не нужен. В коде постарше вы встретите другой вариант: строку from typing import List, Dict, а дальше List[int] и Dict[str, int] с заглавной буквы. Он работает до сих пор, но документация называет List и Dict устаревшими псевдонимами, так что в новом коде лучше брать строчные варианты.

Важно понимать: это именно аннотации, а не строгие требования. Python не будет проверять типы во время выполнения, но специальные инструменты (например, mypy) могут это делать.

Практические примеры использования переменных

Теория без практики это как автомобиль без колес. Вот несколько реальных сценариев использования переменных:

Пример 1: Счетчик элементов

# Подсчет положительных и отрицательных чисел
numbers = [1, -2, 3, -4, 5, -6, 7]
positive_count = 0
negative_count = 0

for number in numbers:
    if number > 0:
        positive_count += 1
    elif number < 0:
        negative_count += 1

print(f"Положительных: {positive_count}, отрицательных: {negative_count}")

Пример 2: Аккумулятор значений

# Вычисление среднего балла
grades = [5, 4, 5, 3, 4, 5]
total_sum = 0
count = 0

for grade in grades:
    total_sum += grade
    count += 1

average = total_sum / count
print(f"Средний балл: {average:.2f}")

Пример 3: Флаги состояния

# Проверка валидности данных пользователя
email = "user@example.com"
password = "mypassword123"

is_valid_email = "@" in email and "." in email
is_valid_password = len(password) >= 8
is_user_valid = is_valid_email and is_valid_password

if is_user_valid:
    print("Пользователь может быть зарегистрирован")
else:
    print("Данные пользователя некорректны")

Типичные ошибки при работе с переменными

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

Ошибка 1: Использование неопределенной переменной

# Неправильно
print(username)  # NameError: name 'username' is not defined

# Правильно
username = "Иван"
print(username)

Ошибка 2: Неправильное именование

# Избегайте таких имен
list = [1, 2, 3]  # затеняет встроенный тип list
str = "текст"     # затеняет встроенный тип str

# Лучше
my_list = [1, 2, 3]
text = "текст"

Ошибка 3: Путаница с типами

# Может привести к неожиданным результатам
age = "25"
next_year_age = age + 1  # TypeError!

# Правильно
age = int("25")
next_year_age = age + 1

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

Ошибка 4: Изменение переменных в неправильной области видимости

counter = 0

def increment():
    counter = counter + 1  # UnboundLocalError!
    return counter

# Правильные варианты:
def increment_return():
    return counter + 1

def increment_global():
    global counter
    counter = counter + 1
    return counter

Часто задаваемые вопросы (FAQ)

Q: Как проверить, определена ли переменная?
A: Можно использовать конструкцию try-except или функцию locals() / globals():

try:
    print(my_variable)
except NameError:
    print("Переменная не определена")

Q: В чем разница между = и == ?
A: Оператор = используется для присваивания значения, а == для сравнения значений.

Q: Зачем переменной значение None?
A: None это отдельный объект со смыслом «значения пока нет». Он нужен, когда переменную создают заранее, а чем ее заполнить, выяснится позже. Тип такой переменной называется NoneType, а проверять ее принято через x is None, а не через ==.

Q: Почему функция падает с UnboundLocalError, хотя переменная создана выше?
A: Потому что присваивание внутри функции делает имя локальным на всю функцию, и чтение до присваивания оказывается обращением к пустому локальному имени. Выходов четыре: передать значение параметром, вернуть результат через return, объявить global для переменной модуля или nonlocal для переменной внешней функции.

Q: Есть ли в Python настоящие константы?
A: Нет. Заглавные буквы в MAX_ATTEMPTS это договоренность между разработчиками, переприсвоить такое имя язык не помешает. Анализаторы кода умеют ругаться на это, если пометить значение аннотацией Final из модуля typing, но и она ничего не запрещает во время выполнения.

Q: Можно ли называть переменные русскими буквами?
A: Технически да, имя = "Иван" работает: справочник языка разрешает в именах любые буквы, не только латинские. Но PEP 8 требует имена только из ASCII для стандартной библиотеки и советует то же самое проектам с международной аудиторией, поэтому в рабочем коде лучше писать имена по-английски.

Практическое задание

Теперь попробуйте сами! Создайте программу для управления личными финансами:

# Создайте переменные для хранения информации о пользователе
# имя, возраст, месячный доход, месячные расходы

# Вычислите годовую экономию
# Выведите информацию в красивом формате

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

Заключение

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

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

Читайте также:

• Input в Python
• Операторы сравнения в Python
• Str в Python
• Цикл for в Python