Когда будешь использовать список?

Когда использовать список (list) в Python

Список (list) — один из основных типов данных в Python. Важно понимать, когда его использовать, а когда выбрать альтернативу.

Характеристики списка

# Основные свойства списка
my_list = [1, 2, 3, 'a', None, [4, 5]]

# ✅ Упорядочен (сохраняет порядок)
my_list[0]  # 1 - доступ по индексу O(1)

# ✅ Изменяемый (mutable)
my_list[0] = 10
my_list.append(100)

# ✅ Может содержать разные типы
my_list = [1, 'string', 3.14, None, True]

# ✅ Итерируемый
for item in my_list:
    print(item)

# ✅ Динамический размер
my_list = []
my_list.append(1)  # Размер растёт

1. Использовать список, когда нужна упорядоченная коллекция

# ✅ ХОРОШО: сохранять порядок
users_in_line = ['Alice', 'Bob', 'Charlie', 'David']
first_user = users_in_line[0]  # Alice
# Порядок важен!

# ✅ ХОРОШО: последовательность действий
setup_steps = [
    'Install dependencies',
    'Run migrations',
    'Start server',
    'Run tests'
]
for step in setup_steps:
    print(f"Doing: {step}")
# Порядок критически важен!

# ✅ ХОРОШО: координаты или последовательность значений
coordinates = [10, 20, 30]  # (x, y, z)
point = [x1, y1, x2, y2]    # Координаты двух точек

2. Использовать список, когда нужна частая модификация

# ✅ ХОРОШО: часто добавляем/удаляем элементы
shoppinglist = []

def add_item(item):
    shopping_list.append(item)      # O(1) амортизированный

def remove_item(item):
    shopping_list.remove(item)      # O(n)

additem('milk')
add_item('bread')
add_item('eggs')
# Список отлично подходит для динамического расширения

# ✅ ХОРОШО: изменение элементов
scores = [10, 20, 30]
for i in range(len(scores)):
    scores[i] *= 2  # Изменяем каждый элемент
# Кортеж это не позволит!

# ✅ ХОРОШО: сортировка
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()           # Сортирует на месте O(n log n)
numbers.reverse()        # Переворачивает O(n)

3. Использовать список, когда нужен доступ по индексу

# ✅ ХОРОШО: случайный доступ по индексу
import random

players = ['Alice', 'Bob', 'Charlie', 'David']
random_player = players[random.randint(0, len(players)-1)]  # O(1)
# Индексированный доступ — очень быстро!

# ✅ ХОРОШО: работа с диапазонами (slicing)
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
middle = items[3:7]          # [4, 5, 6, 7]
every_other = items[::2]     # [1, 3, 5, 7, 9]
reversed_items = items[::-1] # [10, 9, 8, ...]
# Срезы работают только на последовательностях

4. Когда НЕ использовать список

❌ Не используй список, если нужна неизменяемость

# ❌ ПЛОХО: использовать список для неизменяемых данных
def get_coordinates():
    coords = [10, 20]  # Можно изменить!
    return coords

coords = get_coordinates()
coords[0] = 999  # Случайно изменил!

# ✅ ХОРОШО: использовать кортеж
def get_coordinates():
    return (10, 20)   # Защищено от изменений

coords = get_coordinates()
coords[0] = 999  # TypeError: tuple does not support item assignment

❌ Не используй список, если нужна уникальность элементов

# ❌ ПЛОХО: использовать список для уникальных данных
visited_ips = ['192.168.1.1', '10.0.0.1', '192.168.1.1']  # Дублей!
if '192.168.1.1' in visited_ips:  # O(n) - медленно
    print("Already visited")

# ✅ ХОРОШО: использовать set для уникальности
visited_ips = {'192.168.1.1', '10.0.0.1'}  # Автоматическая уникальность
if '192.168.1.1' in visited_ips:  # O(1) - очень быстро
    print("Already visited")

❌ Не используй список, если часто ищешь элементы

# ❌ ПЛОХО: частые поиски в списке
user_ids = [101, 102, 103, 104, 105, ...., 1000000]
if 500000 in user_ids:  # O(n) - очень медленно! Может быть 500k проверок
    print("Found")

# ✅ ХОРОШО: использовать set для быстрого поиска
user_ids = {101, 102, 103, 104, 105, ...., 1000000}
if 500000 in user_ids:  # O(1) - мгновенно!
    print("Found")

# ✅ ХОРОШО: если нужен поиск с фильтром, то пуск списка
users = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
result = [u for u in users if u['name'] == 'Alice']  # Фильтрация

