Переменные и типы данных

Возвращаемся к Python.

В предыдущем уроке ты установил Python, открыл терминал, создал свой первый .py файл и использовал print().

Очень хорошо.

Ты сказал Python:

print("Hello, World!")

И Python послушался.

Прекрасное начало.

Но теперь нам нужно что-то полезнее.

Выводить текст — это хорошо.

Но настоящие программы должны запоминать вещи.

Имена.

Возраст.

Цены.

Баллы.

Имена пользователей.

Пути к файлам.

Информацию о том, является ли что-то правдой или нет.

И тут на сцену выходят переменные.

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

Без переменных твоя программа имела бы память золотой рыбки после обновления системы.

Не идеально.

Что ты изучишь

В этом уроке ты изучишь:

что такое переменные;
как создавать переменные в Python;
как выводить переменные;
как изменять значение переменной;
как работают строки;
как работают целые числа;
как работают float;
как работают boolean;
как проверять типы данных через type();
как давать переменным понятные названия;
типичные ошибки начинающих;
как практиковаться с простыми данными.

К концу этого урока ты поймёшь, как Python хранит базовую информацию.

Это огромный шаг.

Потому что когда программа может запоминать значения, она начинает делать полезные вещи.

Маленькая память.

Большая сила.

Очень Python.

Что такое переменная?

Переменная — это название, которое хранит значение.

Пример:

name = "Anna"

Здесь:

name

это переменная.

А:

"Anna"

это значение.

Символ = означает:

сохрани это значение под этим названием

То есть эта строка означает:

Сохрани "Anna" в переменной с названием name.

Теперь Python помнит, что name означает "Anna".

Очень полезно.

Очень просто.

Очень опасно, если назвать всё thing.

Твоя первая переменная

Создай файл:

variables.py

Напиши:

name = "Anna"

print(name)

Запусти:

python variables.py

или:

python3 variables.py

Output:

Anna

Python не печатает слово name.

Он печатает значение, которое сохранено внутри name.

В этом и смысл переменных.

Переменная — как этикетка на коробке.

Значение — это то, что лежит в коробке.

Очень организованно.

Очень полезно.

В отличие от некоторых реальных ящиков в реальных домах.

Переменные могут хранить разные значения

Можно создать больше переменных:

name = "Anna"
age = 25
city = "Rome"

print(name)
print(age)
print(city)

Output:

Anna
25
Rome

Здесь мы сохраняем:

текст в name;
число в age;
текст в city.

Python помнит каждое значение.

Потом print() их показывает.

Твоя программа уже не просто кричит фиксированный текст.

Теперь она может хранить информацию.

Появился маленький мозг.

Уважай его.

Изменение значения переменной

Переменная может изменяться.

Пример:

name = "Anna"
print(name)

name = "Marco"
print(name)

Output:

Anna
Marco

Сначала name хранит "Anna".

Потом мы заменяем это значение на "Marco".

Старое значение исчезает из этой переменной.

Python не становится эмоциональным.

Он не говорит:

Но Anna была здесь первой.

Он просто обновляет значение.

Очень холодно.

Очень эффективно.

Очень компьютерно.

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

Python выполняет код сверху вниз.

Пример:

name = "Anna"
print(name)

name = "Sofia"
print(name)

Output:

Anna
Sofia

Во время первого print(name) значение — "Anna".

Во время второго print(name) значение — "Sofia".

Python не смотрит в будущее.

Он выполняет код строка за строкой.

Как очень послушный поезд.

Обычно по расписанию.

Пока твой код не сойдёт с рельсов.

Строки

Строка — это текст.

Строки пишутся в кавычках.

Пример:

name = "Anna"
city = "Rome"
message = "I am learning Python"

Можно вывести их:

print(name)
print(city)
print(message)

Output:

Anna
Rome
I am learning Python

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

name = "Anna"

Или одинарные кавычки:

name = 'Anna'

Оба варианта работают.

Но не смешивай их.

Неправильно:

name = "Anna'

Python пожалуется.

И в этот раз Python прав.

Кавычки должны совпадать.

Строка — как чемодан.

Если открыть его одним замком, а закрывать другим, начинается хаос.

Строки могут содержать пробелы

Строки могут содержать пробелы:

full_name = "Anna Rossi"
message = "Python is very useful"

print(full_name)
print(message)

Output:

Anna Rossi
Python is very useful

Всё, что находится внутри кавычек, является частью строки.

Пробелы тоже.

Python не удаляет пробелы, потому что вдруг захотел порядка.

Python сохраняет то, что ты написал.

Очень буквально.

Очень верно.

Иногда слишком верно.

Числа: integers

Integer — это целое число.

Пример:

age = 25
year = 2026
quantity = 10

Целым числам не нужны кавычки.

Правильно:

