Является ли кортеж изменяемым объектов?

Являются ли кортежи изменяемыми объектами?

Нет, кортежи (tuples) — это неизменяемые (immutable) объекты в Python. После создания кортежа его нельзя изменить: нельзя добавлять элементы, удалять их или изменять существующие.

Неизменяемость кортежей

t = (1, 2, 3)

# ❌ Нельзя изменить элемент
t[0] = 10  # TypeError: 'tuple' object does not support item assignment

# ❌ Нельзя добавить элемент
t.append(4)  # AttributeError: 'tuple' object has no attribute 'append'

# ❌ Нельзя удалить элемент
del t[0]  # TypeError: 'tuple' object doesn't support item deletion

# ✅ Можно создать новый кортеж с новыми элементами
t = t + (4,)  # (1, 2, 3, 4) — новый кортеж

Сравнение с mutable типами

# Список (MUTABLE — изменяемый)
my_list = [1, 2, 3]
my_list[0] = 10  # OK
my_list.append(4)  # OK
# my_list теперь [10, 2, 3, 4]

# Кортеж (IMMUTABLE — неизменяемый)
my_tuple = (1, 2, 3)
my_tuple[0] = 10  # TypeError
my_tuple.append(4)  # AttributeError
# my_tuple остается (1, 2, 3)

Важная деталь: вложенные изменяемые объекты

Хотя сам кортеж неизменяем, если он содержит изменяемые объекты (список, словарь), эти объекты можно менять!

# ✅ Кортеж содержит список
t = ([1, 2, 3], 'hello')

# ❌ Нельзя заменить список
t[0] = [4, 5, 6]  # TypeError: 'tuple' object does not support item assignment

# ✅ ЛО можно изменить СОДЕРЖИМОЕ списка
t[0].append(4)  # OK
print(t)  # ([1, 2, 3, 4], 'hello')

# Кортеж как структура остался неизменным,
# но содержимое его элемента изменилось

# Кортеж со словарем
t = ({'name': 'Alice'}, 30)

# ❌ Нельзя изменить кортеж
t[0] = {'name': 'Bob'}  # TypeError

# ✅ Но можно изменить словарь
t[0]['name'] = 'Bob'  # OK
print(t)  # ({'name': 'Bob'}, 30)

Почему кортежи неизменяемы?

1. Производительность

# Неизменяемые объекты можно интернировать (переиспользовать)
t1 = (1, 2, 3)
t2 = (1, 2, 3)
print(t1 is t2)  # True — один и тот же объект!

# Список такого не может
l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(l1 is l2)  # False — разные объекты

2. Использование в качестве ключей в словаре

# ✅ Кортеж можно использовать как ключ
d = {
    (1, 2): 'coordinates',
    ('a', 'b'): 'letters'
}
print(d[(1, 2)])  # 'coordinates'

# ❌ Список нельзя
d = {
    [1, 2]: 'coordinates'  # TypeError: unhashable type: 'list'
}

3. Использование в множествах

# ✅ Кортежи в set
my_set = {(1, 2), (3, 4), (1, 2)}
print(len(my_set))  # 2 — дубликат удален

# ❌ Списки в set
my_set = {[1, 2], [3, 4]}  # TypeError: unhashable type: 'list'

4. Безопасность данных

def process_data(immutable_tuple):
    # Функция не сможет случайно изменить аргумент
    # immutable_tuple[0] = 999  # TypeError
    return sum(immutable_tuple)

data = (1, 2, 3)
result = process_data(data)
print(data)  # (1, 2, 3) — не изменилась

Методы кортежа

Кортежи имеют только два метода (по сравнению с 25+ методами списка):

t = (1, 2, 2, 3, 2)

# count() — подсчитать вхождения
print(t.count(2))  # 3

# index() — найти индекс элемента
print(t.index(3))  # 3
print(t.index(2))  # 1 — первое вхождение

# Вот и все методы!

