Списки и кортежи в Python: различия, особенности, применение

# Создание списка
colors = ["красный", "зеленый", "синий"]
# Создание кортежа
point = (10, 20, 30)

# Работа со списком
fruits = ["яблоко", "банан", "груша"]
fruits[0] = "апельсин"  # Легальная операция
print(fruits)  # ['апельсин', 'банан', 'груша']
 
# Работа с кортежем
coords = (10, 20, 30)
coords[0] = 15  # Вызовет TypeError

import sys
 
# Пустой список занимает больше памяти чем пустой кортеж
print(sys.getsizeof([]))  # Обычно выводит 56 байт
print(sys.getsizeof(()))  # Обычно выводит 40 байт
 
# Добавление элементов в список
my_list = []
for i in range(10):
    print(f"Размер: {sys.getsizeof(my_list)}, Количество: {len(my_list)}")
    my_list.append(i)

import sys
 
# Создаём список и кортеж с одинаковыми элементами
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
 
# Сравниваем размер в памяти
list_size = sys.getsizeof(my_list)
tuple_size = sys.getsizeof(my_tuple)
 
print(f"Размер списка: {list_size} байт")
print(f"Размер кортежа: {tuple_size} байт")
print(f"Разница: {list_size - tuple_size} байт")

import timeit
 
# Измеряем время доступа
list_access = timeit.timeit(stmt="a[2]", setup="a = [1, 2, 3, 4, 5]", number=10000000)
tuple_access = timeit.timeit(stmt="a[2]", setup="a = (1, 2, 3, 4, 5)", number=10000000)
 
print(f"Доступ к элементу списка: {list_access:.6f} сек")
print(f"Доступ к элементу кортежа: {tuple_access:.6f} сек")

# Кортеж как ключ словаря - работает
coordinates = {}
coordinates[(0, 0)] = 'Начало координат'
coordinates[(10, 20)] = 'Какая-то точка'
print(coordinates[(0, 0)])  # 'Начало координат'
 
# Список как ключ словаря - вызывает ошибку
dimensions = {}
dimensions[[100, 200]] = 'Прямоугольник'  # TypeError: unhashable type: 'list'

# Простой кортеж с хешируемыми типами
simple_tuple = (1, "строка", True)
print(hash(simple_tuple))  # работает
 
# Кортеж, содержащий список (не хешируемый тип)
complex_tuple = (1, [2, 3], 4)
try:
    hash(complex_tuple)  # TypeError: unhashable type: 'list'
except TypeError as e:
    print(f"Ошибка: {e}")

# Кортеж, содержащий список
data = ([1, 2, 3], "строка", 42)
 
# Невозможно изменить сам кортеж
[H2]data[0] = [4, 5, 6]  # Это вызовет ошибку[/H2]
 
# Но можно изменить содержимое списка внутри кортежа
data[0].append(4)
print(data)  # ([1, 2, 3, 4], 'строка', 42)

# Список задач, который постоянно обновляется
tasks = ["Написать код", "Пройти код-ревью", "Исправить баги"]
tasks.append("Написать тесты")
tasks.remove("Исправить баги")  # Убираем, когда задача выполнена

# Список имен файлов для обработки
files_to_process = ["data1.txt", "data2.txt", "config.json"]
 
# Список чисел для математических операций
numbers = [1, 2, 3, 4, 5]

# Сбор отфильтрованных значений
filtered_values = []
for value in input_data:
    if passes_filter(value):
        filtered_values.append(value)

# Сортировка данных
scores = [88, 92, 65, 73, 99, 82]
scores.sort()  # Сортирует на месте
print(scores)  # [65, 73, 82, 88, 92, 99]
 
# Или обратная сортировка
scores.sort(reverse=True)
print(scores)  # [99, 92, 88, 82, 73, 65]
 
# Произвольное переупорядочивание
import random
random.shuffle(scores)

# Использование списка как стека (LIFO)
stack = []
stack.append('A')  # Добавить элемент на вершину
stack.append('B')
stack.append('C')
print(stack.pop())  # 'C' (последний элемент)
print(stack.pop())  # 'B'

# Информация о человеке (имя, возраст, профессия)
person = ("Александр Пушкин", 37, "Поэт")
 
# Координаты точки в 3D пространстве
point_3d = (2.5, -1.8, 0.5)

# Словарь, где ключами служат пары координат
grid = {}
grid[(0, 0)] = 'Центр'
grid[(1, 0)] = 'Восток'
grid[(0, 1)] = 'Север'

