Python - リスト・タプル・辞書・集合

リスト

Python には文字列以外にリストタプルの 2 種類のシーケンス構造があり、0 個以上の要素を持つことができます。リストは [, ] でデータを囲み、タプルは (, ) でデータを囲みます。

list = [1, 2, 3]
print(type(list))
# <class 'list'>

tuple = (1, 2, 3)
print(type(tuple))
# <class 'tuple'>
リストとタプル

それぞれの違いは、リストはデータがミュータブル (可変) であり、タプルはデータがイミュータブル (不変) になります。ミュータブルであるリストは、要素の挿入や削除を行うことができますが、イミュータブルであるタプルは要素の変更を伴う関数は使用できません。

リストで使用できる関数は以下のとおりです。

  • append
  • clear
  • copy
  • count
  • extend
  • index
  • insert
  • pop
  • remove
  • reverse
  • sort

タプルで使用できる関数は以下のとおりです。

  • count
  • index

上記のようにタプルは要素に対して変更や削除を行うための関数がありません。また、要素に対して直接変更を行う場合もエラーとなります。

list = [1, 2, 3]
list[0] = 4
print(list)
# [4, 2, 3]

tuple = (1, 2, 3)
tuple[0] = 4
print(tuple)
# 'tuple' object does not support item assignment
リストとタプル

リスト型への変換

文字列をリスト型に変換する方法は、以下のように行います。

>>> list('cat')
['c', 'a', 't']
文字列をリスト型に変換

split() 関数を使えば、任意のセパレータ文字列に対して分割することができます。

>>> birthday = '1982/07/01'
>>> birthday.split('/')
['1982', '07', '01']
文字列をリスト型に変換

ただし、文字列に複数のセパレータ文字列が連続している場合、リスト要素としては空文字が設定されます。

>>> splitme = 'a/b//c/d///e'
>>> splitme.split('/')
['a', 'b', '', 'c', 'd', '', '', 'e']
文字列をリスト型に変換

リスト要素の取り出し

オフセットを指定すればリストからも個々の要素を取り出すことができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[0]
'Groucho'
>>> marxes[1]
'Chico'
>>> marxes[2]
'Harpo'
オフセットを使った要素の取り出し

マイナスのインデックスを使えば末尾から逆に取り出すこともできます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[-1]
'Harpo'
>>> marxes[-2]
'Chico'
>>> marxes[-3]
'Groucho'
オフセットを使った要素の取り出し

スライスを使うと、リストのサブシーケンスを取り出すことができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[0:2]
['Groucho', 'Chico']
スライスを使った要素の取り出し

スライスは 1 以外のステップを指定することもできます。以下の例では、先頭から右にひとつおきに要素を取り出しています。

>>> marxes[::2]
['Groucho', 'Harpo']
スライスを使った要素の取り出し

次の例では、末尾から左にひとつおきに要素を取り出しています。

>>> marxes[::-2]
['Harpo', 'Groucho']
スライスを使った要素の取り出し

スライスを使ったテクニックで、リストの要素を逆順にすることもできます。

>>> marxes[::-1]
['Harpo', 'Chico', 'Groucho']
スライスを使った要素の取り出し

リスト要素の追加と削除

リストに要素を追加するための方法のひとつとして append() 関数があります。append() 関数を使うと、末尾に要素をひとつずつ追加することができます。

>>> marxes.append('Zeppo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']
append() 関数を使ったリスト要素の追加

