Приведи пример задачи, где требуется обычный список

Пример задачи, где требуется обычный список

Отличный вопрос! Давайте разберемся, когда нужен именно список (list), а не другие структуры данных:

1. Обработка последовательности данных

Список идеален для упорядоченных данных, где порядок имеет значение:

# Задача: прочитать результаты анализа крови пациента
# Результаты: холестерин, глюкоза, тромбоциты, лейкоциты (в этом порядке)

blood_test_results = [5.2, 95, 250000, 7000]  # list идеален

for i, value in enumerate(blood_test_results):
    print(f"Результат {i+1}: {value}")

# Почему list, а не dict?
# - Потому что порядок важен (первый результат первый)
# - Потому что индекс имеет значение
# - Потому что много значений одного типа

2. Сортировка и изменение порядка

Список хорош для операций, требующих переупорядочения:

# Задача: отсортировать студентов по баллам экзамена
students_scores = [85, 92, 78, 95, 88, 76]

# Нужна именно изменяемая структура
students_scores.sort()  # Сортировка
print(students_scores)  # [76, 78, 85, 88, 92, 95]

# Реверс
students_scores.reverse()
print(students_scores)  # [95, 92, 88, 85, 78, 76]

# Почему list?
# - Методы sort() и reverse() работают с list
# - Индексный доступ для ранкирования
# - Изменяемость нужна для обновления порядка

3. Динамическое добавление/удаление данных

Список идеален, когда размер меняется во время выполнения:

# Задача: обработать очередь клиентов в банке
queue = []  # Пустой список

# Клиенты приходят и встают в очередь
def client_arrives(name):
    queue.append(name)  # Добавление в конец
    print(f"{name} встал в очередь (позиция {len(queue)})")

# Оператор вызывает следующего клиента
def process_client():
    if queue:
        client = queue.pop(0)  # Удаление с начала (FIFO)
        print(f"Обслуживаю {client}")
    else:
        print("Очередь пуста")

# Симуляция
client_arrives("Alice")
client_arrives("Bob")
client_arrives("Charlie")
process_client()  # Обслуживаю Alice
process_client()  # Обслуживаю Bob
process_client()  # Обслуживаю Charlie

# Почему list?
# - append() добавляет быстро
# - Размер неизвестен заранее
# - Нужна работа с позициями (FIFO)

4. Сбор и агрегирование данных

Список — это естественный способ собрать много значений:

# Задача: найти все простые числа до 100
primes = []  # Начинаем с пустого списка

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

for num in range(2, 100):
    if is_prime(num):
        primes.append(num)  # Собираем результаты в список

print(primes)  # [2, 3, 5, 7, 11, 13, ...]
print(f"Найдено {len(primes)} простых чисел")

# Почему list?
# - Собираем неизвестное количество результатов
# - Порядок важен (по возрастанию)
# - Потом нужны операции: len(), sum(), max()

5. Работа со стеком или очередью

Список идеален для реализации стека (LIFO) и очереди (FIFO):

# Задача: функция вызывает функцию, нужно отслеживать call stack

# СТЕК (LIFO - Last In First Out)
call_stack = []  # Именно list

def func_a():
    call_stack.append("func_a")  # push
    func_b()
    call_stack.pop()  # pop

def func_b():
    call_stack.append("func_b")
    func_c()
    call_stack.pop()

def func_c():
    call_stack.append("func_c")
    print(f"Call stack: {call_stack}")
    # Call stack: ['func_a', 'func_b', 'func_c']
    call_stack.pop()

func_a()

# Почему list?
# - append() = push (добавить в конец)
# - pop() = pop (удалить с конца)
# - Это базовые операции стека

6. Матрицы и многомерные данные

Список списков — естественный способ представить матрицу:

# Задача: представить шахматную доску
board = [
    ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],  # Ряд 8
    ['p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'],  # Ряд 7
    ['.', '.', '.', '.', '.', '.', '.', '.'],  # Ряд 6
    ['.', '.', '.', '.', '.', '.', '.', '.'],  # Ряд 5
    ['.', '.', '.', '.', '.', '.', '.', '.'],  # Ряд 4
    ['.', '.', '.', '.', '.', '.', '.', '.'],  # Ряд 3
    ['P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'],  # Ряд 2
    ['R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R'],  # Ряд 1
]

