set

기본 제공 세트 유형입니다. 세트는 변경 가능하고 반복 가능한 고유 값의 컬렉션(세트의 요소)입니다. 세트의 유형 이름은 "set"입니다.

세트는 값을 삽입, 삭제 또는 값의 존재 여부를 확인하는 데 일정한 시간 작업을 제공합니다. 세트는 해시 테이블을 사용하여 구현되므로 사전의 키와 마찬가지로 세트의 요소는 해시 가능해야 합니다. 값은 사전의 키로 사용할 수 있는 경우에만 집합의 요소로 사용할 수 있습니다.

집합은 set() 내장 함수를 사용하여 구성할 수 있습니다. 이 함수는 반복 가능해야 하는 선택적 인수의 고유 요소를 포함하는 새 집합을 반환합니다. 인수 없이 set()을 호출하면 빈 집합이 생성됩니다. 집합에는 리터럴 문법이 없습니다.

in 및 not in 작업은 값이 집합에 있는지 (또는 없는지) 확인합니다.

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

집합은 반복 가능하므로 for 루프, 목록 내포, 반복 가능 항목에서 작동하는 다양한 기본 제공 함수의 피연산자로 사용할 수 있습니다. 길이는 len() 기본 제공 함수를 사용하여 가져올 수 있으며, 반복 순서는 요소가 집합에 처음 추가된 순서입니다.

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

불리언 컨텍스트에서 사용되는 집합은 비어 있지 않은 경우에만 true입니다.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

== 및 !=을 사용하여 집합의 동등성 또는 부등성을 비교할 수 있습니다. s 집합은 t이 동일한 요소를 포함하는 집합인 경우에만 t과 같습니다. 반복 순서는 중요하지 않습니다. 특히 집합은 요소 목록과 같지 않습니다. 집합은 다른 집합과 관련하여 정렬되지 않으며 <, <=, >, >=를 사용하여 두 집합을 비교하거나 집합 시퀀스를 정렬하려고 하면 실패합니다.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

두 집합에 대한 | 작업은 두 집합의 합집합을 반환합니다. 즉, 원래 집합 중 하나 또는 둘 모두에 있는 요소를 포함하는 집합을 반환합니다.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

두 집합에 대한 & 작업은 두 집합의 교집합을 반환합니다. 즉, 원래 집합 두 개 모두에 있는 요소만 포함하는 집합을 반환합니다.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

두 집합에 대한 - 연산자는 두 집합의 차이를 반환합니다. 즉, 왼쪽 집합에 있지만 오른쪽 집합에는 없는 요소를 포함하는 집합을 반환합니다.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])

두 집합에 대한 ^ 작업은 두 집합의 대칭 차이를 반환합니다. 즉, 원래 두 집합 중 정확히 하나에만 있고 둘 다에는 없는 요소를 포함하는 집합입니다.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

위의 각 작업에서 결과 집합의 요소는 두 피연산자 집합의 순서를 유지하며, 왼쪽에서 가져온 모든 요소는 오른쪽에만 있는 요소 앞에 정렬됩니다.

|=, &=, -=, ^=와 같은 해당 증강 할당은 왼쪽 집합을 제자리에서 수정합니다.

s = set([1, 2])
s |= set([2, 3, 4])     # s now equals set([1, 2, 3, 4])
s &= set([0, 1, 2, 3])  # s now equals set([1, 2, 3])
s -= set([0, 1])        # s now equals set([2, 3])
s ^= set([3, 4])        # s now equals set([2, 4])

Starlark의 모든 변경 가능한 값과 마찬가지로 집합은 고정될 수 있으며, 고정되면 집합을 업데이트하려고 시도하는 모든 후속 작업이 실패합니다.

회원

• 추가
• clear
• 차이
• difference_update
• discard
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• 삭제
• symmetric_difference
• symmetric_difference_update
• union
• 업데이트

추가

None set.add(element)

이미 집합에 있는 값을 add하는 것은 허용됩니다. 이렇게 하면 집합이 변경되지 않습니다.

세트에 여러 요소를 추가해야 하는 경우 update 또는 |= 증강 할당 작업을 참고하세요.

매개변수

지우기

None set.clear()

차이

set set.difference(*others)

s와 t가 집합인 경우 s.difference(t)는 s - t와 동일합니다. 하지만 - 작업에는 양쪽이 모두 집합이어야 하는 반면 difference 메서드는 시퀀스와 사전도 허용합니다.

인수 없이 difference를 호출할 수 있습니다. 이렇게 하면 집합의 사본이 반환됩니다.

예를 들면 다음과 같습니다.

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

매개변수

difference_update

None set.difference_update(*others)

