Cater Waiter

집합은 변경 가능하고 순서가 없는 해시 가능한 객체들의 컬렉션이에요. 집합의 원소는 서로 달라야 해요. 중복된 항목은 허용되지 않아요. 여러 가지 서로 다른 데이터 타입은 물론, tuple의 tuples처럼 중첩된 구조까지 담을 수 있어요. 단, 모든 원소가 _해시 가능_해야 해요. 집합에는 변경할 수 없는 frozensets 형태도 있어요.

집합은 다른 데이터 구조나 항목 그룹에서 중복을 빠르게 제거할 때 가장 흔히 사용해요. 순서 지정과 중복 추적이 필요하지 않을 때는 효율적으로 비교하는 데에도 사용해요.

다른 컬렉션 타입(딕셔너리, 배열, 튜플)처럼 sets은 다음을 지원해요:

• for item in <set>를 통한 반복
• in과 not in을 통한 멤버십 확인
• len()을 통한 길이 계산
• copy()를 통한 얕은 복사

sets은 다음을 지원하지 않아요:

• 어떤 종류의 인덱싱
• 정렬이나 삽입을 통한 순서 지정
• 슬라이싱
• +를 통한 연결

set에서 멤버십을 확인하는 것은 평균적으로 상수 시간 복잡도를 가져요. 반면 list나 string에서 멤버십을 확인하는 경우에는 데이터 길이가 길어질수록 시간 복잡도도 커져요. <set>.union(), <set>.intersection(), <set>.difference() 같은 메서드도 평균적으로 상수 시간 복잡도를 가져요.

집합 리터럴

set은 중괄호 {}와 원소 사이의 쉼표를 사용해 _집합 리터럴_로 직접 입력할 수 있어요. 중복은 조용히 생략돼요:

>>> one_element = {'➕'}
{'➕'}

>>> multiple_elements = {'➕', '🔻', '🔹', '🔆'}
{'➕', '🔻', '🔹', '🔆'}

>>> multiple_duplicates =  {'Hello!', 'Hello!', 'Hello!', 
                            '¡Hola!','Привіт!', 'こんにちは！', 
                            '¡Hola!','Привіт!', 'こんにちは！'}
{'こんにちは！', '¡Hola!', 'Hello!', 'Привіт!'}

집합 리터럴은 dict 리터럴과 같은 중괄호를 사용해요. 따라서 빈 set을 만들려면 set()을 사용해야 해요.

집합 생성자

set()(즉 set 클래스의 생성자)은 인자로 전달된 모든 iterable과 함께 사용할 수 있어요. iterable의 원소들은 하나씩 순회하면서 set에 개별적으로 추가돼요. 원소 순서는 유지되지 않고 중복은 조용히 생략돼요:

# To create an empty set, the constructor must be used.
>>> no_elements = set()
set()

# The tuple is unpacked & each element is added.  
# Duplicates are removed.
>>> elements_from_tuple = set(("Parrot", "Bird", 
                               334782, "Bird", "Parrot"))
{334782, 'Bird', 'Parrot'}

# The list is unpacked & each element is added.
# Duplicates are removed.
>>> elements_from_list = set([2, 3, 2, 3, 3, 3, 5, 
                              7, 11, 7, 11, 13, 13])
{2, 3, 5, 7, 11, 13}

집합을 만들 때 주의할 점

"언패킹" 동작 때문에 set()에 문자열을 사용하면 놀랄 수 있어요:

# String elements (Unicode code points) are 
# iterated through and added *individually*.
>>> elements_string = set("Timbuktu")
{'T', 'b', 'i', 'k', 'm', 't', 'u'}

# Unicode separators and positioning code points 
# are also added *individually*.
>>> multiple_code_points_string = set('अभ्यास')
{'अ', 'भ', 'य', 'स', 'ा', '्'}

집합은 서로 다른 데이터 타입과 중첩된 데이터 타입을 담을 수 있지만, 모든 set 원소는 _해시 가능_해야 해요:

# Attempting to use a list for a set member throws a TypeError
>>> lists_as_elements = {['🌈','💦'], 
                        ['☁️','⭐️','🌍'], 
                        ['⛵️', '🚲', '🚀']}

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'


# Standard sets are mutable, so they cannot be hashed.
>>> sets_as_elements = {{'🌈','💦'}, 
                        {'☁️','⭐️','🌍'}, 
                        {'⛵️', '🚲', '🚀'}}

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'

집합 다루기

집합에는 일반적으로 수학적 집합 연산을 흉내 내는 메서드들이 있어요. 이런 메서드 대부분(전부는 아니에요)에는 연산자 형태가 있어요. 메서드는 보통 모든 iterable을 인자로 받지만, 연산자는 연산 양쪽이 모두 set이나 frozensets이어야 해요.

서로소 집합

<set>.isdisjoint(<other_collection>) 메서드는 한 set의 원소가 다른 set의 원소와 겹치는지 확인할 때 사용해요. 이 메서드는 모든 iterable이나 set을 인자로 받아요. 두 집합이 공통 원소를 하나도 가지지 않으면 True를, 원소를 공유하면 False를 반환해요. 이에 해당하는 연산자 형태는 없어요:

