Перейти к содержимому
Editor
ThePythonBookby pythoncompiler.io

Переменные и типы данных в Python: практическое введение

Начальный25 min6 упр.95 XP

Этот урок переведён с английского оригинала.Read in EnglishLeer en españolСообщить об ошибке в переводе

Перед началом
Python для начинающих: первая программа за 5 минут
0/6 упр.

Представьте, что вы отправляете посылку. На бланке есть поле «Вес». Вместо числа вы пишете «тяжёлая». Система доставки падает: она не может рассчитать стоимость по слову «тяжёлая».

Именно такие проблемы в программировании решают типы данных. Тип сообщает Python, чем является значение: числом, фрагментом текста, ответом «да или нет» или вообще ничем. От того, правильно ли учтены типы, зависит, будет код работать или взорвётся.

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

Что такое типы данных в Python?

Тип данных сообщает Python, какого рода это значение. От типа зависит, какие операции с этим значением можно выполнять.

Представьте кухонную утварь. В мерный стакан наливают жидкости. На весах взвешивают твёрдые продукты. Вы же не станете насыпать муку в мерный стакан, рассчитывая узнать её точный вес. Каждый предмет предназначен для чего-то своего.

В Python пять основных типов данных, с которыми вы будете работать каждый день:

Пять основных типов данных Python
# The five core data types
age = 25 # int - whole numbers
temperature = 98.6 # float - decimal numbers
name = "Alice" # str - text
is_sunny = True # bool - True or False
result = None # None - absence of a value
print(type(age)) # <class 'int'>
print(type(temperature)) # <class 'float'>
print(type(name)) # <class 'str'>
print(type(is_sunny)) # <class 'bool'>
print(type(result)) # <class 'NoneType'>
Вывод
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

Функция type() станет вашим лучшим другом при работе с типами данных. Она точно сообщает, с каким значением вы имеете дело. Когда код не работает, проверка типов обычно быстрее всего помогает найти причину.

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

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

Когда нужны целые числа, а когда float

Используйте целые числа, когда значение всегда целое: количество людей, очки в игре, индекс элемента в списке. Используйте float, когда важны доли: температура, проценты, денежные суммы.

Целые числа и float
# Integers - whole numbers, no decimal point
students = 30
lives_remaining = 3
year = 2025
negative_number = -42
# Floats - numbers with a decimal point
pi = 3.14159
batting_average = 0.325
bank_balance = 1042.50
tiny_number = 0.001
print(type(students)) # <class 'int'>
print(type(bank_balance)) # <class 'float'>
Вывод
<class 'int'>
<class 'float'>

Подчёркивания для удобного чтения больших чисел

Большие числа трудно читать. Что записано в 1000000: миллион или десять миллионов? Python разрешает разделять разряды подчёркиваниями. Сам Python подчёркивания полностью игнорирует, они нужны только для ваших глаз.

Подчёркивания в больших числах
# Hard to read
population = 8000000000
# Easy to read - underscores are ignored by Python
population = 8_000_000_000
print(population) # 8000000000
print(type(population)) # <class 'int'>
# Works with floats too
budget = 1_250_000.75
print(budget) # 1250000.75
Вывод
8000000000
<class 'int'>
1250000.75

Проблема 0.1 + 0.2 в Python

Вот что удивляет почти всех, кто видит это впервые. Запустите этот код:

Сюрприз с плавающей точкой
print(0.1 + 0.2)
Вывод
0.30000000000000004

Вы ожидали 0.3, а получили 0.30000000000000004. Это не ошибка Python. Такая проблема есть во всех языках программирования.

Компьютеры хранят числа в двоичном виде (единицами и нулями). Некоторые десятичные числа, например 0,1, невозможно точно записать в двоичной системе, так же как 1/3 нельзя точно записать десятичной дробью (0,333333... тянется бесконечно).

Как справляться с погрешностями float
# The problem
print(0.1 + 0.2 == 0.3) # False!
# Solution 1: round() for display
print(round(0.1 + 0.2, 1)) # 0.3
# Solution 2: check if values are "close enough"
result = 0.1 + 0.2
print(abs(result - 0.3) < 0.0001) # True - close enough!
Вывод
False
0.3
True

Ещё одна важная деталь: обычное деление (/) всегда даёт float, даже если оба числа целые и результат получается целым.

