［Pythonチートシート］文字列／リスト／タプル／辞書／集合の操作編：Pythonチートシート
Pythonが提供する標準的な反復可能オブジェクトとして、文字列、リスト、タプル、辞書、集合の操作をギュギュッとまとめた。
今回はPythonを使う上では避けては通れない、文字列、リスト、タプル、辞書、集合の定義とその操作（演算子、組み込み関数、メソッド）を見ていく（本稿ではfrozenset、バイト列などは省略する）。
目次
文字列／リスト／タプル／辞書／集合の定義
文字列（str）、リスト（list）、タプル（tuple）、辞書（dict）、集合（set）には次のような特性がある。
| 特性 | str | list | tuple | dict | set |
|---|---|---|---|---|---|
| 変更可能 | × | ○ | × | ○ | ○ |
| 変更不可能 | ○ | × | ○ | × | × |
| 要素に順序がある | ○ | ○ | ○ | × | × |
| 要素に順序がない | × | × | × | ○ | ○ |
| 要素（キー）の重複 | ○ | ○ | ○ | × | × |
| 要素の種類 | 文字 | 任意 | 任意 | キー／値の組 | 任意 |
| 文字列／リスト／タプル／辞書／集合の定義 | |||||
また、これらは組み込み関数もしくはリテラルの形で定義できる。以下に定義例を示す。
# 文字列の定義
s = 'foo' # 文字列リテラルはシングルクオート／ダブルクオートなどで囲む
print('s:', s) # 'foo'
s = str([0, 1, 2]) # str関数は他のオブジェクトの文字列表現を作成する
print('s:', s) # '[0, 1, 2]'
# リストの定義
l = ['foo', 'bar'] # リストリテラルは[]で囲む
print('l:', l) # ['foo', 'bar']
l = list('foo') # list関数に文字列（反復可能オブジェクト）を渡す
print('l:', l) # ['f', 'o', 'o']
# タプルの定義
t = (0, 1, 2) # タプルリテラルは()で囲む
print('t:', t) # (0, 1, 2)
t = () # 空のタプル
print('t:', t) # ()
t = (0, ) # 要素を1つだけ持つタプル
print('t:', t) # (0,)
t = tuple(l) # tuple関数にリスト（反復可能オブジェクト）を渡す
print('t:', t) # ('f', 'o', 'o')
# 辞書の定義
d = {'a': 'A', 'b': 'B', 'c': 'C'} # 辞書リテラルは{}内にキー／値の組を書く
print('d:', d) # {'a': 'A', 'b': 'B', 'c': 'C'}
d = dict(foo='FOO', bar='BAR', baz='BAZ') # dict関数にキーワード引数を渡す
print('d:', d) # {'foo': 'FOO', 'bar': 'BAR', 'baz': 'BAZ'}
d = dict([('a', 'A'), ('b', 'B')]) # キーと値のタプルを要素とするリストを渡す
print('d:', d) # {'a': 'A', 'b': 'B'}
# 集合の定義
s = {0, 1, 2} # 集合リテラルは{}で囲む
print('s:', s) # {0, 1, 2}
s = set('foo') # set関数に文字列（反復可能オブジェクト）を渡す
print('s:', s) # {'f', 'o'}：集合は要素の重複を許さない
リスト、辞書、集合については内包表記を使って定義することも可能だ。
# リスト内包表記
l = [x for x in range(5)] # [0, 1, 2, 3, 4] == list(range(5))
l = [x ** 2 for x in l] # [0, 1, 4, 9, 16]
# 辞書内包表記
d = {x: x * 2 for x in range(3)} # {0: 0, 1: 2, 2: 4}
# 集合内包表記
s = {x ** 2 for x in range(3)} # {0, 1, 4}
なお、これらのオブジェクトの詳細については以下を参照されたい。
以下では、これらのオブジェクトに共通する操作、オブジェクトに固有の操作を順に見ていこう。
演算子、組み込み関数による操作
以下に文字列（str）、リスト（list）、タプル（tuple）、辞書（dict）、集合（set）に対して可能な演算と、それらを引数に取る組み込み関数を一覧し、それぞれのデータ型でその操作を行えるかを○（可能）と×（不可能）で示す。以下の表の「操作」列では「iter」を反復可能オブジェクトとし、「x」はその要素と同じ型の値、「n」「i」「j」「k」「func」を乗算やインデクシング、スライシング、その他の操作で使用する値とする。なお、「dict」列で「○」となっているものは、辞書の「キー」を対象とすることには注意しよう（例えば、「'x' in {'A': 'a', 'X': 'x'}」はFalseとなるが、これは辞書に「'x'」というキーがないからだ）。一部の操作では、指定可能な引数を省略しているものもある。
| 操作 | 説明 | str | list | tuple | dict | set |
|---|---|---|---|---|---|---|
| x in iter | xが存在するかどうか | ○ | ○ | ○ | ○ | ○ |
| x not in iter | xが存在しないかどうか | ○ | ○ | ○ | ○ | ○ |
| iter1 + iter2 | iter1とiter2を結合した結果を得る | ○ | ○ | ○ | × | × |
| iter1 += iter2 | iter1の末尾にiter2を結合 | × | ○ | × | × | × |
| iter * n、n * iter | iterのn回の繰り返し | ○ | ○ | ○ | × | × |
| iter *= n | iterをn回繰り返したものをiterに代入 | × | ○ | × | × | × |
| iter[i] | iterのi番目の要素 | ○ | ○ | ○ | ○ | × |
| iter[i:j] | iterのi番目からj番目の要素 | ○ | ○ | ○ | × | × |
| iter[i:j:k] | iterのi番目からj番目の要素（k個おきに） | ○ | ○ | ○ | × | × |
| iter[i] = x | iterのi番目の要素にxを代入 | × | ○ | × | ○ | × |
| iter1[i:j] = iter2 | iter1[i:j]をiter2に置き換える | × | ○ | × | × | × |
| iter1[i:j:k] = iter2 | iter[i:j:k]をiter2に置き換える（両者の要素数が同じである必要がある） | × | ○ | × | × | × |
| del iter[i] | iter[i]の要素を削除 | × | ○ | × | ○ | × |
| del iter[i:j] | iter[i:j]の要素を削除 | × | ○ | × | × | × |
| del iter[i:j:k] | iter[i:j:k]の要素を削除 | × | ○ | × | × | × |
| all(iter) | iterの要素が全て真かどうか | ○ | ○ | ○ | ○ | ○ |
| any(iter) | iterのいずれかの要素が真かどうか | ○ | ○ | ○ | ○ | ○ |
| enumerate(iter, i=0) | 「(index, item)」というタプルを返すイテレータを取得 | ○ | ○ | ○ | ○ | ○ |
| filter(func, iter) | iterの要素に対してfuncを実行し、その結果が真となるものだけを返送するイテレータを取得 | ○ | ○ | ○ | ○ | ○ |
| len(iter) | iterの要素数 | ○ | ○ | ○ | ○ | ○ |
| map(func, iter) | iterの要素に対してfuncを実行し、その結果を返送するイテレータを取得 | ○ | ○ | ○ | ○ | ○ |
| max(iter) | iterで最大の要素 | ○ | ○ | ○ | ○ | ○ |
| min(iter) | iterで最小の要素 | ○ | ○ | ○ | ○ | ○ |
| reversed(iter) | 順序を持つiterの要素を逆順に取り出すイテレータを取得 | ○ | ○ | ○ | × | × |
| sorted(iter, key=None) | keyに指定された関数でiterの要素（辞書の場合はキー）を処理したものをキーとして、iterを並べ替えた新しいオブジェクトを取得 | ○ | ○ | ○ | ○ | ○ |
| sum(iter) | iterの要素の和を求める。要素は数値である必要がある | ○ | ○ | ○ | ○ | ○ |
| zip(*iter) | iterに指定された1つ以上の反復可能オブジェクトから、同じインデックスを持つ要素をまとめたタプルを返送するイテレータを取得 | ○ | ○ | ○ | ○ | ○ |
| 反復可能オブジェクトの操作（演算子、del文、組み込み関数） | ||||||
以下に例を示す。
# in演算子、not in演算子
print("'y' in 'Python':", 'y' in 'Python') # True
print("0 not in [1, 2, 3]:", 0 not in [0, 1, 2, 3]) # False
# +演算子
print('(0, 1, 2) + (3, 4):', (0, 1, 2) + (3, 4)) # (0, 1, 2, 3, 4)
# +=演算子
iter1 = list(range(4))
print('iter1:', iter1) # [0, 1, 2, 3]
iter1 += [4, 5]
print('iter1 += [4, 5]:', iter1) # [0, 1, 2, 3, 4, 5]
# *演算子
print("'Py' * 2:", 'Py' * 2) # 'PyPy'
# *=演算子
iter = ['foo', 'bar']
print('iter:', iter) # ['foo', 'bar']
iter *= 3
print('iter *= 3:', iter) # ['foo', 'bar', 'foo', 'bar', 'foo', 'bar']
# []演算子
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
print('iter[2]:', iter[2]) # 2
print('iter[1:3]:', iter[1:3]) # [1, 2]
print('iter[3:-1]:', iter[3:-1]) # [3]
print('iter[::2]:', iter[::2]) # [0, 2, 4]
# []演算子（代入）
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
iter[2] = 100
print('iter[2] = 100:', iter) # [0, 1, 100, 3, 4]
iter = {'a': 'A', 'b': 'B', 'c': 'C'}
print('iter:', iter) # {'a': 'A', 'b': 'B', 'c': 'C'}
iter['c'] = 'c'
print("iter['c'] = 'c':", iter) # {'a': 'A', 'b': 'B', 'c': 'c'}
iter1 = list(range(5))
print('iter1:', iter1) # [0, 1, 2, 3, 4]
iter2 = [10, 20]
print('iter2:', iter2) # [10, 20]
iter1[1:3] = iter2 # インデックス1と2の要素を[10, 20]で置き換える
print('iter1[1:3] = iter2:', iter1) # [0, 10, 20, 3, 4]
print('iter1:', iter1) # [0, 10, 20, 30, 4]
iter2 = [100, 200, 400]
print('iter2:', iter2) # [100, 200, 400]
iter1[0:5:2] = iter2
print('iter1[0:5:2] = iter2:', iter1) # [100, 10, 200, 3, 400]
# del文
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
del iter[3]
print('del iter[3]:', iter) # [0, 1, 2, 4]
del iter[0:1] # del iter[0:1]はiter[0]のみを削除
print('del iter[0:1]:', iter) # [1, 2, 4]
del iter[::2] # 0番目の要素と2番目の要素を削除
print('del iter[::2]:', iter) # [2]
# all関数／any関数
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
print('all(iter):', all(iter)) # False：iter[0]==0は偽と評価される
print('any(iter):', any(iter)) # True：iter[0]以外は真と評価される
# enumerate関数
iter = 'iter'
for (idx, ch) in enumerate(iter):
print(f"iter[{idx}] = '{ch}'") # "iter[0] = 'i'"、"iter[1] = 't'"、……
# filter関数
iter = [2, 7, 8, 10, 1]
print('iter:', iter)
result = list(filter(lambda x: x % 2 == 0, iter)) # 偶数のみからなるリスト
print('list(filter(lambda x: x % 2 == 0, iter)):', result) # [2, 8, 10]
# len関数
iter = {chr(x + ord('a')): chr(x + ord('A')) for x in range(26)}
print('iter:', iter) # {'a': 'A', 'b': 'B', ……, 'y': 'Y', 'z': 'Z'}
print('len(iter):', len(iter)) # 26
# map関数
iter = list('iter')
print('iter:', iter) # ['i', 't', 'e', 'r']
result = list(map(lambda x: chr(ord(x) - 32), iter)) # 32＝ord('a') - ord('A')
print('list(map(lambda x: chr(ord(x) - 32), iter)):', result) # ['I', 'T', 'E', 'R']
# max関数／min関数
iter = set(range(10))
print('iter:', iter) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print('max(iter):', max(iter)) # 9
iter = 'string'
print('iter:', iter) # 'string'
print('min(iter):', min(iter)) # 'g'
# reversed関数
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
print('list(reversed(iter)):', list(reversed(iter))) # [4, 3, 2, 1, 0]
# sorted関数
iter = 'Python'
print('iter:', iter) # 'Python'
result = ''.join(sorted(iter)) # ASCII順に並べ替え
print("''.join(sorted(iter)):", result) # 'Phnoty'
result = ''.join(sorted(iter, key=str.upper)) # 全てを大文字化した値で並べ替え
print("''.join(sorted(iter, key=str.upper)):", result) # 'hnoPty'
# sum関数
iter = list(range(5))
print('iter:', iter)
print('sum(iter):', sum(iter)) # 10
iter = '012345'
print('iter:', iter)
print('sum([int(x) for x in iter]):', sum([int(x) for x in iter])) # 15
# zip関数
for (x, y) in zip([0, 1, 2], 'str'):
print(x, y) # '0 s'、'1 t'、'2 r'
反復可能オブジェクトのメソッド
反復可能オブジェクトには変更可能（ミュータブル）なものと、変更不可能（イミュータブル）なものがある。また、要素が順序を持つもの（シーケンス）と持たないものがある。こうした特性の違いに応じて、それらに対して呼び出し可能なメソッドが決まる。例えば、文字列とタプルはともに変更不可能な反復可能オブジェクトであるため、呼び出せるのはindexメソッドとcountメソッドのみとなる（変更可能かつ要素が順序を持つ反復可能オブジェクトはリストのみであることから、以下の表に示すメソッドの多くはリストのみでサポートされている）。また、辞書と集合はclearメソッドなど幾つかのメソッドを提供している。
以下に文字列、リスト、タプル、辞書、集合で呼び出し可能／呼び出し不可能なメソッドを一覧する。以下の表の「メソッド」列では「iter」を反復可能オブジェクトとし、「x」はその要素と同じ型の値、「i」を要素のインデックスを表す値とする。
| メソッド | 説明 | str | list | tuple | dict | set |
|---|---|---|---|---|---|---|
| iter.index(x, i, j) | iter（のi番目からj番目）の要素で最初にxが登場する位置 | ○ | ○ | ○ | × | × |
| iter.count(x) | iterにxが何個含まれているか | ○ | ○ | ○ | × | × |
| iter1.append(x) | iterの末尾にxを追加 | × | ○ | × | × | × |
| iter.clear() | iterの内容を全て削除 | × | ○ | × | ○ | ○ |
| iter.copy() | iterの浅いコピーを作成 | × | ○ | × | ○ | ○ |
| iter1.extend(iter2) | iter1の末尾にiter2を結合 | × | ○ | × | × | × |
| iter.insert(i, x) | iterのi番目の位置にxを挿入 | × | ○ | × | × | × |
| iter.pop(i) | iterの先頭（またはi番目）の要素を削除して、その値を戻り値とする 辞書の場合はiで示されるキーを削除し、その値を戻り値とする 集合の場合は引数を取らず、集合の任意の要素を削除して、それを戻り値とする |
× | ○ | × | ○ | ○ |
| iter.remove(x) | iterから指定された要素xを削除する。戻り値はなし | × | ○ | × | × | ○ |
| iter.reverse(x) | iterをインプレースで逆順に並べ替える | × | ○ | × | △ | × |
△：辞書のreversedメソッドはPython 3.8で追加された。
以下に例を示す。
# indexメソッド
iter = 'foobarbaz'
print('iter:', iter)
print("iter.index('a'):", iter.index('a')) # 4
print("iter.index('a', 5, 8):", iter.index('a', 5, 8)) # 7
# countメソッド
iter = (0, 1, 2) * 2
print('iter:', iter) # (0, 1, 2, 0, 1, 2)
print('iter.count(0):', iter.count(0)) # 2
# appendメソッド
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
iter.append(5) # 戻り値はないので別に実行しておく
print('iter.append(5):', iter) # [1, 2, 3, 4, 5]
iter.append([6])
print('iter.append([6]):', iter) # [1, 2, 3, 4, 5, [6]]
# clearメソッド
iter = {'a': 'A', 'b': 'B'}
print('iter:', iter) # {'a': 'A', 'b': 'B'}
iter.clear() # 戻り値はないので別に実行しておく
print('iter.clear():', iter) # {}
# copyメソッド
iter1 = {0, 1, 2, 3}
print('iter1:', iter1) # {0, 1, 2, 3}
iter2 = iter1.copy()
print('iter2 = iter1.copy():', iter2) # {0, 1, 2, 3}
print('iter1 == iter2:', iter1 == iter2) # True
print('iter1 is iter2:', iter1 is iter2) # False
iter1 = [[0, 1], [2, 3]]
print('iter1:', iter1) # [[0, 1], [2, 3]]
iter2 = iter1.copy() # copyメソッドは浅いコピーを作成する
print('iter2 = iter1.copy():', iter2) # [[0, 1], [2, 3]]
print('iter1 is iter2:', iter1 is iter2) # False
print('iter1[0] is iter2[0]:', iter1[0] is iter2[0]) # True
# extendメソッド
iter1 = list(range(5))
iter2 = [5, 6]
print('iter1:', iter1) # [0, 1, 2, 3, 4]
print('iter2:', iter2) # [5, 6]
iter1.extend(iter2) # 戻り値はないので別に実行しておく
print('iter1.extend(iter2):', iter1) # [0, 1, 2, 3, 4, 5, 6]
# insertメソッド
iter = [0, 1, 3, 4]
print('iter:', iter) # [0, 1, 3, 4]
iter.insert(2, 20) # 戻り値はないので別に実行しておく
print('iter.insert(2, 20):', iter) # [0, 1, 20, 3, 4]
# popメソッド
iter = list(range(5))
print('iter:', iter) # [0, 1, 2, 3, 4]
print('iter.pop():', iter.pop()) # 4
print('iter:', iter) # [0, 1, 2, 3] # 末尾の要素が削除され、取り出された
print('iter.pop(1):', iter.pop(1)) # 1
print('iter:', iter) # [0, 2, 3]：指定したインデックス位置の要素が対象
iter = {'a': 'A', 'b': 'B', 'c': 'C'}
print('iter:', iter) # {'a': 'A', 'b': 'B', 'c': 'C'}
print("iter.pop('c'):", iter.pop('c')) # 'C'
print('iter:', iter) # {'a': 'A', 'b': 'B'}
print("iter.pop('d', 'default'):", iter.pop('d', 'default')) # 'default'
iter = {1, 2, 4, 7, 9}
print('iter:', iter) # {1, 2, 4, 7, 9}
print('iter.pop():', iter.pop()) # 1
# removeメソッド
iter = [0, 1, 2] * 2
print('iter:', iter) # [0, 1, 2, 0, 1, 2]
iter.remove(2) # 戻り値はないので別に実行しておく
print('iter.remove(2):', iter) # [0, 1, 0, 1, 2]
iter = set(range(5))
print('iter:', iter) # {0, 1, 2, 3, 4}
iter.remove(2) # 戻り値はないので別に実行しておく
print('iter.remove(2):', iter) # {0, 1, 3, 4}
# reverseメソッド
iter = list(range(5))
print('iter:', iter)
iter.reverse() # 戻り値はないので別に実行しておく
print('iter.reverse():', iter) # [4, 3, 2, 1, 0]
以下では、文字列、リストなど、それぞれの反復可能オブジェクトが持つ固有のメソッドについてまとめる。
リストに固有のメソッド
リストに固有のメソッドを以下に示す（リストは「lst」と表記）。
| メソッド | 説明 |
|---|---|
| lst.sort(key=None, reverse=False) | lstの要素をインプレースでリストの要素を並べ替える |
| リストに固有のメソッド | |
表に示した通り、リストに固有のメソッドは「破壊的な」（リスト自体の要素を書き換える）sortメソッドのみだ。元のリストの順序を維持したまま、並べ替え後のリストがほしいときには組み込みのsorted関数を使用する。
引数keyは、上で見たsorted関数と同様に並べ替える際のキーを取得するために使用する。引数reverseにTrueを指定すると降順に、False（デフォルト値）を指定すると昇順に並べ替えが行われる。
以下に例を示す。
lst = ['foo', 'bar', 'baz']
print('lst:', lst) # ['foo', 'bar', 'baz']
lst.sort() # 戻り値はないので別に実行しておく
print('lst.sort():', lst) # ['bar', 'baz', 'foo']
lst = list('Python')
print('lst:', lst) # ['P', 'y', 't', 'h', 'o', 'n']
lst.sort(key=str.upper, reverse=True) # 大文字小文字の区別なしで並べ替え。逆順
print('lst.sort(key=str.upper, reverse=True):', lst) # ['y', 't', 'P', 'o', 'n', 'h']
辞書に固有のメソッド
辞書に固有のメソッドを以下に示す。以下の表では、辞書オブジェクトを「dct」と表記する。なお、辞書で実装されているメソッドや操作のうち、上で紹介したものは省略している。
| メソッド | 説明 |
|---|---|
| dict.fromkeys(iter, value) | dictクラスのクラスメソッド。iterの要素をキーとした新しい辞書を作成する。valueが指定されれば、キーの値はvalueになる。指定しなければ、Noneになる |
| dct.get(key, default=None) | keyの値を取得する。keyが辞書になければdefaultの値が返される。dct[key]のようにして値を取得しようとすると、keyがないときにはKeyError例外が発生するが、getメソッドではKeyError例外が発生しない |
| dct.items() | (key, value)となるタプルを返送するビューを取得する |
| dct.keys() | 辞書のキーを返送するビューを取得する |
| dct.popitem() | (key, value)の組を任意（またはPython 3.7以降では辞書にキー／値の組を追加したのとは逆の順）にdctから削除して、それを戻り値とする |
| dct.setdefault(key, default=None) | dctに指定したkeyがあれば、その値を戻り値とする。なければ、defaultに指定した値をkeyの値の値として、辞書にエントリを追加する（戻り値はdefaultの値） |
| dct.update(other) | otherに指定した辞書、キー／値を要素とする反復可能オブジェクト、キーワード引数などを使って、dctを更新する。既存のキーが指定された場合は上書きされる |
| dct.values() | dctの値を返送するビューを取得する |
| 辞書に固有のメソッド | |
以下に幾つか例を示す。詳細な説明と例については「Python入門」の「辞書」を参照されたい。
dct = {chr(x+ord('a')): chr(x+ord('A')) for x in range(3)}
print('dct:', dct) # {'a': 'A', 'b': 'B', 'c': 'C'}
print(dct.get('f')) # None（辞書にないキーを指定）
for (key, value) in dct.items():
print(f'{key}: {value}') # 'a: A'、'b: B'、'c: C'
for key in dct.keys():
print(dct[key]) # 'A'、'B'、'C'
dct.setdefault('d', 'D')
print('dct:', dct) # {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}
print(dct.popitem()) # ('d', 'D')
print('dct:', dct) # {'a': 'A', 'b': 'B', 'c': 'C'}
集合に固有のメソッド／演算子
集合に固有のメソッド／演算子を以下に示す。以下の表では、辞書オブジェクトを「st」と表記する。なお、集合で実装されているメソッドや操作のうち、上で紹介したものは省略している。
| メソッド／演算子 | 説明 |
|---|---|
| st.isdisjoint(st2) | stとst2が互いに素なら（重複する要素がなければ）Trueを、そうでなければFalseを返す |
| st.issubset(st2) st <= st2 |
stがst2の部分集合もしくは等しい集合であればTrueを、そうでなければFalseを返す |
| st < st2 | stがst2の真部分集合であればTrueを、そうでなければFalseを返す |
| st.issuperset(st2) st >= st2 |
stがst2の上位集合もしくは等しい集合であればTrueを、そうでなければFalseを返す |
| st > st2 | stがst2の真上位集合であればTrueを、そうでなければFalseを返す |
| st.union(st2) st | st2 |
stとst2の和を返す |
| st.intersection(st2) st & st2 |
stとst2の積を返す |
| st.difference(st2) st - st2 |
stとst2の差を返す |
| st.symmetric_difference(st2) st ^ st2 |
stとst2の対称差を返す |
| st.update(st2) st |= st2 |
stにst2の和をstの要素とする |
| st.intersection_update(st2) st &= st2 |
stとst2の積をstの要素とする |
| st.difference_update(st2) st -= st2 |
stとst2の差をstの要素とする |
| st.symmetric_difference_update(st2) st ^= st2 |
stとst2の対称差をstの要素とする |
| st.add(x) | stにxを追加する |
| st.remove(x) | stからxを削除する。stにxが含まれていないとKeyError例外が発生する |
| st.discard(x) | stからxを削除する。stにxが含まれていなくてもKeyError例外は発生しない |
| 集合に固有のメソッドと演算子 | |
以下に幾つか例を示す。詳細な説明と例については「Python入門」の「集合」を参照されたい。
print('{0, 1, 2}.isdisjoint({3, 4}):', {0, 1, 2}.isdisjoint({3, 4})) # True
print('{0, 1, 2}.union({2, 3}):', {0, 1, 2}.union({2, 3})) # {0, 1, 2, 3}
print('{0, 1, 2} ^ {2, 3}:', {0, 1, 2} ^ {2, 3}) # {0, 1, 3}
st = {0, 1, 2}
st.intersection_update({1, 2, 3})
print('st.intersection_update({1, 2, 3}):', st) # {1, 2}
文字列に固有のメソッド
文字列に固有のメソッドを抜粋して以下に示す。以下の表では、文字列オブジェクトを「st」と表記する。なお、文字列で実装されているメソッドのうち、上で紹介したものは省略している。また、文字列を返すメソッドは全て、元の文字列を変更した新しい文字列を返送する。簡単なものは例を同時に示す。
| メソッド | 説明 | 例 |
|---|---|---|
| st.capitalize() | stの最初の文字を大文字に、残りの文字を小文字にする | 'python'.capitalize()→'Python' |
| st.center(width, fillchar=' ') | stを長さwidthで中央寄せされた文字列にする。前後に空きがあればfillcharで埋められる | 'py'.center(6, '=')→'==py==' |
| st.encode() | stをバイト列にエンコードする | 'python'.encode()→b'python' |
| st.endswith(suffix, start, end) | stがsuffixで終了していればTrueを、そうでなければFalseを返す。startとendは比較の開始位置と終了位置を示す | 'python'.endswith('on')→True 'python'.endswith('on', 5)→False |
| st.expandtabs(tabsize=8) | st中のタブ文字を空白文字に展開する。tabsizeでタブ位置を指定可能 | 'py\tthon'.expandtabs(4)→'py thon' |
| st.find(substr, start, end) | stからsubstrを検索し、最初に見つかったもののインデックスを返す。見つからなければ-1が戻り値となる。startとendで検索の開始位置と終了位置を指定可能 | 'deep'.find('e')→1 'deep'.find('e', 2)→2 |
| st.format(*args, **kwargs) | stを書式指定文字列としてargsとkwargsに受け取った値の書式化を行う | 「文字列の書式指定」を参照 |
| st.index(substr, start, end) | stからsubstrを検索し、最初に見つかったもののインデックスを返す。見つからなければValueError例外となる。startとendで検索の開始位置と終了位置を指定可能 | 'deep'.index('e')→1 'python'.index('a')→ValueError例外 |
| st.isalnum() | stがアルファベットと数字のみで構成されていればTrueを、そうでなければFalseを返す | '0x123'.isalnum()→True '=1234='.isalnum()→False |
| st.isalpha() | stがアルファベットのみで構成されていればTrueを、そうでなければFalseを返す | 'foo'.isalpha()→True '123a'.isalpha()→False |
| st.isascii() | stがASCIIの範囲の文字だけで構成されていればTrueを、そうでなければFalseを返す（Python 3.7以降） | 'ascii range'.isascii()→True 'アスキー'.isascii()→False |
| st.isdecimal() | stが1文字以上を含み、それらが全て数字であればTrueを、そうでなければFalseを返す | '1234'.isdecimal()→True '12.34'.isdecimal()→False |
| st.isdigit() | stが1文字以上を含み、それらが全て数字またはUNICODEのNumeric_Type=Decimal属性を持つ文字であればTrueを、そうでなければFalseを返す | '\u2460'.isdigit()→True（'\u2460'は丸付き数字の1） |
| st.isidentifier() | stが識別子（名前）として正しければTrueを、そうでなければFalseを返す | 'a0'.isidentifier()→True '0a'.isidentifier()→False |
| st.islower() | stが小文字でのみ構成されていればTrue、そうでなければFalseを返す | 'CAPITAL'.islower()→False 'capital'.islower()→True |
| st.isnumeric() | stが1文字以上を含み、それらが全て数を表す文字であればTrueを、そうでなければFalseを返す | '二'.isnumeric()→True '円'.isnumeric()→False |
| st.isprintable() | stが1文字以上を含み、それらが全て印字可能文字であればTrueを、そうでなければFalseを返す | '\x00'.isprintable()→False |
| st.isspace() | stが1文字以上を含み、それらが全て空白文字であればTrueを、そうでなければFalseを返す | '\t'.isspace()→True '_'.isspace()→False |
| st.istitle() | stがタイトルケース（「Title Case」「Python Cheat Sheet」のように最初が大文字で残りが小文字で構成される1語以上の文字列）であればTrueを、そうでなければFalseを返す | 'Foo Bar'.istitle()→True 'FOO Bar'.istitle()→False |
| st.isupper() | stが大文字だけで構成されていればTrueを、そうでなければFalseを返す | 'FOO'.isupper()→True 'foo'.isupper()→False |
| st.join(iter) | stを区切り文字として、反復可能オブジェクトiterの要素を結合する | ','.join(['a', 'b'])→'a,b' |
| st.ljust(width, fillchar=' ') | stを長さwidthで左寄せされた文字列にする。空きがあればfillcharで埋められる | 'py'.ljust(6, '=')→'py====' |
| st.lower() | stを小文字化する | 'FOO'.lower()→'foo' |
| st.lstrip(chars=None) | stの先頭から空白文字もしくはcharsで指定された文字を削除する | ' abc '.lstrip()→'abc ' '=-abc-='.lstrip('-=')→'abc-=' |
| st.maketrans(x, y, z) | st.translateメソッドで使用する変換テーブルを作成する（スタティックメソッド） | 以下を参照 |
| st.partition(s) | stをsが最初に見つかったところで区切り、(sepより前の部分, sep, sepより後ろの部分)というタプルを返す | 'abcdef'.partition('cd')→('ab', 'cd', 'ef') |
| st.replace(old, new, count) | st内のoldをnewでcountで指定した回数だけ置き換える。countを指定しなければ全てのoldがnewに置き換えられる | 'python'.replace('ython', 'erl')→'perl' |
| st.rfind(substr, start, end) | st.findメソッドと同様だが、最後に見つかったもののインデックスを返す。見つからなければ-1が返される | 'deep'.rfind('e')→2 |
| st.rindex(substr, start, end) | st.indexメソッドと同様だが、最後に見つかったもののインデックスを返す。見つからなければ、ValueError例外が発生する | deep'.rindex('a')→ValueError例外 |
| st.rjust(width, fillchar=' ') | stを長さwidthで右寄せされた文字列にする。空きがあればfillcharで埋められる | 'py'.rjust(6, '=')→'====py' |
| str.rpartition(s) | stをsが最後に見つかったところで区切り、(sepより前の部分, sep, sepより後ろの部分)というタプルを返す | 'abcabcabc'.rpartition('ca')→('abcab', 'ca', 'bc') |
| st.rsplit(sep=None, maxsplit=-1) | sepを区切り文字としてstをmaxsplit回分割したものを要素とするリストを返す（sepの検索は末尾より行う）。maxsplitを指定しなければ全てが分割される | 'abcabcabc'.rsplit('ca', 1)→['abcab', 'bc'] |
| st.rstrip(chars=None) | stの先頭から空白文字もしくはcharsで指定された文字を削除する | ' abc '.rstrip()→' abc' '=-abc-='.rstrip('-=')→'=-abc' |
| st.split(sep=None, maxsplit=-1) | sepを区切り文字としてstをmaxsplit回分割したものを要素とするリストを返す（sepの検索は先頭より行う）。maxsplitを指定しなければ全てが分割される | 'abcabcabc'.split('ca', 1)→['ab', 'bcabc'] |
| st.splitlines(keepends=False) | stをその内部にある改行文字で分割し、それぞれを要素とするリストを返す。keependsにTrueを指定すると要素の末尾に改行文字が含まれるようになり、Falseを指定すると要素の末尾から改行文字が削除される | 'a\nb'.splitlines()→['a', 'b'] |
| st.startswith(prefix, start, end) | stがprefixで始まるならTrueを、そうでなければFalseを返す。startとendで検索範囲を指定可能 | 'python'.startswith('py')→True 'python'.startswith('y', 1)→True |
| st.strip(chars=None) | stの先頭および末尾から空白文字もしくはcharsで指定された文字を削除する | ' abc '.strip()→'abc' '=-abc-='.strip('-=')→'abc' |
| st.swapcase() | stの大文字小文字を入れ替える | 'hoge'.swapcase()→'HOGE' |
| st.title() | st内の単語の先頭を大文字に、それ以降の文字を小文字にする | 'deep insider'.title()→'Deep Insider' |
| st.translate(tbl) | st内の文字を変換テーブルtblに従って変換する。変換テーブルはst.maketransメソッドで作成できる | 以下を参照 |
| st.upper() | stを大文字化する | 'foo'.upper()→'FOO' |
| st.zfill(width) | stを長さwidthの文字列とする。空きがあれば'0'で埋められる | '1234'.zfill(5)→'01234' |
| 文字列に固有のメソッド | ||
大方のメソッドは例を表中に示したので、ここではmaketransメソッドとtranslateメソッドの使用例を示す。
maketransメソッドには引数を1つ指定する場合、2つ指定する場合、3つ指定する場合がある。
- 1つ指定：変換前の文字／変換後の文字を要素とする辞書を渡す
- 2つ指定：同じ長さの文字列を渡す。第1引数が変換前の文字を表し、それが第2引数の同じインデックス位置にある文字に変換されるようなテーブルが作られる
- 3つ指定：第1引数と第2引数は2つ指定の場合と同様。第3引数に指定した文字列に含まれる文字は削除されるようなテーブルが作られる
translateメソッドに、maketransメソッドで作成したテーブルを渡すと、それに従って変換が行われる。
# 小文字を大文字に変換するテーブル
d = {chr(x+ord('a')): chr(x+ord('A')) for x in range(26)}
tbl = str.maketrans(d) # 引数を1つ指定する場合
print(tbl) # {97: 'A', 98: 'B', 99: 'C', ……, 121: 'Y', 122: 'Z'}
print("'abc'.translate(tbl):", 'abc'.translate(tbl)) # 'ABC'
tbl = str.maketrans('abcd', 'ABCD') # 引数を2つ指定する場合
print(tbl) # {97: 65, 98: 66, 99: 67, 100: 68}
print("'abcdefg'.translate(tbl):", 'abcdefg'.translate(tbl)) # 'ABCDefg'
tbl = str.maketrans('abc', 'ABC', 'def') # 引数を3つ指定する場合
print(tbl) # {97: 65, 98: 66, 99: 67, 100: None, 101: None, 102: None}
print("'abcdef'.translate(tbl):", 'abcdef'.translate(tbl)) # 'ABC'
formatメソッドについては「Python入門」の「文字列の書式指定」を参照されたい。
今回はPythonプログラムでデータを扱う上では欠かすことのできない文字列、リスト、タプル、辞書、集合の操作方法を圧縮してまとめた。次回はクラス定義の基本についてまとめる予定だ。
Copyright© Digital Advantage Corp. All Rights Reserved.