Зачем нужны переменные? Как их правильно задавать? И почему в одном языке надо указывать тип, а в другом — нет? Я программирую уже кучу лет и учил сотни студентов, и могу сказать: переменные в Python — это штука, которая кажется простой, но без неё никуда. Если вы только начинаете, это первое, что стоит зафиксировать у себя в голове.
Допустим вы создаете код для какого-нибудь интернет-магазина. Нужно запомнить имя клиента, сколько ему лет, сколько он там накупил. И вот тут на сцену выходят переменные — это как карманы в твоей программе, куда можно засунуть нужные данные и потом их достать, когда надо. Я в этой статье разберу всё по полочкам: от того, как просто завести переменную, до всяких приёмов, которые реально выручат, когда будешь кодить что-то посерьёзнее.
Что такое переменные в 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 — свобода! Хочешь, меняй тип переменной прямо на ходу, пока программа работает.
# Начинаем с числа
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) # Покажет все зарезервированные словаЛучшие практики именования переменных
За годы программирования я выработал несколько принципов, которые делают код понятнее. Вот они:
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 поддерживает несколько встроенных типов данных. Давайте разберем самые важные:
# Числовые типы
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()Глобальные и локальные переменные
Различие между глобальными и локальными переменными — источник многих ошибок в коде начинающих программистов. Давайте разберем на практических примерах:
# Глобальная переменная
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
# Сложные типы
from typing import List, Dict
grades: List[int] = [5, 4, 5, 3]
student_data: Dict[str, int] = {"математика": 5, "физика": 4}Важно понимать: это именно аннотации, а не строгие требования. 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Ошибка 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: Оператор = используется для присваивания значения, а == для сравнения значений.
Практическое задание
Теперь попробуйте сами! Создайте программу для управления личными финансами:
# Создайте переменные для хранения информации о пользователе
# имя, возраст, месячный доход, месячные расходы
# Вычислите годовую экономию
# Выведите информацию в красивом форматеЕсли вы только начинаете изучать Python, рекомендую попробовать интерактивный курс Python на JavaRush. У нас каждая тема закрепляется множеством практических задач с автоматической проверкой — это намного эффективнее чем просто чтение теории.
Заключение
Переменные в Python — это как фундамент дома: без них всё развалится. Мы разобрали, как их создавать, как правильно называть, какие бывают типы данных, что такое области видимости и как сейчас модно использовать аннотации типов.
Но вот вам совет: программирование — это не теория, а чистая практика. Не бойтесь засунуть руки в код по локоть! Создавайте переменные, пробуйте закидывать в них разные значения, играйтесь с типами данных. Когда я только начинал, половину фишек я понял, просто тыкаясь и ломая свой код — и это нормально!
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