extend() 関数を使うと、ふたつのリストをひとつにまとめることができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> others = ['Gummo', 'Karl']
>>> marxes.extend(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']
extend() 関数を使ったリスト要素の追加

このときに append() 関数を使うと、others の要素が追加されるのではなく、others が 1 個のリスト要素として追加されてしまいます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> others = ['Gummo', 'Karl']
>>> marxes.append(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', ['Gummo', 'Karl']]
append() 関数を使ったリスト要素の追加

append() 関数は、リストの末尾にしか要素を追加できません。リストのオフセットを指定し、その前に要素を追加したいときには、insert() 関数を使います。オフセット 0 を指定すると、リストの先頭に挿入されます。末尾、または末尾を越えるオフセットを指定すると、append() 関数と同じようにリストの末尾に挿入されます。

>>> marxes.insert(3, 'Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

>>> marxes.insert(10, 'Karl')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']
insert() 関数を使ったリスト要素の追加

要素を削除する場合は、del を使用します。要素を削除した場合、その後ろの要素は前に移動して削除された要素のスペースを埋め、リストの長さは 1 だけ小さくなります。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes[2]
'Harpo'

>>> del marxes[2]
>>> marxes
['Groucho', 'Chico', 'Gummo', 'Zeppo']

>>> marxes[2]
'Gummo'
del を使ったリスト要素の削除

削除したい要素がリストのどこにあるか分からない場合は、remove() 関数を使用します。remove() 関数は、値を指定して要素を削除することができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes.remove('Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']
remove() 関数を使ったリスト要素の削除

pop() 関数を使えば、リストから要素を取り出し、同時にリストからその要素を削除することができます。オフセットを指定して pop() 関数を呼び出すと、そのオフセットの要素が返されます。引数を指定しなければ、オフセットとして -1 が使われます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> marxes.pop()
'Zeppo'
>>> marxes
['Groucho', 'Chico', 'Harpo']
>>> marxes.pop(1)
'Chico'
>>> marxes
['Groucho', 'Harpo']
pop() 関数を使ったリスト要素の取り出し (取得と削除)

要素の値からその要素のリスト内でのオフセットを知りたい場合には、index() 関数を使います。もしも、リストに存在しない要素が指定された場合、ValueError が発生します。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> marxes.index('Chico')
1
index() 関数を使ったリスト要素のオフセット位置の確認

リスト内に要素があるかテストするには、in を使います。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> 'Groucho' in marxes
True
>>> 'Bob' in marxes
False
in を使ったリスト内に要素があるかのテスト

ただし、リスト内には複数の位置に同じ値が格納されている場合があります。in を使ったテストでは、少なくとも 1 つ以上の要素があれば Ture を返します。

>>> words = ['a', 'deer', 'a' 'female', 'deer']
>>> 'deer' in words
True
in を使ったリスト内に要素があるかのテスト

リスト要素の計算と変換

特定の値がリスト内にいくつ含まれているかを数えるには、count() 関数を使います。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes.count('Harpo')
1
>>> marxes.count('Bob')
0
count() 関数を使った値の個数の計算

文字列関数の join() 関数を使うことで文字列への変換を行うこともできます。join() 関数はリスト関数ではありませんが、引数にはイテラブルオブジェクトを指定できるため、以下のように実装できます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> ', '.join(marxes)
'Groucho, Chico, Harpo'
join() 関数を使った文字列への変換

リスト要素を値の順序で並べ替える場合は、sort() 関数、または sorted() 関数を使います。リスト関数の sort() 関数は、指定したリスト自体をソートします。汎用関数の sorted() 関数は、ソートされたリストのコピーを返します。リストの要素が数値ならデフォルトで数値の昇順でソートされ、要素が文字列なら、アルファベット順でソートされます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> sorted_marxes = sorted(marxes)
>>> sorted_marxes
['Chico', 'Groucho', 'Harpo']
>>> marxes
['Groucho', 'Chico', 'Harpo']
sorted() 関数を使ったリストの並び替え

sorted_marxes はコピーであり、これを作ってもオリジナルのリストは変更されません。しかし、marxes リストからリスト関数の sort() 関数を呼び出すと、marxes リスト自体が書き換えられます。

>>> marxes.sort()
>>> marxes
['Chico', 'Groucho', 'Harpo']
sort() 関数を使ったリストの並び替え

基本的に sort() 関数を使う場合は、リストの要素がすべて同じ型である必要があります。ただし、異なる型が混ざっていても正しく動作する場合があります。例えば、intfloat が同じリストに混在していても Python が自動的に変換できるため問題なく動作します。

>>> numbers = [2, 1, 4.0, 3]
>>> numbers.sort()
>>> numbers
[1, 2, 3, 4.0]
sort() 関数を使ったリストの並び替え

デフォルトのソート順は昇順ですが、引数として reverse=True を追加すれば降順になります。

>>> numbers = [2, 1, 4.0, 3]
>>> numbers.sort(reverse=True)
>>> numbers
[4.0, 3, 2, 1]
sort() 関数を使ったリストの並び替え

len() 関数は、リスト内の要素数を返す。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> len(marxes)
3
len() 関数を使ったリストの長さの取得

タプル

タプルは、リストと同様に任意の要素を集めたシーケンスオブジェクトです。ただし、リストとは異なりタプルはイミュータブル (不変) であり、タプルを定義した後では要素の追加、変更、削除はできません。そのため、タプルは定数リストとして扱うことができます。

タプルはリストと比べて関数がかなり少なく、countindex しかありません。タプルを利用するシーンとしては、以下のような場合があります。

  • タプルは、消費スペースが小さい。
  • タプルの要素は、誤って書き換える危険がない。
  • タプルは辞書のキーとして使える。
  • 名前付きタプルは、オブジェクトの単純な代用品として使える。
  • 関数の引数は、タプルとして渡される。

空のタプルは以下のように実装できます。

>>> empty_tuple = ()
>>> empty_tuple
()
空タプルの作成

1 個以上の要素を持つタプルは、個々の要素をカンマで区切ります。要素が 1 個のタプルも末尾にカンマを付けて作ります。

>>> one_marx = 'Groucho',
>>> one_marx
('Groucho',)
要素が 1 個のタプルの作成

要素が複数ある場合は、すべての要素の後ろにカンマを付けます。ただし、最後の要素の後ろのカンマは省略できます。

>>> marx_tuple = 'Groucho', 'Chico', 'Harpo'
>>> marx_tuple
('Groucho', 'Chico', 'Harpo')
要素が複数のタプルの作成

タプルを表示すると () が追加されますが、定義するときに () が必ずしも必要になるわけではありません。タプルを定義するために必要になるのは、値を区切る , です。しかし、() を使ってもエラーにはなりません。値全体を () で囲むと可読性が向上し、タプルだとわかりやすくなります。

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')
>>> marx_tuple
('Groucho', 'Chico', 'Harpo')
わかりやすいタプルの定義

タプルを使うと、一度に複数の変数を代入することができます。

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')
>>> a, b, c = marx_tuple
>>> a
'Groucho'
>>> b
'Chico'
>>> c
'Harpo'
タプルを使った変数の代入

tuple() 関数を使うと他の型からタプルを作ることができます。

>>> marx_list = ['Groucho', 'Chico', 'Harpo']
>>> tuple(marx_list)
('Groucho', 'Chico', 'Harpo')
tuple() 関数を使ったタプルの作成

辞書

辞書は、リストに似ていますが要素の順序が管理されていないため、要素を選択するときにはオフセットを使わず、個々の値に一意なキーを使います。他の言語では、辞書は連想配列、ハッシュ、ハッシュマップなどと呼ばれています。

辞書を作るには、key : value のペアを , で区切って並べ、{} で囲みます。もっとも単純な辞書は、キー/値ペアを持たない空辞書です。

>>> empty_dict = {}
>>> empty_dict
{}
空辞書の作成

key : value のペアは、以下のように書くことができます。対話型インタープリタで辞書の名前を入力すると、その中のキーと値がすべて表示されます。キーを指定すると、対応する値が取得できます。辞書に存在しないキーを指定すると KeyError が発生します。

>>> dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
>>> dict
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

>>> dict['key1']
value1
辞書の作成と取得

dict() 関数を使うと、ふたつの値のシーケンスを辞書に変換できます。ただし、辞書内のキーの順序は決まっておらず、要素を追加したときの順序とは異なる場合があるため注意が必要です。

>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]
>>> dict(lol)
{'c': 'd', 'a': 'b', 'e': 'f'}
dict() 関数を使った変換

dict() 関数の変換は、2 要素のシーケンスを含むものなら何でも変換できます。

# 2 要素のタプルのリスト
>>> lot = [ ('a', 'b'), ('c', 'd'), ('e', 'f') ]
>>> dict(lot)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 要素のリストのタプル
>>> tol = ( ['a', 'b'], ['c', 'd'], ['e', 'f'] )
>>> dict(tol)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 字の文字列のリスト
>>> los = [ 'ab', 'cd', 'ef' ]
>>> dict(los)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 文字の文字列のタプル
>>> tos = ( 'ab', 'cd', 'ef' )
>>> dict(tos)
{'c': 'd', 'a': 'b', 'e': 'f'}
dict() 関数を使った変換

要素の追加と変更

辞書に要素を追加するには、キーを使って要素を参照し、値を代入します。辞書にそのキーが既にある場合には、既存の値が新しい値に上書きされます。キーがまだ存在しない場合には、キーと値のペアが追加されます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict['key4'] = 'value4'
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
value1
辞書に要素を追加

辞書のキーは一意でなければなりません。既に存在しているキーを指定すると、既存の値が新しい値に上書きされます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict['key1'] = 'value10'
print(dict)
# {'key1': 'value10', 'key2': 'value2', 'key3': 'value3'}
辞書の要素を変更

キーを複数回使って定義した場合、最後に定義した値が辞書に残ります。下記は、key1 というキーにまず value1 という値を代入し、そこから value2value3 という順番で値を置き換えています。

dict = {
    'key1': 'value1', 
    'key1': 'value2', 
    'key1': 'value3'
    }
print(dict)
# {'key1': 'value3'}
辞書のキーが複数回定義された場合の動作

辞書を結合する: update()

update() 関数を使えば、辞書のキーと値を別の辞書にコピーすることができます。

dict1 = {
    'key1': 'value1', 
    'key2': 'value2'
    }
print(dict1)
# {'key1': 'value1', 'key2': 'value2'}

dict2 = {
    'key3': 'value3', 
    'key4': 'value4'
    }
print(dict2)
# {'key3': 'value3', 'key4': 'value4'}

dict1.update(dict2)
print(dict1)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
辞書の結合

] 1つ目の辞書と2つ目の辞書に同じキーが含まれている場合、2つ目の辞書の値が残ります。

dict1 = {
    'key1': 'value1', 
    'key2': 'value2'
    }
print(dict1)
# {'key1': 'value1', 'key2': 'value2'}

dict2 = {
    'key1': 'value10', 
    'key2': 'value20'
    }
print(dict2)
# {'key1': 'value10', 'key2': 'value20'}

dict1.update(dict2)
print(dict1)
# {'key1': 'value10', 'key2': 'value20'}
辞書の結合

要素を削除する: del, clear()

要素を削除するためには del を使用します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

del dict['key1']
print(dict)
# {'key2': 'value2', 'key3': 'value3'}
辞書の要素を削除

すべての要素を削除するためには clear() 関数を使用します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict.clear()
print(dict)
# {}
辞書の要素をすべて削除

要素を取得する

辞書にあるキーが含まれているか知りたい場合には in を使います。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print('key1' in dict)
# True
print('key4' in dict)
# False
辞書にキーが存在するかテストする

辞書から要素を取得するための一般的な方法はキーを指定して、対応する値を取り出します。もしも辞書に存在しないキーを指定した場合、KeyError が発生します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict['key1'])
# value1
キーを指定して対応する値を取り出す

