src/intensive15hours/dictionary.py - develop - Kakady32456/pythoncore

src/intensive15hours/dictionary.py
353 строки15 KB
Кузьма Даждъбогин
TSKPTHNPRCTC-5 словари dictionary
23 дек 2025, 16:57
23 дек 2025, 16:5732ef635
"""
Словари (dictionary) в Python

Словарь — это изменяемая коллекция, хранящая данные в виде пар «ключ: значение». Ключи должны быть уникальными и хешируемыми.

Примеры практического использования:
1. Хранение информации о пользователе в веб-приложении (имя, email, возраст)
2. Кэширование результатов дорогостоящих вычислений по ключу
3. Подсчёт частоты слов в тексте
4. Настройки приложения (конфигурация в формате ключ-значение)
5. Представление JSON-данных в памяти

- Изменяемая коллекция: можно добавлять, изменять и удалять элементы
- Неупорядоченная (до Python 3.7), с Python 3.7+ порядок вставки сохраняется
- Доступ к элементам по ключу, а не по индексу
- Ключи должны быть уникальными и хешируемыми (str, int, tuple)
- Значения могут быть любого типа, включая другие словари
- Операции поиска, добавления и удаления — O(1) в среднем
"""


# =============================================================================
# 0) Краткие описания возможностей
# =============================================================================
"""
- Изменяемая коллекция: можно добавлять, изменять и удалять пары
- Порядок вставки сохраняется (начиная с Python 3.7+)
- Доступ к элементам по ключу — не по индексу
- Ключи уникальны и должны быть хешируемыми
- Значения могут повторяться и быть любого типа
- Скорость поиска по ключу — O(1) в среднем
"""


# =============================================================================
# 1) Базовый пример "С чего начать"
# =============================================================================
print("=== Базовый пример использования ===")
# Храним информацию о пользователе
user = {
    "name": "Анна",
    "email": "anna@example.com",
    "age": 28,
    "active": True
}
print(f"Пользователь: {user}")
print(f"Имя: {user['name']}")
print(f"Возраст: {user['age']}")

if user["active"]:
    print(f"Пользователь {user['name']} активен")
print()


# =============================================================================
# 2) Создание словаря
# =============================================================================
print("=== Способы создания ===")

# Пример 1: Литерал словаря — самый частый способ
dict_1 = {"a": 1, "b": 2, "c": 3}
print(f"{dict_1=}")

# Пример 2: Через конструктор dict()
dict_2 = dict(a=1, b=2, c=3)
print(f"{dict_2=}")

# Пример 3: Из списка пар (кортежей или списков)
pairs = [("x", 10), ("y", 20), ("z", 30)]
dict_3 = dict(pairs)
print(f"{dict_3=}")

# Пример 4: Из двух списков с помощью zip()
keys = ["name", "city", "job"]
values = ["Иван", "Москва", "Программист"]
dict_4 = dict(zip(keys, values))
print(f"{dict_4=}")

# ❌ Нельзя использовать изменяемые типы как ключ
# invalid_dict = {[1, 2]: "value"} → TypeError: unhashable type: 'list'
print()


# =============================================================================
# 3) Добавление и изменение элементов
# =============================================================================
print("=== Добавление и изменение ===")

profile = {"name": "Олег"}

# Пример 1: Добавление нового ключа
profile["email"] = "oleg@example.com"
print(f"После добавления email: {profile}")

# Пример 2: Изменение существующего значения
profile["name"] = "Олег Петров"
print(f"После изменения имени: {profile}")

# Пример 3: Добавление нескольких элементов через update()
profile.update({"age": 35, "city": "СПб", "job": "Менеджер"})
print(f"После update(): {profile}")

# Пример 4: update() с другим словарём
new_data = {"phone": "+79991234567", "age": 36}  # age будет перезаписан
profile.update(new_data)
print(f"После обновления данными: {profile}")

# ✅ update() безопасно добавляет и перезаписывает
print()