age = 25

А это уже другое:

age = "25"

Первое — число.

Второе — текст.

Люди видят оба как 25.

Python видит две разные вещи.

Python не впечатлён визуальным сходством.

Python хочет типы.

Маленький строгий бухгалтер.

Числа: float

Float — это число с десятичной частью.

Пример:

price = 19.99
temperature = 21.5
height = 1.75

Float полезны для цен, измерений, средних значений и многих других вещей.

Пример:

price = 19.99

print(price)

Output:

19.99

Важная деталь:

price = 19.99

использует точку.

Не запятую.

Правильно:

price = 19.99

Неправильно:

price = 19,99

В Python десятичные числа используют точку.

Запятая имеет другие значения.

Python не волнует, что в твоей стране цены могут писаться иначе.

У Python свои правила на кухне.

Boolean

Boolean — это значение, которое может быть:

True

или:

False

Пример:

is_student = True
is_admin = False

print(is_student)
print(is_admin)

Output:

True
False

Boolean очень полезны для решений.

Примеры идей:

Пользователь вошёл в систему?
Файл доступен?
Пароль правильный?
Товар есть в наличии?

Boolean простые.

Но мощные.

Как выключатель света.

Включено.

Выключено.

Без философской дискуссии.

True и False должны быть с большой буквы

В Python boolean пишутся так:

True
False

Неправильно:

true
false

Python не поймёт их как boolean.

Python является case-sensitive.

Это означает, что большие и маленькие буквы имеют значение.

Это разные вещи:

True
true
TRUE

Правильно только:

True

То же самое с:

False

Python вежливый.

Но здесь он не принимает творческую орфографию.

Проверка типов через type()

Python может сказать, какой тип имеет значение.

Используй type().

Пример:

name = "Anna"
age = 25
price = 19.99
is_student = True

print(type(name))
print(type(age))
print(type(price))
print(type(is_student))

Output:

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

Это означает:

str    строка
int    целое число
float  десятичное число
bool   boolean

type() полезен, когда ты не уверен, какой тип имеет значение.

Очень полезно во время debugging.

А debugging — это детективная работа с большим количеством кофе.

Четыре базовых типа данных

Пока запомни эти четыре:

str    текст
int    целое число
float  десятичное число
bool   True или False

Примеры:

name = "Anna"        # str
age = 25             # int
price = 19.99        # float
is_active = True     # bool

Эти типы данных везде.

Ты будешь использовать их постоянно.

Они как базовые ингредиенты Python-кухни.

Текст.

Числа.

Десятичные числа.

Правда.

Странный рецепт.

Но работает.

Вывод текста и переменных вместе

Можно выводить текст и переменные вместе, используя запятые:

name = "Anna"
age = 25

print("Name:", name)
print("Age:", age)

Output:

Name: Anna
Age: 25

Это просто и полезно.

print() может принимать несколько значений, разделённых запятыми.

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

Очень мило.

Как для него.

Использование f-strings

Очень распространённый способ соединять текст и переменные — это f-string.

Пример:

name = "Anna"
age = 25

print(f"My name is {name}.")
print(f"I am {age} years old.")

Output:

My name is Anna.
I am 25 years old.

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

Эта строка может содержать переменные внутри фигурных скобок.

Пример:

f"My name is {name}"

Python заменяет:

{name}

на значение переменной.

f-strings очень полезны.

Очень читаемые.

Очень Python.

Используй их часто.

Будущий ты одобрит.

Простые вычисления с переменными

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

Пример:

price = 10
quantity = 3

total = price * quantity

print(total)

Output:

Здесь Python вычисляет:

10 * 3

и сохраняет результат в:

total

Потом мы выводим total.

Очень полезно.

Это начало настоящей программной логики.

Маленький магазин.

Маленькое вычисление.

Большая идея.

Больше примеров вычислений

Попробуй:

a = 10
b = 5

print(a + b)
print(a - b)
print(a * b)
print(a / b)

Output:

Можно также сохранять результаты:

a = 10
b = 5

sum_result = a + b
difference = a - b
product = a * b
division = a / b

print(sum_result)
print(difference)
print(product)
print(division)

Это понятнее, когда программы растут.

Понятные названия имеют значение.

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

x = a * b

Будущий ты уже достаточно страдал.

Обновление числа

Можно обновить переменную, используя её старое значение.

Пример:

score = 10
score = score + 5

print(score)

Output:

Это означает:

Возьми старое значение score.
Добавь 5.
Сохрани новое значение обратно в score.

Это очень распространено.

Сначала может выглядеть странно.

В математике это было бы странно.

В программировании это нормально.

Символ = в Python означает присваивание.

Не “равно навсегда”.

А:

положи это значение в эту переменную

Очень важно.

Более короткий синтаксис обновления

