В чем разница между блендингом и случайным лесом?

В чем разница между списком и кортежем в Python?

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

Быстрое сравнение

Список (list):  Изменяемый (mutable)    [1, 2, 3]
Кортеж (tuple): Неизменяемый (immutable) (1, 2, 3)

Основные отличия

# Создание
my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

# Изменение
my_list[0] = 100        # ✓ Работает
my_tuple[0] = 100       # ❌ TypeError: 'tuple' object does not support item assignment

my_list.append(4)       # ✓ Работает
my_tuple.append(4)      # ❌ AttributeError: 'tuple' object has no attribute 'append'

Почему это важно

Список (list):

• Можно добавлять, удалять, изменять элементы
• Медленнее (больше памяти и операций)
• Не может быть ключом словаря
• Не может быть элементом set

Кортеж (tuple):

• Зафиксирован после создания
• Быстрее (оптимизирован Python)
• Может быть ключом словаря (hashable)
• Может быть элементом set

Операции со списком

numbers = [1, 2, 3]

# Добавление
numbers.append(4)           # [1, 2, 3, 4]
numbers.insert(0, 0)        # [0, 1, 2, 3, 4]
numbers.extend([5, 6])      # [0, 1, 2, 3, 4, 5, 6]

# Удаление
numbers.remove(3)           # Удаляет значение
numbers.pop(0)              # Удаляет по индексу, возвращает

# Изменение
numbers[0] = 999            # [999, 1, 2, 3, 4, 5, 6]

Операции с кортежем

numbers = (1, 2, 3)

# Большинство операций невозможны
numbers.append(4)       # ❌ Ошибка
numbers[0] = 999        # ❌ Ошибка

# Но срезы работают
print(numbers[0:2])     # (1, 2)

# Конкатенация (создает новый кортеж)
new_tuple = numbers + (4, 5)  # (1, 2, 3, 4, 5)

Использование в словарях

# Кортеж как ключ (OK)
d = {
    (1, 2): 'point A',
    (3, 4): 'point B'
}
print(d[(1, 2)])  # 'point A'

# Список как ключ (ERROR)
d = {
    [1, 2]: 'point A'  # ❌ TypeError: unhashable type: 'list'
}

Использование в set

# Кортеж в set (OK)
s = {(1, 2), (3, 4), (1, 2)}
print(s)  # {(1, 2), (3, 4)}

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

Performance

import timeit

# Создание
t_list = timeit.timeit('[1, 2, 3, 4, 5]', number=1000000)
t_tuple = timeit.timeit('(1, 2, 3, 4, 5)', number=1000000)

print(f"list:  {t_list:.3f}s")
print(f"tuple: {t_tuple:.3f}s")
# tuple обычно в 2-3x быстрее

# Доступ к элементу
t_list = timeit.timeit('x = my_list[2]', setup='my_list=[1,2,3,4,5]', number=1000000)
t_tuple = timeit.timeit('x = my_tuple[2]', setup='my_tuple=(1,2,3,4,5)', number=1000000)

# Примерно одинаково

Когда использовать что

Список (list):

• Когда данные могут меняться
• Коллекция однородных элементов
• Нужны операции добавления/удаления

todos = ['купить молоко', 'позвонить другу']
todos.append('помыть машину')

prices = [10.5, 20.0, 15.75]
prices[0] = 11.0

Кортеж (tuple):

• Когда данные фиксированы
• Координаты, точки (x, y, z)
• Ключи словаря, элементы set
• Возвращаемые значения из функции

# Координаты (не должны меняться)
point = (10, 20)
coordinates = [(1, 2), (3, 4), (5, 6)]

# Ключ словаря
cache = {(user_id, date): result}

# Возврат из функции (unpacking)
def get_user():
    return ('Alice', 30, 'NYC')

name, age, city = get_user()

# Set уникальных точек
unique_points = {(1, 2), (3, 4), (1, 2)}

Распаковка (unpacking)

# Список
[a, b, c] = [1, 2, 3]
a, b, c = [1, 2, 3]  # Не нужны скобки

# Кортеж
(a, b, c) = (1, 2, 3)
a, b, c = (1, 2, 3)  # Не нужны скобки

# В функциях
def func():
    return (10, 20, 30)

x, y, z = func()  # Кортеж автоматически распаковывается

# Обмен переменных
a, b = b, a  # Работает через кортеж!

Изменяемые элементы в кортеже

# Кортеж с изменяемым элементом (список)
t = (1, 2, [3, 4, 5])

# Сам кортеж неизменяемый
t[0] = 100  # ❌ Ошибка

# Но список внутри кортежа изменяемый!
t[2].append(6)  # ✓ Работает
print(t)  # (1, 2, [3, 4, 5, 6])

# Это запутанно! Избегай этого.

named tuple (специальный кортеж)

from collections import namedtuple

# Кортеж с именованными полями
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)

print(p.x)  # 10
print(p.y)  # 20
print(p[0]) # 10 (можно как обычный кортеж)

# Преимущества: читаемость + неизменяемость

Чек-лист

• ✓ list — изменяемый, используй когда данные меняются
• ✓ tuple — неизменяемый, используй для фиксированных данных
• ✓ tuple — hashable, может быть ключом dict и элементом set
• ✓ tuple — быстрее, используй для production когда speed важна
• ✓ namedtuple — когда нужна семантика без класса
• ✓ распаковка — обе структуры поддерживают, очень полезно

Вывод

Список:

data = [1, 2, 3]
data[0] = 999       # Можно менять
data.append(4)      # Можно добавлять

Кортеж:

data = (1, 2, 3)
data[0] = 999       # Нельзя менять
data = data + (4,)  # Только конкатенация (новый объект)

Выбор между ними зависит от того, нужны ли изменения после создания.