# =============================================================================
# 4) Удаление элементов
# =============================================================================
print("=== Удаление элементов ===")

# Пример 1: Удаление по ключу с возвратом значения
removed_value = profile.pop("phone")
print(f"Удалённый телефон: {removed_value}")
print(f"После pop('phone'): {profile}")

# Пример 2: Удаление без ошибки, если ключа нет
profile.pop("height", None)  # None — значение по умолчанию
print("Попытка удалить отсутствующий ключ — прошла без ошибки")

# ❌ pop() без значения по умолчанию вызовет KeyError
# profile.pop("missing_key") → KeyError: 'missing_key'

# Пример 3: Удаление последней пары (с Python 3.7+, порядок вставки)
last_key, last_value = profile.popitem()
print(f"Удалена последняя пара: {last_key} = {last_value}")

# ❌ popitem() на пустом словаре → KeyError: 'popitem(): dictionary is empty'

# Пример 4: Удаление с помощью del
del profile["city"]
print(f"После del['city']: {profile}")

# Пример 5: Очистка всего словаря
profile.clear()
print(f"После clear(): {profile}")
print()


# =============================================================================
# 5) Поиск и доступ к элементам
# =============================================================================
print("=== Поиск и доступ ===")

data = {"a": 1, "b": 2, "c": 3}

# Пример 1: Доступ по ключу
print(f"data['a'] = {data['a']}")

# ❌ Обращение к несуществующему ключу → KeyError
# data['missing'] → KeyError: 'missing'

# Пример 2: Безопасное получение значения
value = data.get("missing", "не найден")
print(f"data.get('missing') = {value}")

# Пример 3: Проверка наличия ключа
if "b" in data:
    print("Ключ 'b' присутствует")

# Пример 4: Получение всех ключей, значений, пар
print(f"Ключи: {list(data.keys())}")
print(f"Значения: {list(data.values())}")
print(f"Пары: {list(data.items())}")

# ❌ Словари не поддерживают индексацию: data[0] → ошибка
# ❌ Не поддерживают срезы: data[1:3] → TypeError: unhashable type: 'slice'
print()


# =============================================================================
# 6) Основные методы и операции
# =============================================================================
print("=== Основные методы ===")

stats = {"python": 15, "js": 10, "java": 8, "c++": 5}

# Группа 1: Агрегация
print(f"Сумма значений: {sum(stats.values())}")
print(f"Максимум: {max(stats, key=stats.get)} → {stats[max(stats, key=stats.get)]}")
print(f"Минимум: {min(stats, key=stats.get)} → {stats[min(stats, key=stats.get)]}")

# Группа 2: Преобразования
as_list = list(stats.items())
print(f"Словарь → список пар: {as_list}")

# Группа 3: Копирование
stats_copy = stats.copy()
stats_copy["go"] = 12
print(f"Оригинал: {stats}")
print(f"Копия: {stats_copy}")

# ✅ deepcopy для вложенных структур (если нужно)
import copy
nested = {"user": {"name": "Bob", "age": 30}}
deep_copy = copy.deepcopy(nested)
print()


# =============================================================================
# 7) Продвинутые примеры использования
# =============================================================================
print("=== Продвинутые примеры ===")

# Пример 1: Подсчёт частоты слов
text = "python java python javascript java python"
words = text.split()
word_count = {}
for word in words:
    word_count[word] = word_count.get(word, 0) + 1
print(f"Частота слов: {word_count}")

# Пример 2: Группировка данных
students = [
    {"name": "Alice", "group": "A"},
    {"name": "Bob", "group": "B"},
    {"name": "Charlie", "group": "A"}
]
groups = {}
for student in students:
    group = student["group"]
    groups.setdefault(group, []).append(student["name"])
print(f"Группировка по группам: {groups}")

# Пример 3: Кэширование
_cache = {}
def expensive_function(n):
    if n in _cache:
        print(f"Кэш hit для {n}")
        return _cache[n]
    print(f"Вычисляем для {n}")
    result = n ** 2 + 2 * n + 1  # Пример сложной операции
    _cache[n] = result
    return result