# Both mammals and additional_animals are lists.
>>> mammals = ['squirrel','dog','cat','cow', 'tiger', 'elephant']
>>> additional_animals = ['pangolin', 'panda', 'parrot', 
                          'lemur', 'tiger', 'pangolin']

# Animals is a dict.
>>> animals = {'chicken': 'white',
               'sparrow': 'grey',
               'eagle': 'brown and white',
               'albatross': 'grey and white',
               'crow': 'black',
               'elephant': 'grey', 
               'dog': 'rust',
               'cow': 'black and white',
               'tiger': 'orange and black',
               'cat': 'grey',
               'squirrel': 'black'}
               
# Birds is a set.
>>> birds = {'crow','sparrow','eagle','chicken', 'albatross'}

# Mammals and birds don't share any elements.
>>> birds.isdisjoint(mammals)
True

# There are also no shared elements between 
# additional_animals and birds.
>>> birds.isdisjoint(additional_animals)
True

# Animals and mammals have shared elements.
# **Note** The first object needs to be a set or converted to a set
# since .isdisjoint() is a set method.
>>> set(animals).isdisjoint(mammals)
False

부분집합과 상위집합

<set>.issubset(<other_collection>)는 <set>의 모든 원소가 <other_collection>에도 있는지 확인할 때 사용해요. 연산자 형태는 <set> <= <other_set>이에요:

# Both mammals and additional_animals are lists.
>>> mammals = ['squirrel','dog','cat','cow', 'tiger', 'elephant']
>>> additional_animals = ['pangolin', 'panda', 'parrot', 
                          'lemur', 'tiger', 'pangolin']

# Animals is a dict.
>>> animals = {'chicken': 'white',
               'sparrow': 'grey',
               'eagle': 'brown and white',
               'albatross': 'grey and white',
               'crow': 'black',
               'elephant': 'grey', 
               'dog': 'rust',
               'cow': 'black and white',
               'tiger': 'orange and black',
               'cat': 'grey',
               'squirrel': 'black'}

# Birds is a set.
>>> birds = {'crow','sparrow','eagle','chicken', 'albatross'}

# Set methods will take any iterable as an argument.
# All members of birds are also members of animals.
>>> birds.issubset(animals)
True

# All members of mammals also appear in animals.
# **Note** The first object needs to be a set or converted to a set
# since .issubset() is a set method.
>>> set(mammals).issubset(animals)
True

# Both objects need to be sets to use a set operator
>>> birds <= set(mammals)
False

# A set is always a loose subset of itself.
>>> set(additional_animals) <= set(additional_animals)
True

<set>.issuperset(<other_collection>)는 .issubset()의 반대예요. <other_collection>의 모든 원소가 <set>에도 있는지 확인할 때 사용해요. 연산자 형태는 <set> >= <other_set>이에요:

# All members of mammals also appear in animals.
# **Note** The first object needs to be a set or converted to a set
# since .issuperset() is a set method.
>>> set(animals).issuperset(mammals)
True

# All members of animals do not show up as members of birds.
>>> birds.issuperset(animals)
False

# Both objects need to be sets to use a set operator
>>> birds >= set(mammals)
False

# A set is always a loose superset of itself.
>>> set(animals) >= set(animals)
True

집합의 교집합

<set>.intersection(*<other iterables>)는 원래 set과 모든 <others>에 공통으로 있는 원소로 이루어진 새 set을 반환해요(즉, 모든 것이 교차하는 set이에요). 이 메서드의 연산자 버전은 <set> & <other set> & <other set 2> & ... <other set n>이에요:

>>> perennials = {'Annatto','Asafetida','Asparagus','Azalea',
                 'Winter Savory', 'Broccoli','Curry Leaf','Fennel', 
                 'Kaffir Lime','Kale','Lavender','Mint','Oranges',
                 'Oregano', 'Tarragon', 'Wild Bergamot'}

>>> annuals = {'Corn', 'Zucchini', 'Sweet Peas', 'Marjoram', 
              'Summer Squash', 'Okra','Shallots', 'Basil', 
              'Cilantro', 'Cumin', 'Sunflower', 'Chervil', 
              'Summer Savory'}

>>> herbs = ['Annatto','Asafetida','Basil','Chervil','Cilantro',
            'Curry Leaf','Fennel','Kaffir Lime','Lavender',
            'Marjoram','Mint','Oregano','Summer Savory', 
            'Tarragon','Wild Bergamot','Wild Celery',
            'Winter Savory']


# Methods will take any iterable as an argument.
>>> perennial_herbs = perennials.intersection(herbs)
{'Annatto', 'Asafetida', 'Curry Leaf', 'Fennel', 'Kaffir Lime',
 'Lavender', 'Mint', 'Oregano', 'Wild Bergamot','Winter Savory'}

# Operators require both groups be sets.
>>> annuals & set(herbs)
 {'Basil', 'Chervil', 'Marjoram', 'Cilantro'}

집합의 합집합