Деление всегда возвращает float
print(10 / 2) # 5.0 - float, not int!
print(type(10 / 2)) # <class 'float'>
# Use // for integer division
print(10 // 2) # 5 - int!
print(type(10 // 2)) # <class 'int'>
Вывод
5.0
<class 'float'>
5
<class 'int'>

Логические значения в Python (True и False)

Логический тип (boolean) является самым простым типом данных в Python. У него всего два возможных значения: True или False. И всё.

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

Логические значения и сравнения
is_raining = True
has_umbrella = False
print(is_raining) # True
print(type(is_raining)) # <class 'bool'>
# Comparisons produce booleans
print(10 > 5) # True
print(10 < 5) # False
print(10 == 10) # True
print(10 != 10) # False
Вывод
True
<class 'bool'>
True
False
True
False

Что такое истинные и ложные значения (truthy и falsy) в Python?

Любое значение в Python можно использовать как логическое. Одни значения считаются True (их называют truthy, «истинными»), другие считаются False (falsy, «ложными»). Проверить любое значение можно, передав его в bool().

Истинные и ложные значения
# Falsy values - these all act like False
print(bool(0)) # False - zero
print(bool(0.0)) # False - zero float
print(bool("")) # False - empty string
print(bool(None)) # False - None
print(bool([])) # False - empty list
print("---")
# Truthy values - everything else acts like True
print(bool(1)) # True - any non-zero number
print(bool(-5)) # True - negative numbers too!
print(bool("hello")) # True - any non-empty string
print(bool("False")) # True - the STRING "False" is truthy!
print(bool([1, 2])) # True - non-empty list
Вывод
False
False
False
False
False
---
True
True
True
True
True

Вот полный список ложных значений. Запомните их, всё остальное истинно:

Ложное значениеТипПочему оно ложное
FalseboolЭто и есть False
0intНоль
0.0floatНоль
""strПустая строка
NoneNoneTypeОтсутствие значения
[]listПустой список
{}dictПустой словарь

Что такое None в Python?

None означает в Python «здесь ничего нет». Это не ноль. Это не пустая строка. Это полное отсутствие значения.

Представьте анкету с полем «Второе имя». Если человек оставил его пустым, это не то же самое, что написать число 0 или пустую строку "". Второго имени у него нет, вот и всё. Это пустое поле и есть None.

None не ноль и не пустое значение
middle_name = None
print(middle_name) # None
print(type(middle_name)) # <class 'NoneType'>
# None is NOT the same as 0, False, or ""
print(None == 0) # False
print(None == False) # False
print(None == "") # False
Вывод
None
<class 'NoneType'>
False
False
False

Как проверить значение на None в Python

Для проверки на None всегда используйте is None или is not None. Не используйте ==. Это соглашение Python, и за ним стоит настоящая техническая причина.

Не стоит: == None
value = None

if value == None:
    print("No value")
Лучше: is None
value = None

if value is None:
    print("No value")
None как значение по умолчанию
# Common pattern: using None as a default
def greet(name=None):
if name is None:
print("Hello, stranger!")
else:
print(f"Hello, {name}!")
greet() # Hello, stranger!
greet("Alice") # Hello, Alice!
Вывод
Hello, stranger!
Hello, Alice!

None постоянно используется как значение по умолчанию в функциях. Это аккуратный способ сказать: «этот аргумент необязателен».

Как проверить тип переменной в Python

Для проверки типов в Python есть два инструмента: type() и isinstance(). Они похожи, но служат разным целям.

Как узнать тип значения с помощью type()

type() сообщает точный тип значения. Это отличный инструмент для отладки: когда что-то не работает, проверка типа часто сразу показывает причину.

Изучаем значения с помощью type()
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("hello")) # <class 'str'>
print(type(True)) # <class 'bool'>
print(type(None)) # <class 'NoneType'>
# You can compare types directly
age = 25
print(type(age) == int) # True
print(type(age) == str) # False
Вывод
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>
True
False

Проверка типов с помощью isinstance()

isinstance() проверяет, относится ли значение к определённому типу (или к одному из нескольких типов). В реальном коде типы лучше проверять именно так: эта функция учитывает наследование и читается понятнее.

isinstance(): предпочтительный способ проверки типов
age = 25
name = "Alice"
temperature = 98.6
# Check against one type
print(isinstance(age, int)) # True
print(isinstance(name, str)) # True
print(isinstance(age, str)) # False
# Check against multiple types at once
print(isinstance(age, (int, float))) # True - age is an int
print(isinstance(temperature, (int, float))) # True - temp is a float
print(isinstance(name, (int, float))) # False - name is a str
Вывод
True
True
False
True
True
False

Любопытный факт: в Python логический тип на самом деле является подклассом целых чисел. True втайне равно 1, а False втайне равно 0.

Связь между bool и int
# Booleans are secretly integers
print(isinstance(True, int)) # True - bool is a subclass of int!
print(isinstance(True, bool)) # True
# This means you can do math with booleans
print(True + True) # 2
print(True * 10) # 10
print(False + 42) # 42
Вывод
True
True
2
10
42

Как преобразовывать типы в Python

Иногда значение хранится в одном типе, а нужно в другом. Пользователь вводит в форму свой возраст, и он приходит как строка "25", а для вычислений нужно целое число 25. Для преобразования типов в Python есть встроенные функции.

Преобразование с помощью int(), float(), str() и bool()

Основы преобразования типов
# str → int
age_text = "25"
age_number = int(age_text)
print(age_number + 5) # 30 - now we can do math!
# str → float
price_text = "9.99"
price = float(price_text)
print(price * 2) # 19.98
# int → str
score = 100
message = "Your score: " + str(score)
print(message) # Your score: 100
# int → float
whole = 42
decimal = float(whole)
print(decimal) # 42.0
# float → int (truncates - does NOT round!)
pi = 3.99
whole_pi = int(pi)
print(whole_pi) # 3 - the .99 is chopped off!
Вывод
30
19.98
Your score: 100
42.0
3

Частые ловушки при преобразовании типов

Не всякое преобразование возможно. Если попытаться преобразовать что-то бессмысленное, Python упадёт с ошибкой ValueError.

Преобразования, которые не работают
# These work fine
print(int("42")) # 42
print(float("3.14")) # 3.14
print(str(100)) # "100"
# These will CRASH
try:
print(int("hello")) # ValueError! "hello" isn't a number
except ValueError as e:
print(f"Error: {e}")
try:
print(int("3.14")) # ValueError! int() can't handle decimals in strings
except ValueError as e:
print(f"Error: {e}")
# Fix: convert string to float first, then to int
print(int(float("3.14"))) # 3 - works!
Вывод
42
3.14
100
Error: invalid literal for int() with base 10: 'hello'
Error: invalid literal for int() with base 10: '3.14'
3

Преобразование в bool() подчиняется правилам истинности и ложности, которые мы разобрали выше:

Преобразование в bool
# bool() follows truthy/falsy rules
print(bool(1)) # True
print(bool(0)) # False
print(bool("text")) # True
print(bool("")) # False
print(bool(None)) # False
# Careful: the string "0" is truthy!
print(bool("0")) # True - it's a non-empty string!
Вывод
True
False
True
False
False
True

Присваивание в Python: несколько переменных сразу и обмен значениями

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

Множественное присваивание в одну строку

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

Множественное присваивание
# Assign multiple variables at once
x, y, z = 10, 20, 30
print(x) # 10
print(y) # 20
print(z) # 30
# Great for related values
first_name, last_name, age = "Alice", "Smith", 25
print(f"{first_name} {last_name}, age {age}")
# Assign the same value to multiple variables
a = b = c = 0
print(a, b, c) # 0 0 0
Вывод
10
20
30
Alice Smith, age 25
0 0 0

Обмен значений без временной переменной

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

Другие языки: нужна временная переменная
a = 1
b = 2

# Need a third variable to hold the value
temp = a
a = b
b = temp
print(a, b)  # 2 1
Python: обмен в одну строку
a = 1
b = 2

# Python handles the swap in one step
a, b = b, a
print(a, b)  # 2 1

Строка a, b = b, a работает, потому что Python сначала вычисляет всю правую часть (b, a превращается в 2, 1), а затем присваивает эти значения левой части. Временная переменная не нужна.

Практические упражнения

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

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

Упражнение 1: создайте переменные каждого типа
Напишите код

Создайте по одной переменной каждого основного типа Python и выведите её тип. Вывод должен быть в точности таким:

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

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

# Create one variable of each type
# Print the type of each variable
Упражнение 2: конвертер температуры
Напишите код

Переведите температуру из градусов Фаренгейта в градусы Цельсия.

Формула: **Цельсий = (Фаренгейт - 32) * 5 / 9**

Дана переменная fahrenheit со значением 98.6. Вычислите температуру по Цельсию и выведите результат в точности в таком формате:

98.6F = 37.0C
fahrenheit = 98.6
# Calculate celsius using the formula
# Print the result
Упражнение 3: предскажите вывод (истинно или ложно?)
Угадайте вывод

Не запуская код, предскажите, что выведет каждая строка. Затем запустите его и проверьте свои ответы.

Запишите свои предположения в комментариях, затем нажмите «Запустить», чтобы проверить.

print(bool("")) # Your prediction:
print(bool(0)) # Your prediction:
print(bool("False")) # Your prediction:
print(bool(None)) # Your prediction:
print(bool(-1)) # Your prediction:
print(bool(" ")) # Your prediction:
Упражнение 4: исправьте ошибку (строка + число)
Исправьте ошибку

Этот код должен выводить краткую анкету пользователя, но падает с ошибкой TypeError. Исправьте код, чтобы он выводил:

Name: Alice
Age: 25
Height: 5.6 feet

Исправить можно любым способом (f-строки, преобразование через str() и т. п.).

name = "Alice"
age = 25
height = 5.6
print("Name: " + name)
print("Age: " + age)
print("Height: " + height + " feet")
Упражнение 5: поменяйте местами две переменные
Напишите код

Даны две переменные: a = 10 и b = 20. Поменяйте их значения местами без временной переменной, затем выведите обе.

Ожидаемый вывод:

a = 20
b = 10
a = 10
b = 20
# Swap a and b without a temp variable
print(f"a = {a}")
print(f"b = {b}")
Упражнение 6: цепочка преобразований типов
Напишите код

Дана строка price_text со значением "49" и целое число quantity, равное 3.

1. Преобразуйте price_text в целое число

2. Вычислите общую сумму (цена, умноженная на количество)

3. Выведите результат в точности в таком формате:

3 items at $49 each = $147 total

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

price_text = "49"
quantity = 3
# Step 1: Convert price_text to an integer
# Step 2: Calculate the total
# Step 3: Print the formatted result

Итоги: переменные и типы данных в Python

Краткая шпаргалка по всему, что вы узнали в этом уроке:

ТипПримерЧто хранит
int42, -7, 1_000Целые числа
float3.14, 0.0, -2.5Дробные числа
str"hello", 'world'Текст
boolTrue, FalseЗначения «да или нет»
NoneNoneОтсутствие значения

Основные инструменты:

ИнструментНазначениеПример
type(x)Узнать тип xtype(42) → <class 'int'>
isinstance(x, int)Проверить, относится ли x к нужному типуisinstance(42, int) → True
int(), float(), str()Преобразовать один тип в другойint("42") → 42
bool()Проверить истинностьbool("") → False
a, b = 1, 2Множественное присваиваниеПрисвоить значения нескольким переменным сразу
a, b = b, aОбмен значениямиБез временной переменной

Что дальше?

В следующем уроке, [Числа и математика](/python/numbers-and-math), вы глубже разберётесь в числах Python. Вы познакомитесь с модулем math, способами округления и форматированием чисел, а ещё научитесь писать программы, которые считают как профи.

Похожие уроки

Основы Python·Начальный
Преобразование типов в Python: int(), float(), str(), bool()
20 min5 упр.
Основы Python·Начальный
Python для начинающих: первая программа за 5 минут
20 min4 упр.
Основы Python·Начальный
Числа в Python: int, float и арифметические операции
20 min6 упр.
Основы Python·Начальный
Строки в Python: создание, индексы, срезы и работа с текстом
25 min7 упр.
Структуры данных·Начальный
Списки в Python: создание, доступ, изменение и перебор
30 min8 упр.
Управляющие конструкции·Начальный
Условия if-else в Python: elif, вложенные if и тернарный оператор
25 min6 упр.

Урок был полезен?

Предложить улучшение