❌ Не используй список, если нужны key-value пары

# ❌ ПЛОХО: хранить пары в списке
config = ['host', 'localhost', 'port', 8000, 'debug', True]
host = config[0]  # Каким индексом это было?
port = config[2]  # Сложно помнить!

# ✅ ХОРОШО: использовать dict
config = {'host': 'localhost', 'port': 8000, 'debug': True}
host = config['host']   # Ясный доступ
port = config['port']   # Читаемо

5. Сравнение списка с альтернативами

*В Python 3.7+ dict сохраняет порядок как побочный эффект

6. Реальные примеры использования списков

Пример 1: Обработка результатов запроса

# Список идеален для результатов запроса
def fetch_users_from_database(limit=10):
    users = []  # Используем список
    for row in database.execute("SELECT * FROM users LIMIT ?" , (limit,)):
        user = {'id': row[0], 'name': row[1], 'email': row[2]}
        users.append(user)  # Добавляем по мере обработки
    return users

users = fetch_users_from_database()
for user in users:  # Упорядоченный результат
    print(user['name'])

Пример 2: Pipeline обработки данных

# Список отлично подходит для последовательных трансформаций
def process_data(raw_data):
    results = []
    
    # Шаг 1: фильтрация
    for item in raw_data:
        if item['valid']:
            results.append(item)
    
    # Шаг 2: трансформация
    results = [transform(item) for item in results]
    
    # Шаг 3: сортировка
    results.sort(key=lambda x: x['priority'], reverse=True)
    
    return results

Пример 3: Кэширование с порядком

# Список для LRU кэша
class LRUCache:
    def __init__(self, capacity=100):
        self.cache = {}  # Быстрый поиск
        self.order = []  # Порядок доступа
        self.capacity = capacity
    
    def get(self, key):
        if key in self.cache:
            self.order.remove(key)  # O(n), но обычно кэш мал
            self.order.append(key)  # Переместить в конец
            return self.cache[key]
        return None
    
    def put(self, key, value):
        if key in self.cache:
            self.order.remove(key)
        elif len(self.order) >= self.capacity:
            old_key = self.order.pop(0)  # Удалить самый старый
            del self.cache[old_key]
        
        self.cache[key] = value
        self.order.append(key)

7. Оптимизация работы со списками

# ❌ ПЛОХО: неоптимизированно
result = []
for i in range(1000000):
    result.append(i * 2)  # Много реаллокаций памяти

# ✅ ХОРОШО: list comprehension (быстрее)
result = [i * 2 for i in range(1000000)]  # Один аллокация

# ❌ ПЛОХО: поиск в списке
if item in large_list:  # O(n)
    ...

# ✅ ХОРОШО: если часто ищешь - используй set
item_set = set(large_list)  # O(n) один раз
if item in item_set:  # O(1) потом
    ...

# ❌ ПЛОХО: удаление в цикле
for item in my_list:
    if should_remove(item):
        my_list.remove(item)  # O(n) каждый раз!

# ✅ ХОРОШО: list comprehension
my_list = [item for item in my_list if not should_remove(item)]  # O(n) один раз

Итоговый практический алгоритм выбора

# Вопросы для выбора структуры данных:

1. Нужна уникальность?
   ДА → set или dict (ключи)
   НЕТ → продолжаем

2. Нужны key-value пары?
   ДА → dict
   НЕТ → продолжаем

3. Нужна неизменяемость?
   ДА → tuple
   НЕТ → продолжаем

4. Нужен быстрый поиск элементов?
   ДА → set
   НЕТ → продолжаем

5. Нужна очередь/стек поведение?
   ДА → deque (из collections)
   НЕТ → продолжаем

6. По умолчанию → list ✅

Итоговый вывод

Использовать список когда:

• ✅ Нужна упорядоченная коллекция (порядок важен)
• ✅ Нужна частая модификация (append, remove, modify)
• ✅ Нужен доступ по индексу (my_list[0])
• ✅ Нужна гибкость типов (разные типы в одном списке)
• ✅ По умолчанию для коллекций (если нет причин использовать другое)

НЕ использовать список когда:

• ❌ Нужна неизменяемость → tuple
• ❌ Нужна уникальность → set
• ❌ Нужны key-value пары → dict
• ❌ Нужна быстрая вставка/удаление в начало → deque
• ❌ Нужны частые поиски элементов → set (O(1) vs O(n))

Список — это универсальный инструмент, но хороший разработчик знает, когда использовать специализированные структуры данных для оптимальной производительности и читаемости кода.