def get_user_stats(user_id):
    # ... какая-то логика получения данных ...
    return (42, "Активный", "2023-03-15")  # кол-во посещений, статус, последний вход
 
visits, status, last_login = get_user_stats(123)

# Константы, которые не должны меняться
DAYS_OF_WEEK = ("Пн", "Вт", "Ср", "Чт", "Пт", "Сб", "Вс")
RGB_BLACK = (0, 0, 0)
 
# Функция, принимающая список баз данных
def connect_to_databases(database_configs):
    # Преобразование списка в кортеж для защиты от изменений внутри функции
    database_configs = tuple(database_configs)
    for config in database_configs:
        # ... логика подключения ...

# Версии программы (мажорная, минорная, патч)
version = (2, 0, 1)
 
# Спецификация цветовой модели
cmyk = (0, 100, 100, 0)  # Красный цвет в CMYK

# Распаковка кортежа в переменные
point = (3, 4)
x, y = point
print(f"x = {x}, y = {y}")  # x = 3, y = 4
 
# Распаковка с игнорированием значений
name, _, occupation = ("Анна Каренина", 28, "Дама высшего общества")
print(f"{name} работает как {occupation}")
 
# Распаковка с оператором *
first, *middle, last = [1, 2, 3, 4, 5]
print(middle)  # [2, 3, 4]

# Множественное присваивание
x, y, z = 1, 2, 3
 
# Обмен значений без временной переменной
a, b = 5, 10
a, b = b, a  # Теперь a = 10, b = 5

# Создаем кольцевой буфер для хранения последних N элементов
def ring_buffer(size):
    buffer = []
    def add(item):
        buffer.append(item)
        if len(buffer) > size:
            buffer.pop(0)
        return buffer
    return add
 
# Использование
last_5 = ring_buffer(5)
for i in range(10):
    print(last_5(i))

# Сортировка списка людей по нескольким критериям
people = [
    ('Петр', 'Иванов', 35),
    ('Анна', 'Петрова', 22),
    ('Петр', 'Сидоров', 42),
]
 
# Сортировка по имени (возрастание), затем по возрасту (убывание)
sorted_people = sorted(people, key=lambda x: (x[0], -x[2]))
print(sorted_people)

# Подсчет частоты элементов в списке
numbers = [1, 2, 3, 1, 2, 3, 1, 4, 5]
frequency = {}
 
for num in numbers:
    frequency[num] = frequency.get(num, 0) + 1
 
# Получение элементов с наибольшей частотой
max_frequency = max(frequency.values())
most_frequent = [num for num, freq in frequency.items() if freq == max_frequency]

def get_dimensions():
    width = 1920
    height = 1080
    return width, height  # Неявное создание кортежа
 
# Использование
screen_width, screen_height = get_dimensions()
print(f"Разрешение экрана: {screen_width}×{screen_height}")

def fetch_user_data(user_id):
    # В реальном коде здесь был бы запрос к базе данных
    return "Сергей Павлов", 32, "sergey@example.com"
 
# Плохо
data = fetch_user_data(42)
print(f"Имя: {data[0]}, Возраст: {data[1]}")
 
# Хорошо
name, age, email = fetch_user_data(42)
print(f"Имя: {name}, Возраст: {age}")

def get_statistics(values):
    minimum = min(values)
    maximum = max(values)
    average = sum(values) / len(values)
    return minimum, maximum, average
 
# Если нам нужны только минимум и максимум
min_val, max_val, _ = get_statistics([1, 5, 3, 9, 2])

from collections import namedtuple
 
# Определяем структуру результата
UserResult = namedtuple('UserResult', ['success', 'data', 'error'])
 
def process_user_request(request):
    try:
        # ... обработка запроса ...
        return UserResult(True, {"id": 123, "status": "active"}, None)
    except Exception as e:
        return UserResult(False, None, str(e))
 
# Использование
result = process_user_request({"action": "verify"})
if result.success:
    print(f"Данные: {result.data}")
else:
    print(f"Ошибка: {result.error}")

queue = []
# Добавление элементов
queue.append("первый")
queue.append("второй")
queue.append("третий")
 
# Извлечение элементов
first = queue.pop(0)  # Удаляет и возвращает первый элемент
print(first)  # "первый"

from collections import deque
 
queue = deque()
queue.append("первый")
queue.append("второй")
queue.append("третий")
 
# Извлечение — O(1) операция
first = queue.popleft()
print(first)  # "первый"

stack = []
# Добавление на вершину стека
stack.append("дно")
stack.append("середина")
stack.append("вершина")
 
# Извлечение с вершины — O(1) операция
top = stack.pop()
print(top)  # "вершина"

