Какие встроенные типы данных есть в Python?

Ответ

В Python типы данных делятся на изменяемые (mutable) и неизменяемые (immutable), что критично для понимания поведения объектов.

Неизменяемые (Immutable):

int, float, complex — числовые типы.
str — строки.
tuple — кортежи.
bytes — байтовые строки.
frozenset — неизменяемое множество.
bool — логический тип (True, False).

Изменяемые (Mutable):

list — списки.
dict — словари.
set — множества.
bytearray — изменяемая байтовая последовательность.

Пример, демонстрирующий разницу:

# Неизменяемый тип (int)
a = 5
b = a  # b ссылается на тот же объект
b = 10 # Создается новый объект 10, a не меняется
print(a) # 5

# Изменяемый тип (list)
list1 = [1, 2, 3]
list2 = list1 # list2 ссылается на тот же объект в памяти
list2.append(4) # Изменяется общий объект
print(list1) # [1, 2, 3, 4] - list1 тоже изменился!

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

x = 42
type(x)          # <class 'int'>
isinstance(x, int) # True
float(x)         # 42.0 (преобразование)
str(x)           # '42'

Ключевое на практике: Понимание мутабельности помогает избежать ошибок, особенно при передаче аргументов в функции. Неизменяемые объекты передаются по значению (фактически, копируется ссылка, но объект нельзя изменить), а изменяемые — по ссылке.

Ответ 18+ 🔞

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

Вот смотри, какие типы неизменяемые, их, блядь, не переделаешь, как ни старайся:

int, float, complex — циферки всякие.
str — строки, текст этот.
tuple — кортежи, типа застеклённый балкон, ничего туда не пристроишь.
bytes — байты, тоже замороженные.
frozenset — множество, но в анабиозе, frozenset же, логично.
bool — True и False, тут уж либо да, либо нет, середины не бывает.

А вот изменяемые — это полный раздоль, делай с ними что хочешь, как в коммуналке:

list — списки, туда-сюда пихай.
dict — словари, вообще бардак можно устроить.
set — множества обычные.
bytearray — байты, но такие, которые можно подпилить.

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

# Неизменяемый тип (int), проще говоря, циферка
a = 5
b = a  # b теперь просто смотрит туда же, куда и a
b = 10 # А тут — бац! — создаётся НОВАЯ циферка 10. 'a' спокойно себе пялится на свою пятёрку.
print(a) # 5. Всё на месте, нихуя не поменялось.

# Изменяемый тип (list), то есть список
list1 = [1, 2, 3]
list2 = list1 # list2 — это не копия, это просто вторая вывеска на ту же хату!
list2.append(4) # Заходим в эту общую хату через list2 и ставим там четвёртый стул.
print(list1) # [1, 2, 3, 4] - Опа-на! А list1-то тоже теперь в хате с четырьмя стульями! Вот это пиздец, да? Они же ссылались на один и тот же объект!

Ну и, ясное дело, иногда надо проверить, с кем имеешь дело. Не тыкать же пальцем в небо:

x = 42
type(x)          # <class 'int'> — спрашиваешь: "Ты кто?"
isinstance(x, int) # True — подтверждает: "Да, я integer, ёпта!"
float(x)         # 42.0 — превращаешь в дробь, ну, насильно так.
str(x)           # '42' — делаешь из числа строку, чтоб болтать могла.

А главная мысль, блядь, ради которой весь этот сыр-бор: это понимание нужно, чтобы не облажаться, особенно когда кидаешь данные в функции. С неизменяемыми объектами — расслабься, их не испортишь, как бы ты там ни старался. А вот с изменяемыми — подозрение ебать чувствую — будь начеку! Передал список в функцию, она там что-то внутри поменяла, а у тебя исходный список уже по ушам получен. Это как дать другу ключи от своей тачки, а он вернёт её с новым вмятым крылом. Вот чтобы такого не было, это и надо в башке держать.