Python имеет более короткий способ:

score = 10
score += 5

print(score)

Output:

Это:

score += 5

означает:

score = score + 5

Можно также использовать:

score -= 2
score *= 3
score /= 2

Пока не переживай слишком сильно.

Просто знай, что такой синтаксис существует.

Python-разработчики часто его используют.

Потому что, очевидно, экономия нескольких символов даёт нам ощущение силы.

Правила названий переменных

Названия переменных должны соблюдать правила.

Хорошие названия:

name = "Anna"
user_age = 25
product_price = 19.99
is_active = True

Правила:

используй буквы, цифры и underscores;
не начинай с цифры;
не используй пробелы;
не используй ключевые слова Python;
названия являются case-sensitive.

Неправильно:

2name = "Anna"
user age = 25
product-price = 19.99

Это не будет работать.

Названия переменных в Python должны быть валидными.

Python здесь не гибкий.

Даже если попросить очень вежливо.

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

Плохо:

x = "Anna"
y = 25
z = 19.99

Лучше:

name = "Anna"
age = 25
price = 19.99

Понятные названия делают код легче для понимания.

Это важнее, чем думают начинающие.

Программу чаще читают, чем пишут.

Особенно ты сам.

В полночь.

Когда уже забыл, что написал.

Поэтому не наказывай будущего себя.

Используй хорошие названия.

Snake case

В Python названия переменных обычно используют snake_case.

Пример:

first_name = "Anna"
last_name = "Rossi"
user_age = 25
product_price = 19.99

Snake case означает:

маленькие буквы, разделённые underscores

Вот так:

very_clear_variable_name

Это называется snake_case, потому что выглядит как змея.

Очень организованная змея.

Поскольку мы в Python, это звучит уместно.

Case sensitivity

Python является case-sensitive.

Это разные переменные:

name = "Anna"
Name = "Marco"
NAME = "Sofia"

print(name)
print(Name)
print(NAME)

Output:

Anna
Marco
Sofia

Python видит их как три разные названия.

Но, пожалуйста, не делай так в реальном коде.

Это запутывает.

Запутанный код — это место, где bugs арендуют квартиры.

Используй один понятный стиль.

Лучше:

name

а не:

Name
NAME
nAmE

Твой код — не письмо от похитителя.

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

Неправильно:

print(name)

name = "Anna"

Python выполняет код сверху вниз.

В первой строке name ещё не существует.

Поэтому Python жалуется:

NameError: name 'name' is not defined

Правильно:

name = "Anna"

print(name)

Сначала создай переменную.

Потом используй.

Очень просто.

Очень важно.

Как надеть обувь перед выходом на улицу.

Обычно рекомендуется.

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

Неправильно:

name = Anna

Python думает, что Anna — это переменная.

Но мы не создавали переменную с названием Anna.

Правильно:

name = "Anna"

Тексту нужны кавычки.

Названиям переменных — нет.

Сравни:

name = "Anna"
print(name)

Это выводит:

Anna

Кавычки создают текст.

Переменная его сохраняет.

Потом print(name) показывает сохранённое значение.

Очень чисто.

Очень Python.

Типичная ошибка: путать числа и строки

Посмотри на это:

age = 25

Это integer.

А теперь это:

age = "25"

Это string.

Это не одно и то же.

Попробуй:

age = "25"

print(type(age))

Output:

<class 'str'>

Хотя это выглядит как число, Python относится к нему как к тексту, потому что оно в кавычках.

Это важно.

Очень важно.

Особенно во время вычислений.

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

Попробуй:

age = "25"
next_year = age + 1

print(next_year)

Это даст ошибку.

Почему?

Потому что age — это текст.

Python не может добавить число 1 к тексту "25".

Правильно:

age = 25
next_year = age + 1

print(next_year)

Output:

Типы данных имеют значение.

Python не угадывает.

Python не говорит:

Это выглядит как число, возможно...

Нет.

Python придерживается типа.

Строгий.

Но справедливый.

В основном.

Конвертация типов

Иногда нужно превратить значение из одного типа в другой.

Примеры:

age_text = "25"
age_number = int(age_text)

print(age_number + 1)

Output:

Здесь:

int(age_text)

превращает string "25" в integer 25.

Можно также использовать:

str()
float()
bool()

Примеры:

number = 25
text = str(number)

price_text = "19.99"
price = float(price_text)

Мы больше попрактикуем конвертацию типов позже.

Пока просто знай, что она существует.

Это как сказать Python:

Пожалуйста, воспринимай это значение как другой тип.

Python может согласиться.

Если значение имеет смысл.

Пример:

int("banana")

Python категорически не согласится.

И его можно понять.

Мини-программа: цена продукта

Создай файл:

product.py

Напиши:

product_name = "Notebook"
price = 5.99
quantity = 3