class CircularBuffer:
    def __init__(self, capacity):
        self.buffer = [None] * capacity
        self.capacity = capacity
        self.size = 0
        self.head = 0
        self.tail = 0
    
    def enqueue(self, item):
        # Если буфер полон, перезаписываем старейшие данные
        if self.size == self.capacity:
            self.head = (self.head + 1) % self.capacity
        
        # Записываем элемент и обновляем указатели
        self.buffer[self.tail] = item
        self.tail = (self.tail + 1) % self.capacity
        self.size = min(self.size + 1, self.capacity)
    
    def dequeue(self):
        if self.size == 0:
            raise IndexError("Буфер пуст")
            
        item = self.buffer[self.head]
        self.head = (self.head + 1) % self.capacity
        self.size -= 1
        return item
    
    def __repr__(self):
        return str(self.buffer)
 
# Использование
cb = CircularBuffer(3)
for i in range(5):
    cb.enqueue(i)
 
print(cb)  # [2, 3, 4] — начальные значения были перезаписаны

def process_data_stream(data_generator, batch_size=100):
    buffer = []
    for item in data_generator:
        buffer.append(item)
        
        # Когда буфер накопил достаточно данных, обрабатываем их пакетом
        if len(buffer) >= batch_size:
            process_batch(buffer)
            buffer = []  # Очищаем буфер
    
    # Обрабатываем оставшиеся данные
    if buffer:
        process_batch(buffer)
 
# Пример использования
def data_source():
    for i in range(350):
        yield f"Данные_{i}"
 
def process_batch(batch):
    print(f"Обработка пакета из {len(batch)} элементов")
 
process_data_stream(data_source())

# Матрица 3x3 как список списков
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
 
print(matrix[1][2])  # Доступ к элементу во второй строке, третьем столбце: 6
 
# Дерево как вложенные кортежи (корень, левое поддерево, правое поддерево)
tree = ('A',
        ('B', ('D', None, None), ('E', None, None)),
        ('C', ('F', None, None), ('G', None, None))
       )

# Кортеж, содержащий список
data = (1, [2, 3], 4)
 
# Нельзя изменить сам кортеж
[H2]data[1] = [5, 6]  # TypeError[/H2]
 
# Но можно изменить список внутри кортежа
data[1].append(3.5)
print(data)  # (1, [2, 3, 3.5], 4)

# Список в кортеж
my_list = [1, 2, 3, 4]
my_tuple = tuple(my_list)
print(my_tuple)  # (1, 2, 3, 4)
 
# Кортеж в список
another_tuple = ('a', 'b', 'c')
another_list = list(another_tuple)
print(another_list)  # ['a', 'b', 'c']

def get_bounds():
    # Возвращает границы некоторого диапазона
    return (0, 100)
 
# Получаем границы и корректируем их
bounds = list(get_bounds())
bounds[1] = 200  # Увеличиваем верхнюю границу
 
# Используем как ключ для кеширования
cache = {}
cache[tuple(bounds)] = "расчётные данные"

# Неэффективно для больших N
large_list = []
for i in range(10000000):
    large_list.append(i)
 
# Эффективнее (предварительно выделяем нужный размер)
better_list = [None] * 10000000
for i in range(10000000):
    better_list[i] = i

# Вместо:
result = []
for item in data:
    if condition(item):
        result.append(transform(item))
 
# Используйте списковое включение:
result = [transform(item) for item in data if condition(item)]

# Вместо многократного обращения по индексу
total = 0
for i in range(1000):
    total += my_list[10]  # Многократный доступ к одному элементу
 
# Лучше сохранить значение в переменной
element = my_list[10]
total = element * 1000

import array
 
# Создаём массив целых чисел (гораздо более эффективно по памяти)
int_array = array.array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
 
# Операции с массивом аналогичны операциям со списком
int_array.append(11)
print(int_array[5])  # 6

# Демонстрация интернирования кортежей
a = (1, 2)
b = (1, 2)
print(a is b)  # Может быть True для некоторых версий Python и малых кортежей
 
# Для списков это никогда не будет верно
c = [1, 2]
d = [1, 2]
print(c is d)  # Всегда False

# Вместо создания огромного списка в памяти
huge_list = [complicated_function(i) for i in range(10000000)]
 
# Используйте генератор
def huge_generator():
    for i in range(10000000):
        yield complicated_function(i)
 
# Генератор потребляет минимум памяти
for value in huge_generator():
    process(value)

import copy
 
