Python · Синтаксис · Начальный уровень

Методы множеств

10 задач

Научитесь работать с множествами: добавлять и удалять элементы, а также выполнять операции объединения, пересечения и разности.

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

Методы множеств

#
Множество — это неупорядоченная коллекция **уникальных** элементов. Множества мутабельны, но элементы должны быть хешируемыми (неизменяемые типы: строки, числа, кортежи). Множества не поддерживают индексирование — `s[0]` недопустимо. ## Создание множеств ```python s = {1, 2, 3} empty = set() # НЕ {} — это создаёт пустой словарь! from_list = set([1, 2, 2, 3, 3]) print(from_list) # {1, 2, 3} — дубликаты удаляются автоматически ``` ## Добавление и удаление ```python s = {1, 2, 3} s.add(4) # добавляет 4 в множество s.add(2) # без эффекта — 2 уже есть print(s) # {1, 2, 3, 4} s.remove(3) # удаляет 3 — кидает KeyError если нет s.discard(99) # удаляет 99 если есть — БЕЗ ошибки если нет print(s) # {1, 2, 4} popped = s.pop() # удаляет и возвращает ПРОИЗВОЛЬНЫЙ элемент print(popped) # какой-то элемент (порядок не определён) s.clear() # удаляет все элементы print(s) # set() ``` ## Операции над множествами ```python a = {1, 2, 3, 4} b = {3, 4, 5, 6} # Объединение: все элементы из обоих print(a | b) # {1, 2, 3, 4, 5, 6} print(a.union(b)) # то же # Пересечение: только элементы, есть В ОБОИХ print(a & b) # {3, 4} print(a.intersection(b)) # то же # Разность: есть в A, но НЕ в B print(a - b) # {1, 2} print(a.difference(b)) # то же # Симметричная разность: есть в A или B, но НЕ в обоих print(a ^ b) # {1, 2, 5, 6} print(a.symmetric_difference(b)) # то же ``` ## Проверка подмножеств и надмножеств ```python small = {1, 2} big = {1, 2, 3, 4} print(small.issubset(big)) # True — всё из small есть в big print(small <= big) # то же через оператор print(big.issuperset(small)) # True — big содержит всё из small print(big >= small) # то же print(small.isdisjoint({5, 6})) # True — нет общих элементов ``` ## Обновление на месте ```python a = {1, 2, 3} a.update({3, 4, 5}) # добавляет все элементы (как |=) print(a) # {1, 2, 3, 4, 5} a.intersection_update({2, 3}) # оставляет только общие элементы print(a) # {2, 3} a.difference_update({3}) # удаляет элементы из аргумента print(a) # {2} ```

Практические задачи с множествами

#
## Дедупликация Самый частый случай использования множеств: удаление дубликатов из списка. ```python numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] unique = list(set(numbers)) print(sorted(unique)) # [1, 2, 3, 4, 5, 6, 9] ``` Обратите внимание: преобразование в множество теряет исходный порядок. Чтобы сохранить порядок при удалении дубликатов: ```python def deduplicate(lst): seen = set() result = [] for item in lst: if item not in seen: seen.add(item) result.append(item) return result print(deduplicate([3, 1, 4, 1, 5, 9, 2, 6, 5])) # [3, 1, 4, 5, 9, 2, 6] ``` ## Поиск общих и уникальных элементов ```python team_a = {"Alice", "Bob", "Carol", "David"} team_b = {"Bob", "David", "Eve", "Frank"} # Кто есть в обеих командах? both = team_a & team_b print(both) # {"Bob", "David"} # Кто только в команде A? only_a = team_a - team_b print(only_a) # {"Alice", "Carol"} # Все участники (без дубликатов) everyone = team_a | team_b print(everyone) # {"Alice", "Bob", "Carol", "David", "Eve", "Frank"} # Кто ровно в одной команде? exclusive = team_a ^ team_b print(exclusive) # {"Alice", "Carol", "Eve", "Frank"} ``` ## Проверка членства ```python # Поиск в множестве — O(1), намного быстрее списка для больших коллекций allowed_extensions = {".jpg", ".jpeg", ".png", ".gif", ".webp"} def is_image(filename): _, ext = filename.rsplit(".", 1) if "." in filename else (filename, "") return f".{ext.lower()}" in allowed_extensions print(is_image("photo.jpg")) # True print(is_image("doc.pdf")) # False print(is_image("readme.txt")) # False ``` ## Set comprehension ```python words = ["hello", "world", "hello", "python", "world"] unique_words = {w.lower() for w in words} print(unique_words) # {"hello", "world", "python"} # Уникальные первые буквы first_letters = {word[0] for word in ["apple", "banana", "avocado", "cherry"]} print(sorted(first_letters)) # ["a", "b", "c"] ```

Справочник: методы множеств

