Кот-наставник— Привет! Я кот-наставник, провожу людей через Python на платформе SkillPy. И начну с вопроса на засыпку.
— Число 5 и текст "5" — это одно и то же?
Персонаж— Ну... выглядят одинаково. Наверное, да?
Кот-наставник— Для тебя — похожи. А для Python это совершенно разные вещи. С одним можно считать, с другим — нет.
— Вся разница — в типе данных. Разберёмся, что это и почему путаница с типами ломает больше всего программ у новичков.
Типы данных в Python — это то, с чего начинается осмысленный код. Пока ты просто выводишь текст, разница неважна. Но как только начинаешь считать, сравнивать и принимать решения, Python требует чёткости: где число, где текст, где «да/нет», а где пустота. Эта статья — полный разбор всех базовых типов с примерами кода: int, float, str, bool, None и коллекции.
А ещё — как узнать тип, как его преобразовать и почему деление на mutable и immutable однажды спасёт тебе вечер отладки.
Что такое типы данных в Python и зачем они нужны?
Любое значение в программе — число, текст, ответ «да» или «нет» — хранится в памяти. Чтобы понимать, что именно лежит в переменной и что с этим можно делать, Python присваивает каждому значению тип.
Тип данных — это «сорт» значения. Он говорит Python, что лежит в переменной и какие операции с ним допустимы: число можно умножить, строку — соединить с другой строкой, а вот сложить текст с числом уже нельзя.
Тип определяет правила игры. С числом 100 можно посчитать налог. Текст "100" — это просто три символа на экране: его нельзя умножить на ставку, зато можно, например, перевести в верхний регистр. Один и тот же на вид «100» ведёт себя по-разному — всё зависит от типа.
Как Python определяет тип: динамическая типизация
В некоторых языках тип переменной нужно объявлять заранее: «эта коробка только для целых чисел». В Python иначе — тип определяется автоматически по тому, что ты в переменную положил. Это называется динамической типизацией.
Ты просто присваиваешь значение, а Python сам понимает тип:
age = 25 # Python видит целое число -> int
price = 99.99 # видит точку -> float
name = "Алексей" # видит кавычки -> str
is_online = True # видит True/False -> boolУзнать тип переменной можно функцией type() — она пригодится для отладки, когда поведение кода кажется странным:
Спросим у Python тип каждой переменной:
age = 25
price = 99.99
name = "Алексей"
is_online = True
print(type(age))
print(type(price))
print(type(name))
print(type(is_online))<class 'int'> <class 'float'> <class 'str'> <class 'bool'>
Кот-наставник— Тебе не нужно объявлять типы заранее — это удобно. Но есть обратная сторона: Python не предупредит, если ты случайно положил текст туда, где ждал число. — Поэтому
type()— твой друг. Сомневаешься, что внутри переменной — спроси.
Числа: int и float
Для чисел в Python есть два основных типа: целые и дробные. Разница — ровно в одной точке.
int — целые числа
Целые числа — без дробной части, положительные и отрицательные:
age = 25
year = 2026
temperature = -10
big_number = 1_000_000 # подчёркивания для читаемости, Python их игнорируетfloat — дробные числа
Дробные числа записываются через точку, а не запятую:
price = 99.99
pi = 3.14
temperature = 36.6
ratio = -0.5Числовые типы одним взглядом:
| Тип | Что хранит | Примеры |
|---|---|---|
| int | Целые числа | 25, -10, 2026 |
| float | Дробные числа (с точкой) | 99.99, 3.14, -0.5 |
Деление / всегда даёт float, даже если делится нацело. А если нужна именно целая часть — есть целочисленное деление //:
Смотри, как тип результата зависит от операции:
print(10 / 2) # обычное деление
print(10 // 3) # целочисленное деление
print(type(10 / 2))5.0 3 <class 'float'>
Подводный камень float: неточность
Дробные числа хранятся в двоичном виде, и не каждую десятичную дробь можно записать точно. Из-за этого случается классический сюрприз:
Тот самый пример, который удивляет каждого новичка:
print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)0.30000000000000004 False
Это не баг Python — так устроены дробные числа почти во всех языках. Вывод простой: не сравнивай float через == напрямую и округляй результат, когда показываешь его пользователю (например, через round(x, 2) или f-строки).
Строки (str): текст в кавычках
Строка (str) — это текст: имя, сообщение, пароль, да хоть целая книга. Главный признак строки — кавычки, одинарные или двойные, разницы нет.
Строки можно создавать по-разному:
name = "Алексей"
city = 'Москва'
message = "Привет, мир!"
multiline = """Текст
на несколько
строк"""Строки умеют многое: их можно соединять (+), повторять (*), приводить к верхнему или нижнему регистру, искать подстроку. А подставлять переменные внутрь текста удобнее всего через f-строки — об этом отдельная статья: f-строки в Python: форматирование строк просто и читаемо.
Несколько частых операций со строками:
name = "python"
print(name.upper()) # верхний регистр
print(name * 3) # повтор
print(len(name)) # длина строки
print("py" in name) # есть ли подстрокаPYTHON pythonpythonpython 6 True
Булев тип (bool): True и False
Самый простой тип данных — булев (bool). У него всего два значения: True (истина) и False (ложь). Да или нет, включено или выключено. Именно на нём держатся все решения в программах.
Булев тип (
bool) — это тип с двумя возможными значениями:TrueиFalse. Назван в честь математика Джорджа Буля.
True и False пишутся с заглавной буквы:
is_raining = True
is_sunny = False
print(is_raining)
print(type(is_raining))True <class 'bool'>
Чаще всего bool появляется не вручную, а как результат сравнения. Любой оператор сравнения (>, <, ==, !=, >=, <=) возвращает именно True или False:
Сравнения возвращают булев результат:
age = 20
print(age > 18)
print(age == 25)
print(type(age > 18))True False <class 'bool'>
None — особое значение «ничего»
Иногда значения просто нет — и это не ноль и не пустая строка, а буквально «пусто». Для этого в Python есть None — единственное значение типа NoneType.
`None` — специальное значение, которое означает «ничего» или «значение пока не задано». Это не
0и не"", а отдельная сущность.
None удобен как «заготовка» для значения, которое появится позже:
winner = None # победителя пока нет
print(winner)
print(type(winner))None <class 'NoneType'>
None часто возвращают функции, которые ничего не отдают явно (например, print()). Проверять его принято через is: if winner is None:.
Truthy и Falsy: неявные истина и ложь
В проверках if могут участвовать не только True и False. Python умеет оценивать как логическое значение любой тип данных. Правило простое: всё «пустое» и «нулевое» — это ложь, всё остальное — правда.
Функция bool() показывает, как Python оценивает разные значения:
print(bool("")) # пустая строка
print(bool("текст")) # непустая строка
print(bool(0)) # ноль
print(bool(42)) # любое число, кроме нуля
print(bool(None)) # ничегоFalse True False True False
Значения, которые ведут себя как True, называют truthy, а как False — falsy. К falsy относятся: False, 0, 0.0, "", None, а также пустые коллекции ([], {}, ()). Всё остальное — truthy.
Многословно:
name = input("Имя: ")
if name:
print("Привет,", name)Python-стиль:
name = input("Имя: ")
if name != "":
print("Привет,", name)Кот-наставник— Truthy и falsy — это не магия, а удобство.
if items:читается как «если в списке хоть что-то есть» — коротко и по-человечески.— Но не путай «пусто» и «ложь по смыслу». Для этого и существует
None— отдельное «ничего».
Коллекции: list, dict, tuple, set
Пока мы говорили об одиночных значениях. Но чаще данных много: список покупок, профиль пользователя, набор тегов. Для групп значений есть отдельные типы — коллекции.
Четыре коллекции, которые нужно знать:
| Тип | Что это? | Пример |
|---|---|---|
| list | Список, упорядоченный, изменяемый | [1, 2, 3] |
| dict | Словарь «ключ → значение» | {"name": "Алексей", "age": 25} |
| tuple | Кортеж, как список, но неизменяемый | (55.7, 37.6) |
| set | Множество уникальных значений | {1, 2, 3} |
tags = ["python", "обучение", "код"] # list
user = {"name": "Алексей", "age": 25} # dict
point = (55.75, 37.61) # tuple
unique_ids = {1, 2, 3, 3, 2} # set -> {1, 2, 3}
print(type(tags))
print(type(user))
print(unique_ids)<class 'list'>
<class 'dict'>
{1, 2, 3}Как проверить тип: type() и isinstance()
Уже знакомая type() отвечает на вопрос «какой это тип?». Но для проверок в коде чаще используют isinstance() — она отвечает «является ли значение этим типом?» и возвращает bool.
Сравни два подхода:
age = 25
print(type(age)) # узнать тип
print(isinstance(age, int)) # проверить тип -> True/False
print(isinstance(age, str))<class 'int'> True False
Преобразование типов: int(), float(), str(), bool()
Тип значения можно сменить — это называется преобразованием типов. Для каждого базового типа есть функция с тем же именем: int(), float(), str(), bool(). Особенно это важно для данных от пользователя: input() всегда возвращает строку, даже если человек ввёл число.
Превращаем строку в число и обратно:
age_str = "25"
age_num = int(age_str) # str -> int
price = float("99.99") # str -> float
text = str(2026) # int -> str
print(age_num + 1)
print(price * 2)
print("Год: " + text)26 199.98 Год: 2026
При переводе float в int дробная часть отбрасывается, а не округляется — это легко забыть:
int() просто срезает дробную часть:
print(int(99.99)) # не 100!
print(int(3.7)) # не 4!99 3
Mutable и Immutable: почему это важно?
Все типы в Python делятся на две группы: изменяемые (mutable) и неизменяемые (immutable). Это не теоретическая мелочь — непонимание разницы приводит к багам, которые сложно найти.
Immutable (неизменяемые) — значение нельзя изменить после создания:
int,float,str,bool,tuple,None. Mutable (изменяемые) — содержимое можно менять на месте:list,dict,set.
Строка неизменяема — её методы возвращают новую строку, а не меняют старую:
text = "привет"
text.upper() # создаёт новую строку, но никуда её не сохраняет
print(text) # старая строка не изменилась
text = text.upper() # вот так — сохраняем результат
print(text)привет ПРИВЕТ
А список изменяемый — он меняется прямо на месте:
nums = [1, 2, 3]
nums.append(4) # меняем сам список
print(nums)[1, 2, 3, 4]
Тот самый коварный случай:
a = [1, 2, 3]
b = a # b и a — один и тот же список
b.append(4)
print(a) # изменился и a![1, 2, 3, 4]
Аннотации типов (type hints) в Python
Python не заставляет указывать типы, но позволяет — через аннотации (type hints). Это подсказки для тебя, твоей команды и редактора кода: какой тип ожидается в переменной или аргументе функции.
Аннотации пишутся через двоеточие, а для функций — ещё и стрелкой ->:
age: int = 25
name: str = "Алексей"
prices: list[float] = [9.99, 19.99]
def greet(name: str) -> str:
return f"Привет, {name}!"
print(greet("Мир"))Привет, Мир!
Кот-наставник— На старте можно писать и без аннотаций — Python поймёт. Но привыкай к ним пораньше: в больших проектах они экономят часы на чтении чужого (и своего вчерашнего) кода.
Частые ошибки новичков с типами
Шпаргалка: все базовые типы
| Тип | Группа | Пример | Изменяемый? |
|---|---|---|---|
| int | Число | 25, -10 | Нет |
| float | Число | 99.99, 3.14 | Нет |
| str | Текст | "Привет" | Нет |
| bool | Логика | True, False | Нет |
| None | Пустота | None | Нет |
| list | Коллекция | [1, 2, 3] | Да |
| dict | Коллекция | {"a": 1} | Да |
| tuple | Коллекция | (1, 2) | Нет |
| set | Коллекция | {1, 2, 3} | Да |
Главное запомнить
- У каждого значения есть тип
intиfloat— числа,str— текст,bool— истина/ложь,None— пустота, аlist,dict,tuple,set— коллекции. - Тип определяется автоматически
Python сам понимает тип по значению. Проверить можно через
type(), а в условиях — черезisinstance(). - Типы можно преобразовывать
int(),float(),str(),bool()меняют тип. Помни:input()всегда возвращает строку. - Mutable vs Immutable
Списки, словари и множества меняются на месте; числа, строки и кортежи — нет.
b = aдля списка копирует ссылку, а не данные. - Аннотации типов — подсказки, а не правила
age: intпомогает людям и инструментам, но не проверяется при запуске.
Кот-наставник— Вот и вся база типов. Дальше всё держится на ней: условия, циклы, функции — везде важно понимать, с каким типом ты работаешь.
— Лучший способ закрепить — не перечитать, а написать самому. Создай переменные разных типов, прогони через
type(), попробуй преобразования. Я подскажу, если что-то пойдёт не так.
Теперь ты понимаешь типы данных — проверь это на практике!
Прочитать про типы — половина дела. На SkillPy ты сразу пишешь код: создаёшь переменные, преобразуешь типы, ловишь TypeError в безопасной среде — а AI-наставник объясняет, что пошло не так и почему. Не сравнивает с шаблоном, а понимает твоё решение.