Множества (sets) в Python

Введение

Примеры

  • 5

    Получить уникальные элементы списка

    Допустим, у вас есть список ресторанов - может быть, вы читаете его из файла. Вы заботитесь об уникальных ресторанах в списке. Лучший способ получить уникальные элементы из списка - превратить его в набор:

     restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
    unique_restaurants = set(restaurants)
    print(unique_restaurants)
    # prints {'Chicken Chicken', "McDonald's", 'Burger King'}
    
     

    Обратите внимание, что набор не в том же порядке, что и исходный список; это потому , что множества являются неупорядоченными, так же , как dict с.

    Это может быть легко преобразован обратно в List с Python встроенный в list функций, что дает еще один список , который тот же список , как оригинал , но без дубликатов:

     list(unique_restaurants)
    # ['Chicken Chicken', "McDonald's", 'Burger King']
    
     

    Также принято видеть это одной строкой:

     # Removes all duplicates and returns another list
    list(set(restaurants))
    
     

    Теперь любые операции, которые могут быть выполнены в исходном списке, могут быть выполнены снова.

  • 11

    Операции на множествах

    с другими наборами

     # Intersection    
    {1, 2, 3, 4, 5}.intersection({3, 4, 5, 6})  # {3, 4, 5}
    {1, 2, 3, 4, 5} & {3, 4, 5, 6}              # {3, 4, 5}
    
    # Union
    {1, 2, 3, 4, 5}.union({3, 4, 5, 6})  # {1, 2, 3, 4, 5, 6}
    {1, 2, 3, 4, 5} | {3, 4, 5, 6}       # {1, 2, 3, 4, 5, 6}
    
    # Difference
    {1, 2, 3, 4}.difference({2, 3, 5})  # {1, 4}
    {1, 2, 3, 4} - {2, 3, 5}            # {1, 4}
    
    # Symmetric difference with
    {1, 2, 3, 4}.symmetric_difference({2, 3, 5})  # {1, 4, 5}
    {1, 2, 3, 4} ^ {2, 3, 5}                      # {1, 4, 5}
    
    # Superset check
    {1, 2}.issuperset({1, 2, 3})  # False
    {1, 2} >= {1, 2, 3}           # False
    
    # Subset check
    {1, 2}.issubset({1, 2, 3})  # True
    {1, 2} <= {1, 2, 3}         # True
    
    # Disjoint check
    {1, 2}.isdisjoint({3, 4})  # True
    {1, 2}.isdisjoint({1, 4})  # False
    
     

    с отдельными элементами

     # Existence check
    2 in {1,2,3}      # True
    4 in {1,2,3}      # False
    4 not in {1,2,3}  # True
    
    # Add and Remove
    s = {1,2,3}
    s.add(4)        # s == {1,2,3,4}
    
    s.discard(3)    # s == {1,2,4}
    s.discard(5)    # s == {1,2,4}
    
    s.remove(2)     # s == {1,4}
    s.remove(2)     # KeyError!
     

    Операции множества возвращают новые множества, но имеют соответствующие версии на месте:

    метод операция на месте метод на месте
    союз s | = t Обновить
    пересечение s & = t intersection_update
    разница s - = t difference_update
    symmetric_difference с ^ = т symmetric_difference_update

    Например:

     s = {1, 2}
    s.update({3, 4})   # s == {1, 2, 3, 4} 
  • 0

    Наборы против мультимножеств

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

    Рассмотрим этот пример:

     >>> setA = {'a','b','b','c'}
    >>> setA
    set(['a', 'c', 'b'])
    
     

    При сохранении строки 'a' , 'b' , 'b' , 'c' в структуру набора данных , мы потеряли информацию о том , что 'b' происходит дважды. Конечно, сохранение элементов в списке сохранит эту информацию

     >>> listA = ['a','b','b','c']
    >>> listA
    ['a', 'b', 'b', 'c']
    
     

    но структура данных списка вводит дополнительный ненужный порядок, который замедляет наши вычисления.

    Для реализации мультинаборы Python предоставляет Counter класса из collections модуля (начиная с версии 2.7):

    >>> из коллекции импортов Counter >>> counterA = Counter (['a', 'b', 'b', 'c']) >>> CounterA Counter ({'b': 2, 'a': 1 , 'c': 1})

    Counter представляет собой словарь , где где элементы хранятся в виде ключей словаря и их счетчики хранятся в виде значений словаря. И, как и все словари, это неупорядоченная коллекция.

  • 3

    Операции над множествами с использованием методов и встроенных функций

    Определим два множества a и b

     >>> a = {1, 2, 2, 3, 4}
    >>> b = {3, 3, 4, 4, 5} 

    Примечание: {1} создает набор из одного элемента, а {} создает пустой dict . Правильный способ для создания пустого набора будет set() .

    пересечение

    a.intersection(b) возвращает новый набор с элементами , присутствующими в обеих a и b

     >>> a.intersection(b)
    {3, 4} 

    союз

    a.union(b) возвращает новый набор с элементами , присутствующими в любом a и b

     >>> a.union(b)
    {1, 2, 3, 4, 5} 

    разница

    a.difference(b) возвращает новый набор с элементами , присутствующими в , но не в a b

     >>> a.difference(b)
    {1, 2}
    >>> b.difference(a)
    {5} 

    Симметричная разница

    a.symmetric_difference(b) возвращает новый набор с элементами , присутствующими в любом a или b , но не в обеих

     >>> a.symmetric_difference(b)
    {1, 2, 5}
    >>> b.symmetric_difference(a)
    {1, 2, 5} 

    Примечание: a.symmetric_difference(b) == b.symmetric_difference(a)

    Подмножество и суперсет

    c.issubset(a) проверяет , соответствует ли каждый элемент c в . a

    a.issuperset(c) проверяет , является ли каждый элемент c находится в . a

     >>> c = {1, 2}
    >>> c.issubset(a)
    True
    >>> a.issuperset(c)
    True 

    Последние операции имеют эквивалентные операторы, как показано ниже:

    метод оператор
    a.intersection(b) a & b
    a.union(b) | b
    a.difference(b) a - b
    a.symmetric_difference(b) a ^ b
    a.issubset(b) a <= b
    a.issuperset(b) a >= b

    Несвязные множества

    Наборы и a d не пересекаются , если ни один элемент в не находится также в a d , и наоборот.

     >>> d = {5, 6}
    >>> a.isdisjoint(b) # {2, 3, 4} are in both sets
    False
    >>> a.isdisjoint(d)
    True
    
    # This is an equivalent check, but less efficient
    >>> len(a & d) == 0
    True
    
    # This is even less efficient
    >>> a & d == set()
    True 

    Тестирование членства

    Встроенный in поисках ключевых слов для появлений

     >>> 1 in a
    True
    >>> 6 in a
    False 

    длина

    Встроенный len() функция возвращает количество элементов в наборе

     >>> len(a)
    4
    >>> len(b)
    3 
  • 4

    Набор Наборов

     {{1,2}, {3,4}}
    
     

    приводит к:

     TypeError: unhashable type: 'set'
    
     

    Вместо этого используйте frozenset :

     {frozenset({1, 2}), frozenset({3, 4})} 

Синтаксис

Параметры

Примечания