Шпаргалка по типам данных в Python (быстрый справочник)

Привет! Ты уже изучил много типов данных в Python. Но иногда бывает сложно запомнить всё сразу. Эта шпаргалка — твой быстрый справочник.

Здесь собраны все основные типы данных с примерами, методами и подсказками.

Сохрани эту статью в закладки. Она пригодится, когда нужно быстро что-то вспомнить.

Содержание

Что нужно знать перед началом
Основная часть
Числа (int, float)
Строки (str)
Логический тип (bool)
Списки (list)
Кортежи (tuple)
Словари (dict)
Множества (set)
None (NoneType)
Таблица типов данных (быстрая)
Преобразование типов
Частые ошибки и как их избежать
Ошибка 1: Путаница между списком и кортежем
Ошибка 2: Использование list вместо tuple для ключей словаря
Ошибка 3: Изменение словаря во время итерации
Шпаргалка (быстрый справочник)
Заключение / Выводы
КВИЗ
Что дальше?

Что нужно знать перед началом

Эта шпаргалка для тех, кто уже знаком с основами Python.

Совет: Используй эту статью как справочник. Не нужно запоминать всё наизусть — просто знай, где искать.

Основная часть

Числа (int, float)

int (целые числа)

x = 10
y = -5
z = 0

Операция	Пример	Результат
Сложение	`10 + 3`	`13`
Вычитание	`10 - 3`	`7`
Умножение	`10 * 3`	`30`
Деление	`10 / 3`	`3.333...`
Целочисленное деление	`10 // 3`	`3`
Остаток	`10 % 3`	`1`
Степень	`10 ** 3`	`1000`

float (дробные числа)

x = 3.14
y = -0.5
z = 2.0

Операция	Пример	Результат
Сложение	`3.14 + 2.5`	`5.64`
Вычитание	`3.14 - 2.5`	`0.64`
Умножение	`3.14 * 2`	`6.28`
Деление	`3.14 / 2`	`1.57`

Важно: float хранится с погрешностью. Для сравнения используй abs(a - b) < epsilon.

Строки (str)

s1 = "Hello"
s2 = 'World'
s3 = """Многострочная
строка"""

Метод	Что делает	Пример
`len(s)`	Длина строки	`len("Hello")` → `5`
`s.upper()`	В верхний регистр	`"hello".upper()` → `"HELLO"`
`s.lower()`	В нижний регистр	`"HELLO".lower()` → `"hello"`
`s.strip()`	Удалить пробелы по краям	`" hello ".strip()` → `"hello"`
`s.split(",")`	Разбить по разделителю	`"a,b,c".split(",")` → `["a","b","c"]`
`",".join(list)`	Склеить список	`",".join(["a","b"])` → `"a,b"`
`s.replace("a","b")`	Заменить подстроку	`"Hello".replace("l","x")` → `"Hexxo"`
`s.find("sub")`	Найти подстроку	`"Hello".find("e")` → `1`
`s[::-1]`	Развернуть строку	`"Hello"[::-1]` → `"olleH"`

Совет: Для объединения строк используй f-строки: f"Hello {name}".

Логический тип (bool)

is_active = True
is_deleted = False

Оператор	Что делает	Пример
`and`	И (оба True)	`True and True` → `True`
`or`	ИЛИ (хотя бы один True)	`True or False` → `True`
`not`	НЕ (отрицание)	`not True` → `False`

Важно: bool — подкласс int. True == 1, False == 0.

Списки (list)

my_list = [1, 2, 3, "hello", True]

Метод	Что делает	Пример
`append(x)`	Добавить в конец	`[1,2].append(3)` → `[1,2,3]`
`insert(i, x)`	Вставить по индексу	`[1,3].insert(1,2)` → `[1,2,3]`
`remove(x)`	Удалить первое значение	`[1,2,3].remove(2)` → `[1,3]`
`pop(i)`	Удалить по индексу	`[1,2,3].pop(1)` → `[1,3]`
`sort()`	Сортировать	`[3,1,2].sort()` → `[1,2,3]`
`reverse()`	Перевернуть	`[1,2,3].reverse()` → `[3,2,1]`
`len(list)`	Длина списка	`len([1,2,3])` → `3`