#
## Мутирующие методы | Метод | Что делает | |---|---| | `s.add(x)` | Добавить `x` в множество | | `s.remove(x)` | Удалить `x` (кидает `KeyError` если нет) | | `s.discard(x)` | Удалить `x` если есть, без ошибки если нет | | `s.pop()` | Удалить и вернуть произвольный элемент | | `s.clear()` | Удалить все элементы | | `s.update(other)` | Добавить все элементы из `other` в `s` | | `s.intersection_update(other)` | Оставить только общие элементы | | `s.difference_update(other)` | Удалить элементы из `other` | ## Операции над множествами — методы и операторы | Операция | Метод | Оператор | Результат | |---|---|---|---| | Объединение | `a.union(b)` | `a | b` | Все элементы A и B | | Пересечение | `a.intersection(b)` | `a & b` | Только есть в A и B | | Разность | `a.difference(b)` | `a - b` | Есть в A, нет в B | | Симметричная разность | `a.symmetric_difference(b)` | `a ^ b` | В A или B, но не в обоих | | Подмножество | `a.issubset(b)` | `a <= b` | Всё из A есть в B | | Надмножество | `a.issuperset(b)` | `a >= b` | A содержит всё из B | | Непересекаемость | `a.isdisjoint(b)` | — | A и B не имеют общих элементов | ## Операторы vs методы Операторы (`|`, `&`, `-`, `^`) требуют, чтобы **оба операнда были множествами**. Методы (`.union()`, `.intersection()` и т.д.) принимают **любой итерируемый** объект: ```python s = {1, 2, 3} s.union([3, 4, 5]) # OK — список принимается s | [3, 4, 5] # TypeError — оператор требует множество ``` ## Set comprehension ```python {выражение for переменная in итерируемый} {выражение for переменная in итерируемый if условие} ``` ## Распространённые паттерны ```python # Дедупликация с сохранением порядка seen = set() result = [x for x in lst if not (x in seen or seen.add(x))] # Быстрая проверка членства VALID = {"admin", "editor", "viewer"} if role not in VALID: raise ValueError(f"Unknown role: {role}") # Общие элементы нескольких множеств common = set.intersection(*list_of_sets) ```

Упражнения:

01

Безопасное удаление

#
Напишите функцию `safe_remove(s, value)`, которая удаляет `value` из множества `s` если он есть, и возвращает `True` если удалено или `False` если не найдено. Функция никогда не должна кидать ошибку. Пример: `s = {1, 2, 3}; safe_remove(s, 2)` → `True`, `s == {1, 3}`; `safe_remove(s, 99)` → `False`.
def safe_remove(s, value):
    pass


s = {1, 2, 3}
print(safe_remove(s, 2))    # True  (s теперь {1, 3})
print(safe_remove(s, 99))   # False
Решение 
def safe_remove(s, value):
    if value in s:
        s.discard(value)
        return True
    return False


s = {1, 2, 3}
print(safe_remove(s, 2))    # True
print(safe_remove(s, 99))   # False
02

Удалить дубликаты с сохранением порядка

#
Напишите функцию `unique_ordered(lst)`, которая удаляет дубликаты из списка с сохранением порядка первого появления. Пример: `unique_ordered([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])` → `[3, 1, 4, 5, 9, 2, 6]`. Используйте множество для отслеживания виденных элементов.
def unique_ordered(lst):
    pass