s과 t이 집합인 경우 s.difference_update(t)은 s -= t과 동일합니다. 하지만 -= 증강 할당에는 양쪽 모두 집합이어야 하는 반면 difference_update 메서드는 시퀀스와 dict도 허용합니다.

인수 없이 difference_update를 호출할 수 있습니다. 이렇게 하면 집합이 변경되지 않습니다.

예를 들면 다음과 같습니다.

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

매개변수

삭제

None set.discard(element)

세트에 없는 값을 discard해도 됩니다. 이렇게 하면 세트가 변경되지 않습니다. 없는 요소를 삭제하려고 할 때 실패하려면 remove를 대신 사용하세요. 세트에서 여러 요소를 삭제해야 하는 경우 difference_update 또는 -= 증강 할당 작업을 참고하세요.

예를 들면 다음과 같습니다.

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

매개변수

교집합

set set.intersection(*others)

s와 t가 집합인 경우 s.intersection(t)는 s & t와 동일합니다. 하지만 & 작업에는 양쪽이 모두 집합이어야 하는 반면 intersection 메서드는 시퀀스와 사전도 허용합니다.

인수 없이 intersection를 호출할 수 있습니다. 이렇게 하면 집합의 사본이 반환됩니다.

예를 들면 다음과 같습니다.

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

매개변수

intersection_update

None set.intersection_update(*others)

s와 t가 집합인 경우 s.intersection_update(t)는 s &= t와 동일합니다. 하지만 &= 증강 할당에는 양쪽이 모두 집합이어야 하는 반면 intersection_update 메서드는 시퀀스와 dict도 허용합니다.

인수 없이 intersection_update를 호출할 수 있습니다. 이렇게 하면 집합이 변경되지 않습니다.

예를 들면 다음과 같습니다.

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

매개변수

isdisjoint

bool set.isdisjoint(other)

예를 들면 다음과 같습니다.

set([1, 2]).isdisjoint([3, 4])  # True
set().isdisjoint(set())         # True
set([1, 2]).isdisjoint([2, 3])  # False

매개변수

issubset

bool set.issubset(other)

집합은 항상 자체의 하위 집합으로 간주됩니다.

예를 들면 다음과 같습니다.

set([1, 2]).issubset([1, 2, 3])  # True
set([1, 2]).issubset([1, 2])     # True
set([1, 2]).issubset([2, 3])     # False

매개변수

issuperset

bool set.issuperset(other)

집합은 항상 자체의 상위 집합으로 간주됩니다.

예를 들면 다음과 같습니다.

set([1, 2, 3]).issuperset([1, 2])     # True
set([1, 2, 3]).issuperset([1, 2, 3])  # True
set([1, 2, 3]).issuperset([2, 3, 4])  # False

매개변수

팝

unknown set.pop()

세트가 비어 있으면 실패합니다.

예를 들면 다음과 같습니다.

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

삭제

None set.remove(element)

요소가 집합에 없으면 remove이 실패합니다. 없는 요소를 삭제하려고 할 때 실패하지 않으려면 discard를 대신 사용하세요. 세트에서 여러 요소를 삭제해야 하는 경우 difference_update 또는 -= 증강 할당 작업을 참고하세요.

매개변수

symmetric_difference

set set.symmetric_difference(other)

s와 t가 집합인 경우 s.symmetric_difference(t)는 s ^ t와 동일합니다. 하지만 ^ 작업에는 양쪽이 모두 집합이어야 하는 반면 symmetric_difference 메서드는 시퀀스나 사전도 허용합니다.

예를 들면 다음과 같습니다.

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

매개변수

symmetric_difference_update

None set.symmetric_difference_update(other)

s과 t이 집합인 경우 s.symmetric_difference_update(t)은 `s ^= t` 와 같습니다. ; however, note that the ^=증강 할당에는 양쪽이 모두 집합이어야 하지만 symmetric_difference_update 메서드는 시퀀스나 dict도 허용합니다.

예를 들면 다음과 같습니다.

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

매개변수

합집합

set set.union(*others)

s와 t가 집합인 경우 s.union(t)는 s | t와 동일합니다. 하지만 | 작업에는 양쪽이 모두 집합이어야 하는 반면 union 메서드는 시퀀스와 사전도 허용합니다.

인수 없이 union를 호출할 수 있습니다. 이렇게 하면 세트의 사본이 반환됩니다.

예를 들면 다음과 같습니다.

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

매개변수

update

None set.update(*others)

예를 들면 다음과 같습니다.

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

s와 t가 집합인 경우 s.update(t)는 s |= t와 동일합니다. 하지만 |= 증강 할당에는 양쪽 모두 집합이어야 하는 반면 update 메서드는 시퀀스와 dict도 허용합니다.

인수 없이 update를 호출할 수 있습니다. 이렇게 하면 집합이 변경되지 않습니다.

매개변수