Python · Синтаксис · Початковий рівень

Методи словників

10 завдань

Освойте всі основні методи словників та dict comprehension для ефективної роботи з даними.

Короткий вступ до теми та пояснення перед вправами (вправи нижче):

Методи словників

#
Словник — це невпорядкована колекція пар ключ-значення. Ключі мають бути незмінними (рядки, числа, кортежі); значення — будь-якого типу. Словники **мутабельні**: можна додавати, оновлювати та видаляти записи. ## Безпечне читання з get() ```python user = {"name": "Alice", "age": 30} print(user["name"]) # "Alice" print(user.get("email")) # None — без KeyError! print(user.get("email", "not set")) # "not set" ``` Завжди надавайте перевагу `get()` перед `[]`, якщо ключ може бути відсутнім. Прямий доступ через `[]` кидає `KeyError`, якщо ключ не існує. ## setdefault() ```python d = {} d.setdefault("count", 0) # встановлює "count" = 0 тільки якщо його немає d["count"] += 1 print(d) # {"count": 1} # Класичний паттерн підрахунку слів: text = "apple banana apple cherry apple" freq = {} for word in text.split(): freq.setdefault(word, 0) freq[word] += 1 print(freq) # {"apple": 3, "banana": 1, "cherry": 1} ``` ## update() ```python defaults = {"color": "blue", "size": 10, "shape": "circle"} overrides = {"color": "red", "weight": 5} defaults.update(overrides) print(defaults) # {"color": "red", "size": 10, "shape": "circle", "weight": 5} ``` `update()` модифікує словник на місці. Для злиття без мутації використовуйте `{**d1, **d2}` (Python 3.5+) або `d1 | d2` (Python 3.9+). ## pop() та popitem() ```python d = {"a": 1, "b": 2, "c": 3} val = d.pop("b") # видаляє ключ "b", повертає 2 print(val, d) # 2 {"a": 1, "c": 3} val = d.pop("x", "default") # повертає "default" — без KeyError print(val) # "default" key, val = d.popitem() # видаляє і повертає останній вставлений (k, v) print(key, val) # "c" 3 ``` ## keys(), values(), items() ```python person = {"name": "Bob", "age": 25, "city": "Kyiv"} print(list(person.keys())) # ["name", "age", "city"] print(list(person.values())) # ["Bob", 25, "Kyiv"] print(list(person.items())) # [("name", "Bob"), ("age", 25), ("city", "Kyiv")] # Ітерація по парах ключ-значення for key, value in person.items(): print(f"{key}: {value}") ``` ## copy() та clear() ```python original = {"a": 1, "b": 2} copy = original.copy() # поверхнева копія copy["c"] = 3 print(original) # {"a": 1, "b": 2} — не змінився original.clear() print(original) # {} ```

Dict Comprehension та вкладені словники

#
## Dict comprehension Dict comprehension створює новий словник з будь-якого ітерабельного в одному читабельному виразі. ```python # Базовий: {ключ: значення for елемент in ітерабельний} squares = {x: x**2 for x in range(1, 6)} print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25} # З двох списків через zip keys = ["a", "b", "c"] values = [1, 2, 3] d = {k: v for k, v in zip(keys, values)} print(d) # {"a": 1, "b": 2, "c": 3} # З умовою (фільтр) even_squares = {x: x**2 for x in range(10) if x % 2 == 0} print(even_squares) # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64} # Трансформація існуючого словника prices = {"apple": 1.2, "banana": 0.5, "cherry": 3.0} discounted = {item: round(price * 0.9, 2) for item, price in prices.items()} print(discounted) # {"apple": 1.08, "banana": 0.45, "cherry": 2.7} ``` ## Інверсія словника ```python original = {"a": 1, "b": 2, "c": 3} inverted = {v: k for k, v in original.items()} print(inverted) # {1: "a", 2: "b", 3: "c"} ``` Працює тільки якщо всі значення унікальні та хешабельні. ## Вкладені словники ```python users = { "alice": {"age": 30, "role": "admin"}, "bob": {"age": 25, "role": "user"}, } # Доступ до вкладеного значення print(users["alice"]["role"]) # "admin" # Безпечний доступ — ланцюжок get() role = users.get("charlie", {}).get("role", "guest") print(role) # "guest" — без KeyError навіть якщо "charlie" не існує # Оновлення вкладеного значення users["alice"]["age"] = 31 ``` ## Групування через словники ```python words = ["apple", "ant", "banana", "bear", "cherry"] by_letter = {} for word in words: letter = word[0] by_letter.setdefault(letter, []) by_letter[letter].append(word) print(by_letter) # {"a": ["apple", "ant"], "b": ["banana", "bear"], "c": ["cherry"]} ``` ## Злиття словників (Python 3.9+) ```python d1 = {"a": 1, "b": 2} d2 = {"b": 3, "c": 4} merged = d1 | d2 # новий словник, d2 перемагає при конфліктах print(merged) # {"a": 1, "b": 3, "c": 4} d1 |= d2 # оновлює d1 на місці print(d1) # {"a": 1, "b": 3, "c": 4} ```