print(unique_ordered([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]))
# [3, 1, 4, 5, 9, 2, 6]
Решение 
def unique_ordered(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


print(unique_ordered([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]))
# [3, 1, 4, 5, 9, 2, 6]
03

Общие элементы

#
Напишите функцию `common(a, b)`, которая возвращает множество элементов, присутствующих в обоих списках `a` и `b`. Пример: `common([1, 2, 3, 4], [3, 4, 5, 6])` → `{3, 4}`. Преобразуйте в множества и используйте операцию пересечения.
def common(a, b):
    pass


print(common([1, 2, 3, 4], [3, 4, 5, 6]))
# {3, 4}
Решение 
def common(a, b):
    return set(a) & set(b)


print(common([1, 2, 3, 4], [3, 4, 5, 6]))
# {3, 4}
04

Только в одном

#
Напишите функцию `exclusive(a, b)`, которая возвращает множество элементов, присутствующих ровно в одном из двух списков (но не в обоих). Пример: `exclusive([1, 2, 3], [2, 3, 4])` → `{1, 4}`. Используйте операцию симметрической разности.
def exclusive(a, b):
    pass


print(exclusive([1, 2, 3], [2, 3, 4]))
# {1, 4}
Решение 
def exclusive(a, b):
    return set(a) ^ set(b)


print(exclusive([1, 2, 3], [2, 3, 4]))
# {1, 4}
05

Проверка подмножества

#
Напишите функцию `is_subset(small, big)`, которая возвращает `True`, если каждый элемент `small` также есть в `big`. Оба аргумента могут быть списками или множествами. Пример: `is_subset([1, 2], [1, 2, 3, 4])` → `True`, `is_subset([1, 5], [1, 2, 3])` → `False`.
def is_subset(small, big):
    pass


print(is_subset([1, 2], [1, 2, 3, 4]))    # True
print(is_subset([1, 5], [1, 2, 3]))        # False
Решение 
def is_subset(small, big):
    return set(small) <= set(big)


print(is_subset([1, 2], [1, 2, 3, 4]))    # True
print(is_subset([1, 5], [1, 2, 3]))        # False
06

Количество уникальных слов

#
Напишите функцию `unique_word_count(text)`, которая возвращает количество уникальных слов в строке (без учёта регистра). Пример: `unique_word_count("The cat sat on the mat the cat")` → `5` (the, cat, sat, on, mat).
def unique_word_count(text):
    pass


print(unique_word_count("The cat sat on the mat the cat"))
# 5  (the, cat, sat, on, mat)
Решение 
def unique_word_count(text):
    return len(set(text.lower().split()))


print(unique_word_count("The cat sat on the mat the cat"))
# 5  (the, cat, sat, on, mat)
07

Допустимые символы

#
Напишите функцию `has_only_valid(s, allowed)`, которая возвращает `True`, если каждый символ строки `s` содержится в строке `allowed`. Пример: `has_only_valid("hello", "aehllo")` → `True`, `has_only_valid("hello!", "aehllo")` → `False`. Используйте операции над множествами.
def has_only_valid(s, allowed):
    pass


print(has_only_valid("hello", "aehllo"))    # True
print(has_only_valid("hello!", "aehllo"))   # False
Решение 
def has_only_valid(s, allowed):
    return set(s) <= set(allowed)


print(has_only_valid("hello", "aehllo"))    # True
print(has_only_valid("hello!", "aehllo"))   # False
08

Set Comprehension

#
Напишите функцию `vowel_set(text)`, которая возвращает множество всех уникальных гласных (a, e, i, o, u), встречающихся в `text` (без учёта регистра). Используйте set comprehension. Пример: `vowel_set("Hello World")` → `{"e", "o"}`.
def vowel_set(text):
    pass


print(vowel_set("Hello World"))   # {"e", "o"}
print(vowel_set("Python"))        # {"o"}
Решение 
def vowel_set(text):
    vowels = "aeiou"
    return {ch for ch in text.lower() if ch in vowels}


print(vowel_set("Hello World"))   # {"e", "o"}
print(vowel_set("Python"))        # {"o"}
09

Диаграмма Венна

#
Студенты могут записаться в Клуб A, Клуб B или оба. Из двух множеств `club_a` и `club_b` с именами студентов напишите функцию `venn(club_a, club_b)`, которая возвращает словарь с тремя ключами: `"only_a"` (только в A), `"only_b"` (только в B), `"both"` (в обоих). Пример: `venn({"Alice", "Bob", "Carol"}, {"Bob", "Carol", "David"})` → `{"only_a": {"Alice"}, "only_b": {"David"}, "both": {"Bob", "Carol"}}`.
def venn(club_a, club_b):
    pass


result = venn({"Alice", "Bob", "Carol"}, {"Bob", "Carol", "David"})
print(result["only_a"])   # {"Alice"}
print(result["only_b"])   # {"David"}
print(result["both"])     # {"Bob", "Carol"}
Решение 
def venn(club_a, club_b):
    return {
        "only_a": club_a - club_b,
        "only_b": club_b - club_a,
        "both":   club_a & club_b,
    }


result = venn({"Alice", "Bob", "Carol"}, {"Bob", "Carol", "David"})
print(result["only_a"])   # {"Alice"}
print(result["only_b"])   # {"David"}
print(result["both"])     # {"Bob", "Carol"}
10

Общее для всех множеств

#
Напишите функцию `common_all(*lists)`, которая возвращает множество элементов, присутствующих ВО ВСЕХ переданных списках. Пример: `common_all([1, 2, 3], [2, 3, 4], [2, 3, 5])` → `{2, 3}`. Обработайте случай когда списков не передано (вернуть пустое множество).
def common_all(*lists):
    pass


print(common_all([1, 2, 3], [2, 3, 4], [2, 3, 5]))   # {2, 3}
print(common_all([1, 2], [3, 4]))                     # set()
print(common_all())                                   # set()
Решение 
def common_all(*lists):
    if not lists:
        return set()
    result = set(lists[0])
    for lst in lists[1:]:
        result &= set(lst)
    return result


print(common_all([1, 2, 3], [2, 3, 4], [2, 3, 5]))   # {2, 3}
print(common_all([1, 2], [3, 4]))                     # set()
print(common_all())                                   # set()