KeyError を避けるための方法はふたつあります。ひとつは、事前に in を使ってキーが存在することを確認する方法です。もうひとつは、辞書専用の get() 関数を使う方法です。get() 関数では、キーとオプションを指定することができ、キーがなければ指定したオプションが返されます。オプションを指定しない場合、None が返されます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.get('key1', 'not exist in dict'))
# value1
    
print(dict.get('key4', 'not exist in dict'))
# not exist in dict
get() 関数を使用して要素を取り出す

keys() 関数を使えば、辞書のすべてのキーを取得できます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.keys())
# dict_keys(['key1', 'key2', 'key3'])
keys() 関数を使用してすべてのキーを取得する

values() 関数を使えば、辞書のすべての値を取得できます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.values())
# dict_values(['value1', 'value2', 'value3'])
values() 関数を使用してすべての値を取得する

辞書からすべてのキー/値のペアを取り出したい場合は、items() を使います。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.items())
# dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
items() 関数を使用してすべてのキー/値ペアを取得する

集合

集合は、キーだけの辞書のようなものです。辞書の場合と同様に、個々のキーは一意でなければなりません。集合は、和集合、交叉、差集合、対称差などの集合演算を行うことができます

集合の作成と変換

集合を作るには、set() 関数を使うか、1 個以上のカンマ区切りの値を {} で囲みます。辞書のキーと同様に、集合の要素には順序はありません。