# Для создания независимой копии вложенных структур
nested_list = [[1, 2], [3, 4]]
shallow_copy = list(nested_list)  # или nested_list.copy() или nested_list[:]
deep_copy = copy.deepcopy(nested_list)
 
# Изменение вложенного списка
nested_list[0][0] = 99
 
print(shallow_copy)  # [[99, 2], [3, 4]] - изменилась и копия!
print(deep_copy)     # [[1, 2], [3, 4]] - глубокая копия не изменилась

# Генератор списка - создает и возвращает весь список сразу
squares_list = [x*x for x in range(1000000)]
 
# Выражение-генератор - создает генератор, который вычисляет значения по запросу
squares_gen = (x*x for x in range(1000000))
 
# Сравнение использования памяти
import sys
print(f"Размер списка: {sys.getsizeof(squares_list)} байт")
print(f"Размер генератора: {sys.getsizeof(squares_gen)} байт")

import time
 
# Замеряем время доступа
list_time_start = time.time()
total = sum(squares_list)
list_time = time.time() - list_time_start
 
gen_time_start = time.time()
total = sum(squares_gen)  # Обратите внимание, что генератор исчерпан после использования
gen_time = time.time() - gen_time_start
 
print(f"Время доступа к списку: {list_time:.6f} сек")
print(f"Время генерирования и суммирования: {gen_time:.6f} сек")

# Конвейерная обработка с генераторами
result = sum(x*2 for x in range(1000000) if x % 2 == 0)

# Пример мемоизации с использованием кортежей
cache = {}
 
def expensive_calculation(a, b, c):
    # Создаём кортеж из аргументов для использования в качестве ключа
    args = (a, b, c)
    
    # Проверяем, есть ли результат в кеше
    if args in cache:
        print("Используем кешированный результат")
        return cache[args]
    
    print("Выполняем вычисление")
    # Имитация тяжелого расчета
    import time
    time.sleep(1)
    result = a[B]2 + b[/B]2 + c**2
    
    # Сохраняем результат в кеше
    cache[args] = result
    return result
 
# Тестируем
print(expensive_calculation(1, 2, 3))  # Выполнит расчет
print(expensive_calculation(1, 2, 3))  # Использует кеш
print(expensive_calculation(4, 5, 6))  # Выполнит новый расчет

def memoize(func):
    cache = {}
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper
 
@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
 
# Теперь функция fibonacci автоматически использует кеширование
print(fibonacci(35))  # Быстрый результат благодаря мемоизации

from collections import namedtuple
 
# Определяем новый тип - именованный кортеж
Point = namedtuple('Point', ['x', 'y', 'z'])
 
# Создаем экземпляр
p = Point(1, 2, 3)
 
# Доступ по именам
print(p.x, p.y, p.z)  # 1 2 3
 
# Доступ по индексам (как обычный кортеж)
print(p[0], p[1], p[2])  # 1 2 3
 
# Распаковка, как обычный кортеж
x, y, z = p

# Использование именованных кортежей для представления структур данных
Employee = namedtuple('Employee', ['name', 'age', 'position', 'salary'])
 
# Создание коллекции сотрудников
employees = [
    Employee('Анна', 28, 'Программист', 120000),
    Employee('Борис', 35, 'Менеджер', 150000),
    Employee('Виктор', 24, 'Дизайнер', 90000)
]
 
# Обработка данных с использованием удобного доступа по имени
for emp in employees:
    if emp.age < 30 and emp.salary > 100000:
        print(f"{emp.name} — перспективный молодой специалист")

# Создание нового именованного кортежа с измененными значениями
p1 = Point(1, 2, 3)
p2 = p1._replace(y=20)
print(p2)  # Point(x=1, y=20, z=3)
 
# Преобразование в словарь
point_dict = p2._asdict()
print(point_dict)  # {'x': 1, 'y': 20, 'z': 3}
 
# Получение имен полей и значений
print(p2._fields)  # ('x', 'y', 'z')
print(p2._field_defaults)  # {}
 
# Создание именованного кортежа со значениями по умолчанию
Person = namedtuple('Person', ['name', 'age', 'job'], defaults=['Unknown', 0, None])
default_person = Person()
print(default_person)  # Person(name='Unknown', age=0, job=None)

from dataclasses import dataclass
 
@dataclass
class MutablePoint:
    x: int
    y: int
    z: int = 0  # значение по умолчанию
 
p = MutablePoint(1, 2)
print(p)  # MutablePoint(x=1, y=2, z=0)
 
# Можно изменять поля
p.y = 20
print(p)  # MutablePoint(x=1, y=20, z=0)