Python基礎講座 #11 セット (Set)

>>> set_1 = set([1, 2, 3])
>>> print(set_1)
{1, 2, 3}
>>> print(type(set_1))
<class 'set'>

>>> set_2 = set((1, 2, 3))
>>> print(set_2)
{1, 2, 3}
>>> print(type(set_2))
<class 'set'>

>>> set_3 = set('string')
>>> print(set_3)
{'s', 't', 'n', 'r', 'i', 'g'}
>>> print(type(set_3))
<class 'set'>
>>> set_4 = set(range(10))
>>> print(set_4)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> print(type(set_4))
<class 'set'>

>>> set_5 = set()
>>> print(set_5)
set()
>>> print(type(set_5))
<class 'set'>

>>> set(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: set expected at most 1 argument, got 3

>>> set(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

>>> set_6 = {1, 2, 3}
>>> print(set_6)
{1, 2, 3}
>>> print(type(set_6))
<class 'set'>

>>> var = {}
>>> print(var)
{}
>>> print(type(var))
<class 'dict'>

>>> my_set = {'one', 'two', 'three'}
>>> my_set
{'three', 'one', 'two'}

>>> my_set.add('four')
>>> my_set
{'four', 'three', 'one', 'two'}

>>> my_set[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable

>>> my_set = {1, 2, 2, 3}
>>> my_set
{1, 2, 3}

>>> my_set.add(1)
>>> my_set
{1, 2, 3}

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

>>> {[1, 2, 3], [2, 3, 4]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

>>> help(set)
Help on class set in module builtins:

class set(object)
|  set() -> new empty set object
|  set(iterable) -> new set object
|
|  Build an unordered collection of unique elements.
|
|  Methods defined here:
|
|  __and__(self, value, /)
|      Return self&value.
|
|  __contains__(...)
|      x.__contains__(y) <==> y in x.
|
|  __eq__(self, value, /)
|      Return self==value.
|
|  __ge__(self, value, /)
|      Return self>=value.
|
|  __getattribute__(self, name, /)
|      Return getattr(self, name).
|
|  __gt__(self, value, /)
|      Return self>value.
|
|  __iand__(self, value, /)
|      Return self&=value.
|
|  __init__(self, /, *args, **kwargs)
|      Initialize self.  See help(type(self)) for accurate signature.
|
|  __ior__(self, value, /)
|      Return self|=value.
|
|  __isub__(self, value, /)
|      Return self-=value.
|
|  __iter__(self, /)
|      Implement iter(self).
|
|  __ixor__(self, value, /)
|      Return self^=value.
|
|  __le__(self, value, /)
|      Return self<=value.
|
|  __len__(self, /)
|      Return len(self).
|
|  __lt__(self, value, /)
|      Return self<value.
|
|  __ne__(self, value, /)
|      Return self!=value.
|
|  __or__(self, value, /)
|      Return self|value.
|
|  __rand__(self, value, /)
|      Return value&self.
|
|  __reduce__(...)
|      Return state information for pickling.
|
|  __repr__(self, /)
|      Return repr(self).
|
|  __ror__(self, value, /)
|      Return value|self.
|
|  __rsub__(self, value, /)
|      Return value-self.
|
|  __rxor__(self, value, /)
|      Return value^self.
|
|  __sizeof__(...)
|      S.__sizeof__() -> size of S in memory, in bytes
|
|  __sub__(self, value, /)
|      Return self-value.
|
|  __xor__(self, value, /)
|      Return self^value.
|
|  add(...)
|      Add an element to a set.
|
|      This has no effect if the element is already present.
|
|  clear(...)
|      Remove all elements from this set.
|
|  copy(...)
|      Return a shallow copy of a set.
|
|  difference(...)
|      Return the difference of two or more sets as a new set.
|
|      (i.e. all elements that are in this set but not the others.)
|
|  difference_update(...)
|      Remove all elements of another set from this set.
|
|  discard(...)
|      Remove an element from a set if it is a member.
|
|      If the element is not a member, do nothing.
|
|  intersection(...)
|      Return the intersection of two sets as a new set.
|
|      (i.e. all elements that are in both sets.)
|
|  intersection_update(...)
|      Update a set with the intersection of itself and another.
|
|  isdisjoint(...)
|      Return True if two sets have a null intersection.
|
|  issubset(...)
|      Report whether another set contains this set.
|
|  issuperset(...)
|      Report whether this set contains another set.
|
|  pop(...)
|      Remove and return an arbitrary set element.
|      Raises KeyError if the set is empty.
|
|  remove(...)
|      Remove an element from a set; it must be a member.
|
|      If the element is not a member, raise a KeyError.
|
|  symmetric_difference(...)
|      Return the symmetric difference of two sets as a new set.
|
|      (i.e. all elements that are in exactly one of the sets.)
|
|  symmetric_difference_update(...)
|      Update a set with the symmetric difference of itself and another.
|
|  union(...)
|      Return the union of sets as a new set.
|
|      (i.e. all elements that are in either set.)
|
|  update(...)
|      Update a set with the union of itself and others.
|
|  ----------------------------------------------------------------------
|  Class methods defined here:
|
|  __class_getitem__(...) from builtins.type
|      See PEP 585
|
|  ----------------------------------------------------------------------
|  Static methods defined here:
|
|  __new__(*args, **kwargs) from builtins.type
|      Create and return a new object.  See help(type) for accurate signature.
|
|  ----------------------------------------------------------------------
|  Data and other attributes defined here:
|
|  __hash__ = None

>>> help(set.add)
Help on method_descriptor:

add(...)
Add an element to a set.

This has no effect if the element is already present.

>>> myset = set()
>>> print(myset)
set()
>>>
>>> myset.add(1)
>>> print(myset)
{1}
>>>
>>> myset.add(2)
>>> print(myset)
{1, 2}

>>> help(set.pop)
Help on method_descriptor:

pop(...)
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.

>>> myset.pop()
1
>>> print(myset)
{2}

>>> myset.pop()
2
>>> print(myset)
set()

>>> myset.pop()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'

>>> help(set.remove)
Help on method_descriptor:

remove(...)
Remove an element from a set; it must be a member.

    If the element is not a member, raise a KeyError.

>>> myset = {1, 2, 3}
>>> myset.remove(1)
>>> print(myset)
{2, 3}

>>> myset.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4

>>> help(set.union)
Help on method_descriptor:

union(...)
Return the union of sets as a new set.

    (i.e. all elements that are in either set.)

>>> set_1 = {1, 2, 3}
>>> set_2 = {3, 4, 5}

>>> set_1.union(set_2)
{1, 2, 3, 4, 5}

>>> set_1.intersection(set_2)
{3}

>>> set_1.difference(set_2)
{1, 2}