empty_set = set()
print(empty_set)
# set()

even_numbers = {0, 2, 4, 6, 8}
print(even_numbers)
# {0, 8, 2, 4, 6}

odd_numbers = {1, 3, 5, 7, 9}
print(odd_numbers)
# {9, 3, 1, 5, 7}
集合の作成

リスト、文字列、タプル、辞書から重複する値を取り除けば集合を作ることができます。一部の文字が複数回登場する文字列、例えば 'letters' には 'e''t' がふたつずつ含まれていますが、集合にはひとつずつしか含まれていないことがわかります。

print(set('letters'))
# {'l', 'e', 't', 'r', 's'}
集合の作成

リストから集合を作る場合は以下のとおりになります。

print(set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] ))
# {'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}
集合の作成

タプルから集合を作る場合は以下のとおりになります。

print(set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') ))
# {'Ummagumma', 'Atom Heart Mother', 'Echoes'}
集合の作成

set() 関数に辞書を渡すと、キーだけが使われます。

print(set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} ))
# {'apple', 'cherry', 'orange'}
集合の作成

集合の要素数は組み込み関数 len() 関数で取得できます。

s = set('letters')
print(len(s))
# 5
集合の要素数

集合の追加と削除

集合に要素を追加するには、add() 関数を使います。

s = {0, 1, 2}
s.add(3)

