Списки — универсальны, но не всегда подходят. Иногда нужно гарантировать неизменность, иногда — уникальность, а иногда — быстрый доступ по ключу. Для этого у Python есть три структуры, которые закрывают эти задачи намного лучше списков: tuple, set, dict.

Один пример на всю статью: берём текст, считаем частоты слов и параллельно решаем две прикладные задачи:

1. быстро проверяем, встречалось ли слово раньше (проверка принадлежности);
2. получаем топ самых частотных слов.

По дороге станет понятно, где списки проигрывают, а tuple/set/dict выигрывают.

Сначала пишем код

Есть текст. Нужно:

• разбить на слова,
• посчитать, сколько раз каждое встречается,
• вывести топ-5.

Пишем короткий рабочий прототип.

text = """
Python is great, and Python is fast.
Fast code is good code. Python code is readable.
"""

words = text.lower().split()

freq = {}  # словарь частот

for w in words:
    w = w.strip(".,!")  # грубая очистка пунктуации
    if w in freq:
        freq[w] += 1
    else:
        freq[w] = 1

top5 = sorted(freq.items(), key=lambda pair: pair[1], reverse=True)[:5]

for word, count in top5:
    print(word, count)

Это уже делает работу. Теперь разберёмся, какие структуры здесь появились и почему.

Разбираем: что за структуры и зачем

Словарь (dict) — пары ключ-значение

freq = {} — словарь.
Мы храним ключ → значение:

• ключ: слово
• значение: сколько раз оно встречается

Почему не список?

Если бы мы искали, сколько раз встречается слово через список, пришлось бы каждый раз пробегать по нему целиком. Это медленно.
В словаре доступ по ключу устроен так, что проверка w in freq работает очень быстро.

if w in freq:
    freq[w] += 1
else:
    freq[w] = 1

Смысл простой:

• если слово уже было, увеличиваем счётчик
• если нет, создаём запись

Кортеж (tuple) — фиксированная пара

Посмотрите на строку:

freq.items()

Она возвращает набор пар вида:

("python", 3)
("is", 4)
...

Каждая такая пара — кортеж.
Кортеж — это как список, но неизменяемый: нельзя случайно переписать его элементы.

Мы сортируем именно пары:

sorted(freq.items(), key=lambda pair: pair[1], reverse=True)

pair — кортеж (word, count), а pair[1] — его второй элемент.

Множество (set) — уникальность и быстрые проверки

В нашей задаче есть ещё одна полезная вещь: быстро проверять, встречалось ли слово раньше.

Список для этого плох: w in words_list идёт по списку линейно.

Множество делает это почти мгновенно.

Добавим к примеру такую логику: при первом появлении слова кладём его в seen и печатаем «новое слово».

seen = set()

for w in words:
    w = w.strip(".,!")
    
    if w not in seen:
        seen.add(w)   # запоминаем уникальное
        # print("новое слово:", w)

    freq[w] = freq.get(w, 0) + 1

Вот тут сразу два сильных свойства:

1. seen.add(w) гарантирует уникальность
2. w in seen работает быстро.

Улучшаем пример и закрепляем отличия

Сделаем финальную версию парсера чуть аккуратнее:

• считаем частоты,
• собираем уникальные слова,
• проверяем принадлежность,
• выводим топ.

text = """
Python is great, and Python is fast.
Fast code is good code. Python code is readable.
"""

words = text.lower().split()

freq = {}
seen = set()

for raw in words:
    w = raw.strip(".,!")

    # set: уникальность + быстрые проверки
    if w not in seen:
        seen.add(w)

    # dict: частоты
    freq[w] = freq.get(w, 0) + 1

# tuple: пары (слово, частота)
top5 = sorted(freq.items(), key=lambda pair: pair[1], reverse=True)[:5]

print("Уникальных слов:", len(seen))
print("Топ-5:")

for word, count in top5:
    print(f"{word}: {count}")

freq.get(w, 0) — удобный способ из словаря:

• если ключ есть → взять значение
• если нет → взять 0

Чем структуры отличаются по сути

Коротко, по делу:

• list — упорядоченная коллекция, можно менять. Хорош для «последовательностей»: треки, шаги, строки файла.
• tuple — упорядоченная, но неизменяемая. Хорош для фиксированных наборов значений: пары, координаты, результаты.
• set — неупорядоченная коллекция уникальных элементов. Силен в проверке принадлежности и удалении дублей.
• dict — отображение ключ → значение. Силен в частотах, индексах, быстрых поисках по имени.

Если вы каждый раз думаете «что выбрать» — спросите себя:

1. мне нужен порядок?
2. мне нужны дубли?
3. мне нужен доступ по ключу?
4. данные должны быть неизменяемы?

Ответы автоматически подскажут структуру.

Практика на том же примере

Один текст, тот же парсер — только расширение.

1. Сделайте стоп-слова: создайте stop = {"is", "and", "the"} и исключайте их из подсчёта.
2. Выведите слова, которые встретились ровно один раз.
3. Сделайте быстрый поиск: спросите у пользователя слово и отвечайте, есть ли оно в тексте. Проверку делайте через seen, не через список.

Эти три структуры не «дополнение к спискам». Это разные инструменты. Списки удобны часто, но когда задача про уникальность, частоты или пары — tuple/set/dict дают вам код короче, понятнее и быстрее.