Довідник: методи словників

#
## Основні методи | Метод | Що робить | Повертає | |---|---|---| | `d[key]` | Отримати значення (KeyError якщо немає) | значення | | `d.get(key)` | Отримати значення або `None` | значення або None | | `d.get(key, default)` | Отримати значення або default | значення або default | | `d[key] = val` | Встановити / оновити ключ | — | | `d.setdefault(key, default)` | Встановити default тільки якщо ключа немає | значення | | `d.update(other)` | Злити `other` у `d` (на місці) | `None` | | `d.pop(key)` | Видалити і повернути значення (KeyError якщо немає) | значення | | `d.pop(key, default)` | Видалити і повернути значення або default | значення або default | | `d.popitem()` | Видалити і повернути останню пару (key, value) | (key, value) | | `d.keys()` | Представлення всіх ключів | dict_keys | | `d.values()` | Представлення всіх значень | dict_values | | `d.items()` | Представлення всіх пар (key, value) | dict_items | | `d.copy()` | Поверхнева копія | новий dict | | `d.clear()` | Видалити всі записи | `None` | | `key in d` | Перевірити наявність ключа | bool | | `len(d)` | Кількість пар ключ-значення | int | ## Синтаксис dict comprehension ```python {key_expr: val_expr for var in iterable} {key_expr: val_expr for var in iterable if condition} {key_expr: val_expr for k, v in d.items()} ``` ## Злиття словників ```python # Python 3.5+: розпакування merged = {**d1, **d2} # Python 3.9+: оператор | merged = d1 | d2 d1 |= d2 # на місці # Всі версії: update d1.update(d2) ``` ## Безпечний доступ до вкладених даних ```python # Ланцюжок .get() щоб уникнути KeyError на будь-якому рівні value = data.get("user", {}).get("address", {}).get("city", "unknown") ``` ## Поширені патерни ```python # Частота слів freq = {} for word in text.split(): freq[word] = freq.get(word, 0) + 1 # Групування за категорією groups = {} for item in items: groups.setdefault(item.category, []).append(item) # Інвертування inv = {v: k for k, v in d.items()} # Фільтрація за значенням filtered = {k: v for k, v in d.items() if v > 0} ```

Вправи:

01

Безпечне читання конфігурації

#
Напишіть функцію `get_setting(config, key, default=None)`, яка безпечно читає значення зі словника конфігурації. Якщо ключ є — повертає значення, інакше — `default`. Приклад: `get_setting({"debug": True}, "debug")` → `True`, `get_setting({"debug": True}, "port", 8080)` → `8080`.
def get_setting(config, key, default=None):
    pass


print(get_setting({"debug": True}, "debug"))          # True
print(get_setting({"debug": True}, "port", 8080))     # 8080
print(get_setting({"debug": True}, "host"))           # None
Рішення 
def get_setting(config, key, default=None):
    return config.get(key, default)


print(get_setting({"debug": True}, "debug"))          # True
print(get_setting({"debug": True}, "port", 8080))     # 8080
print(get_setting({"debug": True}, "host"))           # None
02

Частота слів

#
Напишіть функцію `word_freq(text)`, яка повертає словник, де кожне слово відповідає кількості його входжень. Слова перекладаються у нижній регістр (для простоти вважайте, що слова розділені лише пробілами). Приклад: `word_freq("the cat sat the cat")` → `{"the": 2, "cat": 2, "sat": 1}`.
def word_freq(text):
    pass


print(word_freq("the cat sat the cat"))
# {"the": 2, "cat": 2, "sat": 1}
Рішення 
def word_freq(text):
    counts = {}
    for word in text.lower().split():
        counts[word] = counts.get(word, 0) + 1
    return counts


print(word_freq("the cat sat the cat"))
# {"the": 2, "cat": 2, "sat": 1}
03

Злиття з перевизначенням

#
Напишіть функцію `merge(base, overrides)`, яка повертає новий словник з усіма ключами з `base`, але якщо ключ є у `overrides` — береться значення з `overrides`. Оригінальні словники не повинні змінюватись. Приклад: `merge({"a": 1, "b": 2}, {"b": 99, "c": 3})` → `{"a": 1, "b": 99, "c": 3}`.
def merge(base, overrides):
    pass


print(merge({"a": 1, "b": 2}, {"b": 99, "c": 3}))
# {"a": 1, "b": 99, "c": 3}
Рішення 
def merge(base, overrides):
    return {**base, **overrides}


print(merge({"a": 1, "b": 2}, {"b": 99, "c": 3}))
# {"a": 1, "b": 99, "c": 3}
04

Безпечне видалення ключа

#
Напишіть функцію `remove_key(d, key)`, яка видаляє `key` зі словника `d` якщо він існує, і повертає видалене значення. Якщо ключ не існує — повертає `None` без помилки. Функція має модифікувати `d` на місці. Приклад: `d = {"a": 1, "b": 2}; remove_key(d, "a")` → повертає `1`, `d` стає `{"b": 2}`.
def remove_key(d, key):
    pass


