Методы словарей

Напишите функцию `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

Напишите функцию `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}

Напишите функцию `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}

Напишите функцию `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

Напишите функцию `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}

Напишите функцию `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}

Напишите функцию `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"}

Напишите функцию `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"]}

Напишите функцию `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

Напишите функцию `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)