total = price * quantity

print(f"Product: {product_name}")
print(f"Price: {price}")
print(f"Quantity: {quantity}")
print(f"Total: {total}")

Запусти:

python product.py

или:

python3 product.py

Output:

Product: Notebook
Price: 5.99
Quantity: 3
Total: 17.97

Это уже полезная логика.

Ты сохраняешь данные.

Вычисляешь результат.

Выводишь понятное сообщение.

Крошечная программа.

Реальная идея.

Очень хорошо.

Мини-программа: профиль пользователя

Создай ещё один файл:

profile.py

Напиши:

first_name = "Anna"
last_name = "Rossi"
age = 25
city = "Rome"
is_student = True

print(f"Name: {first_name} {last_name}")
print(f"Age: {age}")
print(f"City: {city}")
print(f"Student: {is_student}")

Output:

Name: Anna Rossi
Age: 25
City: Rome
Student: True

Это простой профиль пользователя.

Многие реальные приложения хранят такую информацию.

Конечно, реальные приложения хранят её в базах данных.

Но до баз данных нам нужны переменные.

Переменная — это первая маленькая память.

База данных — это большая серьёзная память с документами.

Практика

Создай файл:

practice_variables.py

Напиши переменные для:

своего имени;
своего возраста;
своего города;
любимого языка программирования;
того, изучаешь ли ты Python;
цены чего-то, что ты купил;
количества.

Пример:

name = "Viktor"
age = 33
city = "Vigevano"
favorite_language = "Python"
is_learning_python = True
price = 12.50
quantity = 2

total = price * quantity

print(f"Name: {name}")
print(f"Age: {age}")
print(f"City: {city}")
print(f"Favorite language: {favorite_language}")
print(f"Learning Python: {is_learning_python}")
print(f"Total price: {total}")

Запусти файл.

Потом измени значения.

Запусти снова.

Цель — понять этот цикл:

измени значения
запусти программу
увидь другой output

Это одна из главных сил переменных.

Код может оставаться тем же.

Данные могут изменяться.

Очень полезно.

Очень программирование.

Мини-задание

Создай файл:

small_shop.py

Твоя программа должна хранить:

название продукта;
цену продукта;
количество;
имя клиента;
доступен ли продукт.

Потом вычисли:

total price = price * quantity

Выведи чек так:

Customer: Anna
Product: Keyboard
Available: True
Price: 70.0
Quantity: 2
Total: 140.0

Пример решения:

customer_name = "Anna"
product_name = "Keyboard"
is_available = True
price = 70.0
quantity = 2

total = price * quantity

print(f"Customer: {customer_name}")
print(f"Product: {product_name}")
print(f"Available: {is_available}")
print(f"Price: {price}")
print(f"Quantity: {quantity}")
print(f"Total: {total}")

Теперь измени продукт.

Измени количество.

Измени цену.

Запусти снова.

Так ты учишься.

Не глядя на теорию, пока душа выходит из комнаты.

А изменяя код и смотря, что произойдёт.

Checklist для начинающих

Когда программа не работает, проверь:

Я сохранил файл?
Я запускаю правильный файл?
Я в правильной папке?
Я правильно написал название переменной?
Я создал переменную перед тем, как её использовать?
Я поставил текст в кавычки?
Я использовал точку для десятичных чисел?
Я случайно не использовал пробелы в названиях переменных?
Я написал True и False с большой буквы?

Этот checklist сэкономит тебе время.

Многие ошибки начинающих маленькие.

Крошечная ошибка.

Большая драма.

Классическое программирование.

Итог

Сегодня ты изучил:

переменные хранят значения;
= присваивает значение переменной;
Python выполняет код сверху вниз;
переменные могут изменяться;
strings хранят текст;
integers хранят целые числа;
floats хранят десятичные числа;
booleans хранят True или False;
type() показывает тип значения;
f-strings понятно соединяют текст и переменные;
переменные можно использовать в вычислениях;
названия переменных должны быть понятными;
Python обычно использует snake_case;
Python является case-sensitive;
тексту нужны кавычки;
числам кавычки не нужны;
типы данных имеют значение.

Это один из самых важных уроков в программировании.

Переменные везде.

Каждая полезная программа хранит значения.

Имя.

Число.

Цену.

Результат.

Состояние.

Правду.

Ошибку.

Возможно, не саму ошибку.

Но данные об ошибке.

Очень современно.

Очень Python.

Следующий урок

В следующем уроке мы изучим input.

Ты научишься спрашивать пользователя информацию:

name = input("What is your name? ")

Тогда твои программы станут интерактивными.

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

Именно тогда программа начинает выглядеть живой.

Не слишком живой.

Мы не строим восстание роботов.

Только маленькую Python-программу.

Пока что.