# Доступ к элементу
piece = board[0][0]  # 'r' (чёрная ладья)

# Почему list of list?
# - Это естественное представление матрицы
# - Легко итерировать по рядам и колонам
# - Можно менять элементы board[3][4] = 'P' (ход коня)

7. Кэширование последовательности операций

Список для логирования или истории:

# Задача: логировать операции для отката (undo)
class TextEditor:
    def __init__(self):
        self.history = []  # Список для истории
        self.content = ""
    
    def type(self, text):
        self.history.append(self.content)  # Сохраняем состояние
        self.content += text
    
    def undo(self):
        if self.history:
            self.content = self.history.pop()  # Возвращаемся на шаг назад

editor = TextEditor()
editor.type("Hello")
editor.type(" World")
print(editor.content)  # "Hello World"
editor.undo()
print(editor.content)  # "Hello"
editor.undo()
print(editor.content)  # ""

# Почему list?
# - pop() удаляет последний элемент (стек LIFO)
# - Естественная структура для истории операций

8. Фильтрация и трансформация данных

Список — хороший способ собрать результаты преобразования:

# Задача: получить все чётные числа и возвести в квадрат
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Способ 1: list comprehension
even_squares = [n**2 for n in numbers if n % 2 == 0]
print(even_squares)  # [4, 16, 36, 64, 100]

# Способ 2: filter + map
even_squares = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(even_squares)  # [4, 16, 36, 64, 100]

# Почему list?
# - Результат трансформации — новый список
# - Нужны операции: len(), sum(), max()
# - Может быть дальнейшая обработка

9. Реальный пример: обработка логов

# Задача: прочитать логи, найти ошибки, отсортировать по времени
import re
from datetime import datetime

logs = []

def parse_log_file(filename):
    with open(filename, 'r') as f:
        for line in f:
            # Парсим: "2024-03-23 10:30:45 ERROR: Database connection failed"
            match = re.match(r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (\w+): (.+)', line)
            if match:
                timestamp, level, message = match.groups()
                logs.append({  # Добавляем в список
                    'time': datetime.fromisoformat(timestamp),
                    'level': level,
                    'message': message
                })

# Фильтруем только ошибки
errors = [log for log in logs if log['level'] == 'ERROR']

# Сортируем по времени
errors.sort(key=lambda x: x['time'])

# Выводим
for error in errors:
    print(f"{error['time']} - {error['message']}")

# Почему list?
# - Много логов, неизвестное количество
# - Нужна фильтрация и сортировка
# - Нужно итерировать по результатам

10. Когда НЕ нужен обычный список

# ❌ Если нужна быстрая вставка/удаление с начала
# Используй: collections.deque (O(1) с обоих концов)
from collections import deque
queue = deque()
queue.append("Alice")    # O(1)
queue.popleft()          # O(1)

# ❌ Если нужны уникальные значения
# Используй: set
unique_ids = {1, 2, 3, 4, 5}

# ❌ Если нужна быстрая проверка наличия по ключу
# Используй: dict
user_by_id = {1: "Alice", 2: "Bob"}

# ❌ Если нужна неизменяемость
# Используй: tuple
immutable_coords = (10, 20)

# ❌ Если нужны пары ключ-значение
# Используй: dict
user_data = {"name": "Alice", "age": 30}

Итоговая таблица: когда что использовать

Вывод

Обычный список требуется когда:

1. Порядок важен — элементы упорядочены
2. Динамический размер — меняется во время выполнения
3. Индексный доступ — нужен доступ по позиции
4. Последовательная обработка — итерирование
5. Изменяемость — нужно добавлять/удалять элементы
6. Операции сортировки — sort(), reverse()
7. Собирание результатов — неизвестное количество значений
8. Матрицы и многомерные данные — список списков
9. Стек/Очередь — LIFO/FIFO структуры
10. Трансформация данных — filter, map, list comprehension

Главное правило: если нужна упорядоченная коллекция, которая меняется — используй list. Это самая универсальная и частая структура в Python.