Когда использовать кортежи

1. Возврат нескольких значений

# ✅ Кортеж — хороший выбор
def get_user_info(user_id):
    return ('Alice', 30, 'alice@example.com')

name, age, email = get_user_info(1)

# Или лучше использовать NamedTuple
from typing import NamedTuple

class UserInfo(NamedTuple):
    name: str
    age: int
    email: str

def get_user_info(user_id) -> UserInfo:
    return UserInfo('Alice', 30, 'alice@example.com')

2. Неизменяемые данные

# ✅ Координаты как кортеж
point = (10, 20)

# ❌ Координаты как список (может случайно измениться)
point = [10, 20]

3. Ключи в словарях

# ✅ Кортежи как ключи
cache = {
    (1, 2): 'result1',
    (3, 4): 'result2'
}

# ❌ Списки нельзя
cache = {[1, 2]: 'result1'}  # TypeError

4. Элементы множества

# ✅ Кортежи в set
coordinates = {(0, 0), (1, 1), (0, 0)}
print(len(coordinates))  # 2

# ❌ Списки нельзя
coordinates = {[0, 0], [1, 1]}  # TypeError

5. Аргументы функций

# *args становится кортежем
def print_args(*args):
    print(type(args))  # <class 'tuple'>
    for arg in args:
        print(arg)

print_args(1, 2, 3)
# (1, 2, 3)

Сравнение: список vs кортеж

Может ли я "выглядеть" как список?

# Кортеж поддерживает операции списка (но не изменяющие)

t = (1, 2, 3)

# ✅ Индексирование
print(t[0])  # 1

# ✅ Слайсинг
print(t[1:])  # (2, 3)

# ✅ Итерация
for item in t:
    print(item)

# ✅ Проверка наличия
print(2 in t)  # True

# ✅ Конкатенация (создает новый кортеж)
t2 = t + (4,)
print(t2)  # (1, 2, 3, 4)
print(t)   # (1, 2, 3) — исходный не изменился

# ✅ Повтор (создает новый кортеж)
t3 = t * 2
print(t3)  # (1, 2, 3, 1, 2, 3)

# ❌ Но изменяющие операции работают
t[0] = 10  # TypeError
t.append(4)  # AttributeError

Распаковка кортежей

# Распаковка на переменные
t = ('Alice', 30, 'alice@example.com')
name, age, email = t
print(name)  # Alice

# С пропуском значений
t = (1, 2, 3, 4, 5)
first, *middle, last = t
print(first)   # 1
print(middle)  # [2, 3, 4] — список!
print(last)    # 5

# Вложенная распаковка
t = ('Alice', (30, 'engineer'))
name, (age, job) = t
print(name)  # Alice
print(age)   # 30
print(job)   # engineer

Практический пример

from typing import NamedTuple

# Лучше, чем простой кортеж
class Point(NamedTuple):
    x: int
    y: int

# Неизменяемая координата
p1 = Point(10, 20)
p2 = Point(10, 20)

print(p1 == p2)     # True
print(p1 is p2)     # False (разные объекты)

# Использование как ключ
locations = {
    p1: 'start',
    Point(30, 40): 'end'
}

print(locations[p1])  # 'start'

# Нельзя изменить
p1.x = 15  # AttributeError: can't set attribute

Итоговое резюме

Кортежи — это НЕИЗМЕНЯЕМЫЕ последовательности.

Основные характеристики:

• После создания не могут меняться
• Можно использовать как ключи в словарях
• Можно использовать в множествах (set)
• Быстрее списков
• Безопаснее для данных, которые не должны меняться

Используй кортежи когда:

• Данные не должны меняться
• Нужно использовать как ключ
• Нужна гарантия безопасности
• Нужна небольшая производительность

Используй списки когда:

• Нужно часто добавлять/удалять элементы
• Данные изменяются в процессе обработки
• Нужны методы вроде sort(), reverse()