expensive_function(5)
expensive_function(5)  # Повтор — из кэша
print()


# =============================================================================
# 8) Производительность и лучшие практики
# =============================================================================
print("=== Производительность и лучшие практики ===")

# ✅ Используйте словари, когда:
#   - Нужен быстрый доступ по ключу
#   - Храните структурированные данные (объекты, настройки)
#   - Подсчитываете частоты, группируете данные

# ❌ Не используйте словари, когда:
#   - Нужен строгий порядок (лучше list)
#   - Храните только уникальные значения (лучше set)
#   - Нужна математика над элементами (лучше list или array)

# ⚡ Советы по оптимизации:
#   - Используйте .get() вместо проверки `in` + доступ
#   - Для группировки используйте dict.setdefault() или defaultdict
#   - Используйте кеширование (как в примере выше)

# 🔄 Альтернативы:
#   - collections.defaultdict — для автоматического создания значений по умолчанию
#   - collections.OrderedDict — если нужен порядок (в старых Python)
#   - dataclasses — для сложных объектов с типами
print()


# =============================================================================
# 9) Чек-лист понимания
# =============================================================================
"""
Проверь себя:
✓ Знаю, как создать словарь 4 способами
✓ Понимаю, когда использовать словарь, а не список или множество
✓ Могу безопасно добавлять, изменять, удалять и получать элементы
✓ Знаю разницу между pop(), popitem(), del, clear()
✓ Понимаю, почему ключи должны быть хешируемыми
✓ Умею использовать get() и setdefault() для безопасной работы
✓ Знаю, как группировать и кэшировать данные с помощью словарей
"""


# =============================================================================
# 10) Типичные задачи и решения
# =============================================================================
print("=== Решение частых задач ===")

# Задача 1: Как отсортировать словарь по значениям?
sorted_by_value = dict(sorted(word_count.items(), key=lambda x: x[1], reverse=True))
print(f"Словарь по значениям: {sorted_by_value}")

# Задача 2: Как объединить два словаря?
dict_a = {"a": 1, "b": 2}
dict_b = {"c": 3, "d": 4}
merged = dict_a | dict_b  # Python 3.9+
print(f"Объединение: {merged}")

# Задача 3: Как проверить, есть ли хотя бы один общий ключ?
dict_x = {"a": 1, "b": 2}
dict_y = {"b": 3, "c": 4}
has_common_key = bool(dict_x.keys() & dict_y.keys())
print(f"Есть общий ключ: {has_common_key}")
print()


# =============================================================================
# 11) Интеграция с другими возможностями Python
# =============================================================================
print("=== Работа с другими функциями Python ===")

# С генераторами и comprehensions
squares = {x: x**2 for x in range(5)}
print(f"Генератор словаря: {squares}")

# С map и filter (редко, но возможно)
keys = ["a", "b", "c"]
mapped = dict(zip(keys, map(lambda x: x*2, [1, 2, 3])))
print(f"С map(): {mapped}")

# В циклах
for key, value in squares.items():
    print(f"Квадрат {key} = {value}")
print()


# =============================================================================
# 12) Отладка и тестирование
# =============================================================================
print("=== Советы по отладке ===")

debug_dict = {"x": 10, "y": 20}

# Как проверить тип
print(f"Тип: {type(debug_dict)}")

# Как проверить содержимое
print(f"Содержимое: {debug_dict}")
print(f"Ключи: {list(debug_dict.keys())}")

# Как избежать KeyError
key_to_check = "z"
if key_to_check in debug_dict:
    print(f"Значение: {debug_dict[key_to_check]}")
else:
    print(f"Ключ '{key_to_check}' не найден")

# ✅ Лучше использовать .get() для безопасного доступа
print(f"Значение через get(): {debug_dict.get(key_to_check, 'отсутствует')}")