Приведи пример использования кортежа

Примеры использования кортежей в Python

Кортежи (tuples) — это неизменяемые последовательности элементов. Хотя они похожи на списки, они имеют уникальные применения и преимущества.

Что такое кортеж

# Создание кортежа
point = (10, 20)  # Кортеж из двух элементов
person = ("Alice", 30, "Engineer")  # Кортеж из трёх элементов
empty = ()  # Пустой кортеж
single = (42,)  # Кортеж из одного элемента (запятая важна!)

# Кортежи неизменяемы
point[0] = 15  # TypeError: 'tuple' object does not support item assignment

# Но можно распаковать
x, y = point
print(x, y)  # 10 20

Пример 1: Множественное возвращение из функции

# Функция возвращает несколько значений через кортеж
def get_user_info(user_id):
    """Возвращает информацию о пользователе"""
    # Обычно данные приходят из БД
    return ("Alice", 30, "alice@example.com", "Engineer")

# Использование с распаковкой
name, age, email, profession = get_user_info(1)
print(f"{name}, {age} лет, {email}")

# Или можно получить как кортеж
user_data = get_user_info(1)
print(user_data[0])  # Alice

Пример 2: Неизменяемость — использование как ключ в словаре

# Кортежи хешируемы и могут быть ключами
coordinates_to_city = {
    (55.7558, 37.6173): "Москва",
    (59.9311, 30.3609): "Санкт-Петербург",
    (54.7034, 20.5109): "Калининград"
}

# Поиск города по координатам
latitude, longitude = 55.7558, 37.6173
city = coordinates_to_city[(latitude, longitude)]
print(city)  # Москва

# Со списками этот подход не работает
bad_dict = {[1, 2]: "value"}  # TypeError: unhashable type: 'list'

Пример 3: Параметры функции как кортеж

# *args собирает аргументы в кортеж
def print_values(*args):
    """
    args — это кортеж всех переданных аргументов
    """
    print(f"Тип: {type(args)}")  # <class 'tuple'>
    for i, arg in enumerate(args):
        print(f"Аргумент {i}: {arg}")

print_values(10, 20, 30, "hello")
# Тип: <class 'tuple'>
# Аргумент 0: 10
# Аргумент 1: 20
# Аргумент 2: 30
# Аргумент 3: hello

# Распаковка при вызове
values = (1, 2, 3)
print_values(*values)  # Аргумент 0: 1, Аргумент 1: 2, Аргумент 2: 3

Пример 4: Обмен значений без дополнительной переменной

# Классический способ без кортежей
a = 5
b = 10
temp = a
a = b
b = temp
print(a, b)  # 10 5

# С кортежами (питонический способ)
x = 5
y = 10
x, y = y, x  # Очень элегантно!
print(x, y)  # 10 5

# Это работает потому что:
# 1. Правая часть (y, x) создаёт кортеж (10, 5)
# 2. Левая часть x, y распаковывает его
# 3. Ни одна переменная не теряется

Пример 5: Именованные кортежи (namedtuple)

from collections import namedtuple

# Определяем структуру Point
Point = namedtuple('Point', ['x', 'y'])

# Создание экземпляра
p = Point(10, 20)

# Доступ по индексу (как в обычном кортеже)
print(p[0])  # 10

# Доступ по имени (как в объекте)
print(p.x, p.y)  # 10 20

# Распаковка
x, y = p
print(x, y)  # 10 20

# Namedtuple неизменяемый
# p.x = 30  # AttributeError: can't set attribute

# Но можно создать новый с изменениями
p_new = p._replace(x=30)
print(p_new)  # Point(x=30, y=20)

Пример 6: Сортировка по кортежам

# Список студентов (имя, оценка, возраст)
students = [
    ("Alice", 95, 20),
    ("Bob", 87, 19),
    ("Carol", 95, 21),
    ("Dave", 90, 20)
]

# Python сравнивает кортежи элемент за элементом
# Сначала по оценке (второй элемент), потом по возрасту
sorted_students = sorted(students, key=lambda x: (x[1], x[2]))
print(sorted_students)
# [('Bob', 87, 19),
#  ('Dave', 90, 20),
#  ('Alice', 95, 20),
#  ('Carol', 95, 21)]