print(s)
# {0, 1, 2, 3}
集合に要素を追加する

集合から要素を削除するには、discard(), remove(), pop(), clear() 関数を使います。

discard() 関数は引数に指定した要素を削除します。集合に存在しない値を指定した場合は何もしません。

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s.discard(10)
print(s)
# {0, 2}
集合から要素を削除する

remove() 関数も引数に指定した要素を削除しますが、集合に存在しない値を指定すると KeyError が発生します。

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

s.discard(10)
# KeyError: 10
集合から要素を削除する

pop() 関数は集合から要素を削除し、その値を返します。どの値を削除するかは選択できません。空集合だと KeyError が発生します。

s = {2, 1, 0}

print(s.pop())
# 0
print(s.pop())
# 1
print(s.pop())
# 2
print(s.pop())
# KeyError: 'pop from an empty set'
集合から要素を削除する

clear() 関数はすべての要素を削除し、空集合とします。

s = {0, 1, 2}

s.clear()
print(s)
# set()
集合から要素を削除する

和集合

和集合 (合併、ユニオン) は | 演算子、または union()関数で取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}
和集合

union()関数には複数の引数を指定することもできます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}
和集合

また、引数には set()で 変換できるリストやタプルなども指定できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}
和集合

差集合

積集合 (共通部分、交差、インターセクション)は、&演算子、または intersection() メソッドで取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}
差集合

積集合

差集合は - 演算子、または difference() 関数で取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}
積集合

対称差集合

対称差集合は ^ 演算子、または symmetric_difference() で取得できます。対称差集合は、論理演算における排他的論理和 (XOR) に相当します。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
対称差集合

部分集合か判定する: issubset()

ある集合が別の集合の部分集合かを判定するには、<= 演算子、または issubset() 関数を使います。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True
部分集合か判定する

<= 演算子も issubset() 関数も、等価な集合に対して True を返します。

s1 = {0, 1}

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False
部分集合か判定する

上位集合か判定する: issuperset()

ある集合が別の集合の上位集合かを判定するには、>=演算子、または issuperset() を使います。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True
上位集合か判定する

>= 演算子も issuperset() 関数も、等価な集合に対して True を返す。真上位集合であるかを判定するには、等価な集合に対して False を返す > 演算子を使う。

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False
上位集合か判定する

互いに素か判定する: isdisjoint()

二つの集合が互いに素かを判定するには、isdisjoint() 関数を使います。

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
上位集合か判定する

関連記事

Python 全体の仕様を体系的にまとめたページは、プログラミング Python 入門を参照してください。

Category:
プログラミング
公開日:
更新日:
Pageviews:
119
Shares:
1
Tag:
Python
hatebu icon
hatebu