<set>.union(*<other iterables>)는 <set>과 모든 <other iterables>의 원소로 이루어진 새 set을 반환해요. 이 메서드의 연산자 형태는 <set> | <other set 1> | <other set 2> | ... | <other set n>이에요:

>>> perennials = {'Asparagus', 'Broccoli', 'Sweet Potato', 'Kale'}
>>> annuals = {'Corn', 'Zucchini', 'Sweet Peas', 'Summer Squash'}
>>> more_perennials = ['Radicchio', 'Rhubarb', 
                      'Spinach', 'Watercress']

# Methods will take any iterable as an argument.
>>> perennials.union(more_perennials)
{'Asparagus','Broccoli','Kale','Radicchio','Rhubarb',
'Spinach','Sweet Potato','Watercress'}

# Operators require sets.
>>> set(more_perennials) | perennials
{'Asparagus',
 'Broccoli',
 'Kale',
 'Radicchio',
 'Rhubarb',
 'Spinach',
 'Sweet Potato',
 'Watercress'}

집합의 차집합

<set>.difference(*<other iterables>)는 원래 <set>에 있지만 <others>에는 없는 원소로 이루어진 새 set을 반환해요. 이 메서드의 연산자 버전은 <set> - <other set 1> - <other set 2> - ...<other set n>이에요.

>>> berries_and_veggies = {'Asparagus', 
                          'Broccoli', 
                          'Watercress', 
                          'Goji Berries', 
                          'Goose Berries', 
                          'Ramps', 
                          'Walking Onions', 
                          'Blackberries', 
                          'Strawberries', 
                          'Rhubarb', 
                          'Kale', 
                          'Artichokes', 
                          'Currants'}

>>> veggies = ('Asparagus', 'Broccoli', 'Watercress', 'Ramps',
               'Walking Onions', 'Rhubarb', 'Kale', 'Artichokes')

# Methods will take any iterable as an argument.
>>> berries = berries_and_veggies.difference(veggies)
{'Blackberries','Currants','Goji Berries',
 'Goose Berries', 'Strawberries'}

# Operators require sets.
>>> berries_and_veggies - berries
{'Artichokes','Asparagus','Broccoli','Kale',
'Ramps','Rhubarb','Walking Onions','Watercress'}

<set>.symmetric_difference(<other iterable>)는 <set> 또는 <other>에 있지만 둘 다에는 없는 원소를 담은 새 set을 반환해요. 이 메서드의 연산자 버전은 <set> ^ <other set>이에요:

>>> plants_1 = {'🌲','🍈','🌵', '🥑','🌴', '🥭'}
>>> plants_2 = ('🌸','🌴', '🌺', '🌲', '🌻', '🌵')


# Methods will take any iterable as an argument.
>>> fruit_and_flowers = plants_1.symmetric_difference(plants_2)
>>> fruit_and_flowers
{'🌸', '🌺', '🍈', '🥑', '🥭','🌻' }


# Operators require both groups be sets.
>>> fruit_and_flowers ^ plants_1
{'🌲',  '🌸', '🌴', '🌵','🌺', '🌻'}

>>> fruit_and_flowers ^ set(plants_2)
{'🥭', '🌴', '🌵', '🍈', '🌲', '🥑'}

>>> one = {'black pepper','breadcrumbs','celeriac','chickpea flour',
           'flour','lemon','parsley','salt','soy sauce',
           'sunflower oil','water'}

>>> two = {'black pepper','cornstarch','garlic','ginger',
           'lemon juice','lemon zest','salt','soy sauce','sugar',
           'tofu','vegetable oil','vegetable stock','water'}

>>> three = {'black pepper','garlic','lemon juice','mixed herbs',
             'nutritional yeast', 'olive oil','salt','silken tofu',
             'smoked tofu','soy sauce','spaghetti','turmeric'}

>>> four = {'barley malt','bell pepper','cashews','flour',
            'fresh basil','garlic','garlic powder', 'honey',
            'mushrooms','nutritional yeast','olive oil','oregano',
            'red onion', 'red pepper flakes','rosemary','salt',
            'sugar','tomatoes','water','yeast'}

>>> intersections = (one & two | one & three | one & four | 
                     two & three | two & four | three & four)
...
{'black pepper','flour','garlic','lemon juice','nutritional yeast', 
'olive oil','salt','soy sauce', 'sugar','water'}

# The ^ operation will include some of the items in intersections, 
# which means it is not a "clean" symmetric difference - there
# are overlapping members.
>>> (one ^ two ^ three ^ four) & intersections
{'black pepper', 'garlic', 'soy sauce', 'water'}

# Overlapping members need to be removed in a separate step
# when there are more than two sets that need symmetric difference.
>>> (one ^ two ^ three ^ four) - intersections
...
{'barley malt','bell pepper','breadcrumbs', 'cashews','celeriac',
  'chickpea flour','cornstarch','fresh basil', 'garlic powder',
  'ginger','honey','lemon','lemon zest','mixed herbs','mushrooms',
  'oregano','parsley','red onion','red pepper flakes','rosemary',
  'silken tofu','smoked tofu','spaghetti','sunflower oil', 'tofu', 
  'tomatoes','turmeric','vegetable oil','vegetable stock','yeast'}