Совет: Списки изменяемы (mutable). Их можно менять.

Кортежи (tuple)

my_tuple = (1, 2, 3, "hello")

Метод	Что делает	Пример
`len(tuple)`	Длина кортежа	`len((1,2,3))` → `3`
`tuple.index(x)`	Индекс элемента	`(1,2,3).index(2)` → `1`
`tuple.count(x)`	Количество вхождений	`(1,2,2).count(2)` → `2`

Важно: Кортежи неизменяемы (immutable). Их нельзя менять после создания.

Совет: Используй кортежи для данных, которые не должны меняться.

Словари (dict)

my_dict = {"name": "Анна", "age": 25, "city": "Москва"}

Метод	Что делает	Пример
`dict[key]`	Получить значение	`d["name"]` → `"Анна"`
`dict[key] = value`	Добавить/изменить	`d["age"] = 26`
`del dict[key]`	Удалить ключ	`del d["city"]`
`dict.keys()`	Все ключи	`d.keys()` → `["name","age"]`
`dict.values()`	Все значения	`d.values()` → `["Анна",25]`
`dict.items()`	Пары ключ-значение	`d.items()` → `[("name","Анна"),...]`
`dict.get(key, default)`	Получить с запасным значением	`d.get("age", 0)` → `25`

Совет: Словари изменяемы. Хранят данные в формате «ключ → значение».

Множества (set)

my_set = {1, 2, 3, 4}

Метод	Что делает	Пример
`add(x)`	Добавить элемент	`{1,2}.add(3)` → `{1,2,3}`
`remove(x)`	Удалить элемент	`{1,2,3}.remove(2)` → `{1,3}`
`union(set)`	Объединение	`{1,2}.union({2,3})` → `{1,2,3}`
`intersection(set)`	Пересечение	`{1,2}.intersection({2,3})` → `{2}`
`difference(set)`	Разность	`{1,2}.difference({2,3})` → `{1}`

Важно: Множества хранят только уникальные элементы. Неупорядоченны.

None (NoneType)

x = None

Проверка	Пример
Проверить на None	`if x is None:`
Проверить не None	`if x is not None:`

Важно: None — это не 0, не пустая строка, не False. Это «ничего».

Таблица типов данных (быстрая)

Тип	Пример	Изменяемый?
`int`	`10`, `-5`	Нет
`float`	`3.14`, `-0.5`	Нет
`str`	`"hello"`, `'world'`	Нет
`bool`	`True`, `False`	Нет
`list`	`[1, 2, 3]`	Да
`tuple`	`(1, 2, 3)`	Нет
`dict`	`{"a": 1}`	Да
`set`	`{1, 2, 3}`	Да
`NoneType`	`None`	Нет

Преобразование типов

Что нужно	Как пишется
В целое число	`int(x)`
В дробное число	`float(x)`
В строку	`str(x)`
В логический тип	`bool(x)`
В список	`list(x)`
В кортеж	`tuple(x)`
В множество	`set(x)`

Частые ошибки и как их избежать

Ошибка 1: Путаница между списком и кортежем

Список: [1, 2, 3] — изменяемый
Кортеж: (1, 2, 3) — неизменяемый

Ошибка 2: Использование `list` вместо `tuple` для ключей словаря

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

d = {[1, 2]: "value"}   # Ошибка!
d = {(1, 2): "value"}   # OK

Ошибка 3: Изменение словаря во время итерации

for key in d:
    del d[key]   # Ошибка!

Шпаргалка (быстрый справочник)

Что нужно	Как пишется
Целое число	`x = 10`
Дробное число	`x = 3.14`
Строка	`s = "Hello"`
Логический тип	`b = True`
Список	`l = [1, 2, 3]`
Кортеж	`t = (1, 2, 3)`
Словарь	`d = {"a": 1}`
Множество	`s = {1, 2, 3}`
None	`x = None`