# Или наоборот — по оценке убывая, потом по возрасту
sorted_desc = sorted(students, key=lambda x: (-x[1], x[2]))
print(sorted_desc)

Пример 7: Использование в базах данных

import sqlite3

conn = sqlite3.connect(':memory:')
cur = conn.cursor()

# Создаём таблицу
cur.execute('''CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    email TEXT
)''')

# Кортежи часто используются для передачи данных в БД
users_data = [
    (1, "Alice", "alice@example.com"),
    (2, "Bob", "bob@example.com"),
    (3, "Carol", "carol@example.com")
]

# Вставляем кортежи
for user in users_data:
    cur.execute("INSERT INTO users VALUES (?, ?, ?)", user)

conn.commit()

# Результаты также возвращаются как кортежи
cur.execute("SELECT * FROM users WHERE id = 1")
result = cur.fetchone()  # (1, 'Alice', 'alice@example.com') — кортеж!
print(result[0], result[1])  # 1 Alice

conn.close()

Пример 8: Блокировка от случайного изменения

# Кортеж как константа — не может быть изменён
RGB_COLORS = {
    "red": (255, 0, 0),
    "green": (0, 255, 0),
    "blue": (0, 0, 255)
}

# Гарантируем, что цвета не изменятся
red_color = RGB_COLORS["red"]
# red_color[0] = 128  # TypeError — защита от ошибок!

# Это лучше, чем
Bad_colors = {
    "red": [255, 0, 0],  # Список легко случайно изменить
    "green": [0, 255, 0]
}
bad_red = Bad_colors["red"]
bad_red[0] = 128  # Молча изменяет цвет! Баг!

Пример 9: Распаковка с игнорированием значений

# Когда нам нужны только некоторые элементы
data = ("Alice", 30, "Engineer", "New York")

# Способ 1: с подчёркиванием (исправить)
name, age, *_ = data
print(name, age)  # Alice 30

# Способ 2: с подчёркиванием для одного элемента
name, _, profession, _ = data
print(name, profession)  # Alice Engineer

# Способ 3: нарезка
name, age = data[:2]
print(name, age)  # Alice 30

Пример 10: Кортежи в алгоритмах

# BFS (поиск в ширину) часто использует кортежи для состояния
from collections import deque

def bfs(graph, start):
    """
    BFS — очередь содержит кортежи (узел, расстояние)
    """
    queue = deque([(start, 0)])  # Кортеж: (узел, расстояние)
    visited = {start}
    
    while queue:
        node, distance = queue.popleft()  # Распаковка кортежа
        print(f"Узел {node} на расстоянии {distance}")
        
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, distance + 1))  # Добавляем кортеж

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D'],
    'C': ['A'],
    'D': ['B']
}

bfs(graph, 'A')

Пример 11: Zip — объединение нескольких последовательностей

# zip() возвращает кортежи
names = ["Alice", "Bob", "Carol"]
ages = [30, 25, 28]
professions = ["Engineer", "Designer", "Manager"]

# Объединяем в кортежи
for person in zip(names, ages, professions):
    print(person)  # ('Alice', 30, 'Engineer'), ('Bob', 25, 'Designer'), ...

# Со распаковкой
for name, age, profession in zip(names, ages, professions):
    print(f"{name}: {age} лет, {profession}")

# Обратная распаковка
names, ages, professions = zip(*[
    ("Alice", 30, "Engineer"),
    ("Bob", 25, "Designer"),
    ("Carol", 28, "Manager")
])
print(names)  # ('Alice', 'Bob', 'Carol')

Ключевые преимущества кортежей

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

• Возвращение нескольких значений из функции
• Ключи словаря когда нужно несколько полей
• Защита от случайного изменения (координаты, RGB цвета)
• *args функции (автоматически кортежи)
• Парные/групповые данные (координаты, дата/время)
• Производительность когда нужна скорость
• Многопоточность когда нужна потокобезопасность