d = {"a": 1, "b": 2}
print(remove_key(d, "a"))   # 1
print(d)                    # {"b": 2}
print(remove_key(d, "x"))   # None
Рішення 
def remove_key(d, key):
    return d.pop(key, None)


d = {"a": 1, "b": 2}
print(remove_key(d, "a"))   # 1
print(d)                    # {"b": 2}
print(remove_key(d, "x"))   # None
05

Словник квадратів

#
Напишіть функцію `squares_dict(n)` з використанням dict comprehension, яка повертає словник, де ключі — цілі числа від 1 до `n`, а значення — їх квадрати. Приклад: `squares_dict(5)` → `{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}`.
def squares_dict(n):
    pass


print(squares_dict(5))
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
Рішення 
def squares_dict(n):
    return {i: i ** 2 for i in range(1, n + 1)}


print(squares_dict(5))
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
06

Фільтрація за значенням

#
Напишіть функцію `filter_dict(d, min_value)`, яка повертає новий словник, що містить тільки пари ключ-значення, де значення більше або рівне `min_value`. Приклад: `filter_dict({"a": 5, "b": 1, "c": 8, "d": 3}, 4)` → `{"a": 5, "c": 8}`.
def filter_dict(d, min_value):
    pass


print(filter_dict({"a": 5, "b": 1, "c": 8, "d": 3}, 4))
# {"a": 5, "c": 8}
Рішення 
def filter_dict(d, min_value):
    return {k: v for k, v in d.items() if v >= min_value}


print(filter_dict({"a": 5, "b": 1, "c": 8, "d": 3}, 4))
# {"a": 5, "c": 8}
07

Інвертування словника

#
Напишіть функцію `invert(d)`, яка міняє місцями ключі і значення словника і повертає новий інвертований словник. Вважайте, що всі значення унікальні та хешабельні. Приклад: `invert({"a": 1, "b": 2, "c": 3})` → `{1: "a", 2: "b", 3: "c"}`.
def invert(d):
    pass


print(invert({"a": 1, "b": 2, "c": 3}))
# {1: "a", 2: "b", 3: "c"}
Рішення 
def invert(d):
    return {v: k for k, v in d.items()}


print(invert({"a": 1, "b": 2, "c": 3}))
# {1: "a", 2: "b", 3: "c"}
08

Групування за першою літерою

#
Напишіть функцію `group_by_letter(words)`, яка повертає словник, де кожен ключ — це літера, а значення — відсортований список слів, що починаються з цієї літери. Приклад: `group_by_letter(["apple", "ant", "banana", "bear"])` → `{"a": ["ant", "apple"], "b": ["banana", "bear"]}`.
def group_by_letter(words):
    pass


print(group_by_letter(["apple", "ant", "banana", "bear"]))
# {"a": ["ant", "apple"], "b": ["banana", "bear"]}
Рішення 
def group_by_letter(words):
    result = {}
    for word in words:
        key = word[0]
        result.setdefault(key, []).append(word)
    for key in result:
        result[key].sort()
    return result


print(group_by_letter(["apple", "ant", "banana", "bear"]))
# {"a": ["ant", "apple"], "b": ["banana", "bear"]}
09

Безпечний доступ до вкладених даних

#
Напишіть функцію `deep_get(data, *keys)`, яка безпечно отримує значення з вкладених словників за ланцюжком ключів. Повертає `None` якщо будь-який ключ відсутній. Приклад: `deep_get({"user": {"address": {"city": "Kyiv"}}}, "user", "address", "city")` → `"Kyiv"`, `deep_get({"user": {}}, "user", "address", "city")` → `None`.
def deep_get(data, *keys):
    pass


user = {"user": {"address": {"city": "Kyiv"}}}
print(deep_get(user, "user", "address", "city"))   # Kyiv
print(deep_get(user, "user", "phone"))              # None
Рішення 
def deep_get(data, *keys):
    for key in keys:
        if not isinstance(data, dict):
            return None
        data = data.get(key)
    return data


user = {"user": {"address": {"city": "Kyiv"}}}
print(deep_get(user, "user", "address", "city"))   # Kyiv
print(deep_get(user, "user", "phone"))              # None
10

Словник з двох списків

#
Напишіть функцію `zip_to_dict(keys, values)`, яка створює словник з двох списків однакової довжини. Якщо довжини різні — кидає `ValueError` з повідомленням `"Lists must have the same length"`. Приклад: `zip_to_dict(["a", "b", "c"], [1, 2, 3])` → `{"a": 1, "b": 2, "c": 3}`.
def zip_to_dict(keys, values):
    pass


print(zip_to_dict(["a", "b", "c"], [1, 2, 3]))
# {"a": 1, "b": 2, "c": 3}
zip_to_dict(["x", "y"], [1, 2, 3])  # raises ValueError
Рішення 
def zip_to_dict(keys, values):
    if len(keys) != len(values):
        raise ValueError("Lists must have the same length")
    return dict(zip(keys, values))


print(zip_to_dict(["a", "b", "c"], [1, 2, 3]))
# {"a": 1, "b": 2, "c": 3}
try:
    zip_to_dict(["x", "y"], [1, 2, 3])
except ValueError as e:
    print(e)