Python♪使い方とサンプル集:「組み込み型」の演算・メソッド編

1.Pythonの組み込み型の演算・メソッドTop

 詳細はPythonの「公式ドキュメント」より、「ライブラリーリファレンス」の「組み込み型」を参考にしてください。「Python、公式、組み込み型」で検索すると出てきます。でも、公式ドキュメントは、ちょっと読みにくい。そこで、代表的な機能とポイントをサンプルコードを交えて解説したいと思います。

2.索引

1.シーケンス型

以下のメソッドは、ほとんどのシーケンス型で用いることができます。

s.count(x) [b0002]
s.index(x[, i[, j]]) [b0001]

2.ミュータブルなシーケンス型

以下のメソッドは、ほとんどのミュータブルなシーケンス型 で用いることができます。

s.append(x) [c0008]
s.clear() [c0007]
s.copy() [c0006]
s.extend(t) [c0005]
s.insert(i,x) [c0004]
s.pop([i]) [c0003]
s.remove(x) [c0002]
s.reverse() [c0001]

3.リスト型(list)

以下のメソッドは、list型のメソッドです。

list.sort(key=None,reverse=False) [d0001]

3.解説

(1) シーケンス型

s.index(x[, i[, j]])

s.index(x)
 シーケンス sの中で、最初に出現するxのインデックスを返します。

s.index(x, i)
 シーケンス sの「インデックス i以降の」要素の中で、最初に出現するxのインデックスを返します。(iは整数)

s.index(x, i, j)
 シーケンス sの「インデックス i以降、インデックス jの1つ手前までの範囲の」要素の中で、最初に出現するxのインデックスを返します。(i, jは整数)

s: ほとんどのシーケンス型で用いることができます。
x: インデックス番号を知りたい要素
i, j: 整数
戻り値: 要素の中で、最初に出現するxのインデックス(type: int)

[b0001]

組み込み型のTop

サンプルコード
#コード01
x=['a', 'b', 'c', 'd', 'c']
print(x)
print("x.index('c') =", a.index('c'))
#print(x.index('c', 0, 2)) #エラー 検索範囲は'a', 'b'なので'c'がない
print("x.index('c', 2, 3) =", a.index('c', 2, 3))
#print(x.index('c', 3, 2)) #エラー 範囲は[左側の位置:右側の位置]で指定する。
print("x.index('c', -3, -2) =", a.index('c', -3, -2))
print("x.index('c', 2, -2) =", a.index('c', 2, -2)) #正負の併用も可能
#出力01
['a', 'b', 'c', 'd', 'c']
x.index('c') = 2
x.index('c', 2, 3) = 2
x.index('c', -3, -2) = 2
x.index('c', 2, -2) = 2
備考

 引数i, jによる範囲指定の方法はスライスによる範囲指定の考え方と同じです。範囲指定の覚え方は2つの方法があります。

(1) 範囲指定の覚え方1

 要素のインデックス番号より、範囲指定を考えます。例えばx[1:3]ならば、1番目の要素から2番目(3番目の1つ手前)という方法で覚えることができます。

x.index(‘b’, 1, 3) → 1番目(‘b’)から2番目(‘c’)(3番目の1つ手前)までの要素を検索。
x.index(‘b’, -4, -2) → -4番目(‘b’)から-3番目(‘c’)(-2番目の1つ手前)までの要素を検索。

(2) 範囲指定の覚え方2

 要素の間に下図のような番号をつけ、図に従い範囲を指定します。スライスにおいては負の増分を指定する場合には同じ図が使えないため、覚え方1を推奨します。

x.index(‘b’, 1, 3) → 上の図の1から3までの要素を検索。
x.index(‘b’, -4, -2) → 上の図の-4から-2までの要素を検索。

(3) 注意点

(a)検索範囲に指定したxがない場合、エラーになります。

(b) x.index(x, 左側の位置, 右側の位置)という順番で指定します。
x.index(x, 右側の位置, 左側の位置) のように指定すると、エラーにはなります。
 x.index(‘c’, 3, 2) → エラー

(c) 位置指定の番号に正の数と負の数を混在させることも可能ですが、コードが読みにくいので避けましょう。
x=[‘a’, ‘b’, ‘c’, ‘d’, ‘c’]
x.index(‘c’, 2, -2)

s.count(x)

s.count(x)
 シーケンス  s 中に x が出現する回数を返す。

s: ほとんどのシーケンス型で用いることができます。
x: 回数を求めたいsの要素を入力
戻り値: xが出現する回数(type: int)

[b0002]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','c']
print(a.count('a'))
print(a.count('c'))
#出力01
1
2

(2) ミュータブルなシーケンス型

s.append(x)

s.append(x)
 ミュータブルなシーケンス sの最後にx を加えます (s[len(s):] = [x] と同じ)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
x: 最後に追加したい要素
戻り値: None

[c0008]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','e']
a.append('f')
print(a)

#以下の書式でも要素を追加できる。
a=['a','b','c','d','e']
a[len(a):]=['f']
print(a)

#スライスに関するメモ
a=['a','b','c','d','e']
print(len(a)) #len(a)は5であり、'e'のインデックス4よりも大きい
#print(a[len(a)]) #エラー:a[5]の要素は存在しないのでエラー。
print(a[len(a):]) #存在しない要素番号でもスライス指定は可能。[]を出力。
#出力01
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f']
5
[]

s.clear()

s.clear()
 s から全ての要素を取り除きます (del s[:] 、s[:]=[]と同じ)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
戻り値: None

[c0007]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','e']
a.clear()
print(a)

a=['a','b','c','d','e']
del a[:]
print(a)

a=['a','b','c','d','e']
a[:] = []
print(a)

a=['a','b','c','d','e']
a[1:2] = [0]
print(a)

a=['a','b','c','d','e']
a[1:2] = []
print(a)
#出力01
[]
[]
[]
['a', 0, 'c', 'd', 'e']
['a', 'c', 'd', 'e']

s.copy()

s.copy()
 ミュータブルなシーケンス s の浅いコピーを作成します (ss = s[:] と同じ)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
返り値: sの浅いコピー

[c0006]

組み込み型のTop

サンプルコード

 浅いコピーを行った後、片方の変数の一番浅い要素を変更しても他方への影響はありませんが、それよりも深い部分の要素の変更を行うと、他方の変数が連動して変更されます。下の例では、左辺がa=, a[0]=のケース01~03では、aの変更がbに影響を与えていませんが、a[1][0]=5としたケース04では、aの変更がbに影響を与えています。

#コード01
a = [1, [2], [3, [4]]]
b=a.copy() #浅いコピー
a = [5]
print('01(bは連動しない):',a,b)

a = [1, [2], [3, [4]]]
b=a.copy() #浅いコピー
a[0] = 5
print('02(bは連動しない):',a,b)

a = [1, [2], [3, [4]]]
b=a.copy() #浅いコピー
a[1] = [5]
print('03(bは連動しない):',a,b)

a = [1, [2], [3, [4]]]
b=a.copy() #浅いコピー
a[1][0] = 5
print('04(bは連動する):',a,b)
#出力01
01(bは連動しない): [5] [1, [2], [3, [4]]]
02(bは連動しない): [5, [2], [3, [4]]] [1, [2], [3, [4]]]
03(bは連動しない): [1, [5], [3, [4]]] [1, [2], [3, [4]]]
04(bは連動する): [1, [5], [3, [4]]] [1, [5], [3, [4]]]

 リストの浅いコピーは3つの書式があり、どれも同じ結果になります。①b=a[:], ②b=a.copy(), ③import copy; b=copy.copy(a)

#コード02
#リストの浅いコピーの3通りの書式
a = [1, [2], [3, [4]]]

b = a[:]
print('a=', a, 'b=', b)
b = a.copy()
print('a=', a, 'b=', b)

import copy
b = copy.copy(a)
print('a=', a, 'b=', b)
#出力01
a= [1, [2], [3, [4]]] b= [1, [2], [3, [4]]]
a= [1, [2], [3, [4]]] b= [1, [2], [3, [4]]]
a= [1, [2], [3, [4]]] b= [1, [2], [3, [4]]]
備考

「参照渡し」「浅いコピー」「深いコピー」の違いをしっかりと理解する必要があります。浅いコピーや深いコピーでは、コピー後に片方の変数の内容を変更すると他方の変数の内容も連動して変更される場合があります。

 例えばbにaを「浅いコピー」した後に、aかbのどちらかの「一番上の要素」を変更しても、他方の変数の値は連動して変更されません。しかし、それよりも深い部分の要素を変更すると、他方の変数は連動して変更されます。なお、変数全体を入れ替えると、それは「変数の再定義」となるので連動しません。
※ 「変数の再定義」は左辺が「変数名 =」の形になっています。

 下の図では、浅いコピー(b=a[:])とした後、リストaの要素を変更した場合に、連動してリストbの値が変更されるかどうかを実線と点線で区別しています。
 例えば、浅いコピー(b=a[:])とした後に、a[1] = [5] とすると、bは連動して変更されません。したがって、図のa[1]=の部分は実線になっています。
 一方、浅いコピー(b=a[:])とした後に、a[1][0] = 5とすると、bも連動して、b = [ 1, [5], [3, [4]] ]となるので、図のa[1][0] =の部分は点線になっています。
 つまり、浅いコピーでは一番浅い部分の要素の変更a[0]=, a[1]=, a[2]=ではコピー先とコピー元が連動しません。

参考記事:
まずは、理屈抜きで覚えよう。「参照渡し」「浅いコピー」「深いコピー」

s.extend(t)

s.extend(t)
 ミュータブルなシーケンス s の最後に t の内容を追加します。 (s[len(s):)] = t と同じ)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
t: sがリスト型ならリスト型
戻り値: None

—–備考—–
append()は、要素を1つ追加しますが、extend()は複数の要素を追加できます。

[c0005]

組み込み型のTop

サンプルコード

 以下、append()とextend()の比較です。下の例ではappend()の引数はリストの要素ですが、extend()の引数はリストを渡しているところが違います。

#コード01
a=['a', 'b']

a[len(a):]=['c', 'd']
print(a)

a.extend(['e', 'f'])
print(a)

a[len(a):]=['g']
print(a)

a.append('h')
print(a)
#出力01
['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

s.insert(i, x)

s.insert(i, x)
 ミュータブルなシーケンス s の インデックスiの位置に x を挿入します。iの位置以降の要素は後ろにずらします。 (s[i:i] = [x] と同じ)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
i: 整数
x: 挿入したい要素
戻り値: None

[c0004]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','e']
a.insert(3,'f')
print(a)
a.insert(-2,'g') #負値での指定も可能
print(a)
a[3:3]=['h'] #[3:3]とすると挿入
print(a)
a[3:4]=['i'] #[3:4]とすると置換
print(a)
#出力01
['a', 'b', 'c', 'f', 'd', 'e']
['a', 'b', 'c', 'f', 'g', 'd', 'e']
['a', 'b', 'c', 'h', 'f', 'g', 'd', 'e']
['a', 'b', 'c', 'i', 'f', 'g', 'd', 'e']
備考

(1) 覚え方1

 要素数が5のリストでは、a.insert(3, ‘f’)とa.insert(-2, ‘f’)は同じ結果になります。覚え方1は、各要素のインデックス番号から挿入位置を考える方法です。

(2)覚え方2

 覚え方2は、各要素の間に番号をつけて、挿入位置を考える方法です。

s.pop([i])

s.pop([i])
 ミュータブルなシーケンス s から i 番目の要素を削除し、この削除した要素を返す。iを指定しない場合、一番最後の要素を削除し、この削除した要素を返す。(s[i:i+1] = []はi番目の要素を削除するのは同じだが、削除した要素を返すことはしない。)

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
i: 整数
戻り値: 削除した要素。(type: 削除した要素のtype)

[c0003]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','e']
print(a.pop(3)) #指定位置の要素の削除とともに、削除した要素を返す。
print(a)
print(a.pop(-2)) #指定位置の要素の削除とともに、削除した要素を返す。
print(a)
a[1:2]=[]
print(a)
#出力01
d
['a', 'b', 'c', 'e']
c
['a', 'b', 'e']
['a', 'e']
備考

下図のように、要素を削除する。なお、s.remove(x)は要素の内容から削除する要素を指定し、s.pop(i)は、要素のインデックスから削除する要素を指定する。

s.remove(x)

s.remove(x)
 ミュータブルなシーケンス s の左側から探索し、 s[i] == x となる最初の要素を削除します。同じ要素がなければエラーとなります。

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
x: sの要素と比較したい値
戻り値: None

[c0002]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','c']
a.remove('c')
print(a)
a.remove('c')
print(a)
#a.remove('c') #指定した要素がない場合はエラーになる。
#出力01
['a', 'b', 'd', 'c']
['a', 'b', 'd']
備考

s.remove(x)は要素の内容から削除する要素を指定し、s.pop(i)は、要素のインデックスから削除する要素を指定する。

s.reverse()

s.reverse()
 ミュータブルなシーケンス s をインプレースで逆順にします。つまり、sは逆順にした内容で上書きされます。

s: listなど、ほとんどのミュータブルなシーケンス型 で用いることができます。
戻り値: None

[c0001]

組み込み型のTop

サンプルコード
#コード01
a=['a','b','c','d','e']
print(a)
a.reverse()
print(a)
#出力01
['a', 'b', 'c', 'd', 'e']
['e', 'd', 'c', 'b', 'a']

(3) リスト型(list)

list.sort(key = None, reverse = False)

list.sort(key = None, reverse = False)

 listをインプレースでソートする。つまり、listはソートされた内容で上書きされます。

list: リスト(list)
戻り値: None

—–オプション—–
(1) reverse: reverse=Trueとすると逆順ソート。reverse = False あるいは指定しない場合は正順ソート。
(2) key: list.sort(key = 関数) の形で用いる。関数の部分にlistのそれぞれの要素を代入し、その結果をソートのkeyにする。key = None あるいは指定しない場合は、要素そのものがkeyとなります。

—–備考—–
 ディクショナリにはsort()メソッドはないため、組み込み関数sorted()を用いる。listはsort()メソッドも組み込み関数sorted()も両方使える。sorted()は元のlistの内容を上書きしない。

[d0001]

組み込み型のTop

サンプルコード
(1) sort()メソッドの基本的な使い方

 基本的な使い方をいかに示す。reberse = Trueを指定すると逆順ソートになる。

#コード01
a=['b2','b1','2','a','c']
print('00',a)
a.sort(key = None, reverse = False)
print('Case.1',a)

a=['b2','b1','2','a','c']
a.sort()  #引数を省略すると「key = None, reverse = False」になる。
print('Case.2',a)

a=['b2','b1','2','a','c'] #逆順ソート
a.sort(reverse = True)
print('Case.3',a)
#出力01
00 ['b2', 'b1', '2', 'a', 'c']
Case.1 ['2', 'a', 'b1', 'b2', 'c']
Case.2 ['2', 'a', 'b1', 'b2', 'c']
Case.3 ['c', 'b2', 'b1', 'a', '2']
(2) keyを用いたソートの例

keyを用いたソート。keyの後ろにラムダ(lambda)式、関数、len、int等を指定できる。関数を指定するときはa.sort(len())のように()はつけず、a.sort(len)のような表記ににする。

#コード02
a=[-1, -2, 4, 0, 3]
a.sort(key=lambda x:x*x)
print('Case.1',a)

def fff(x):
    return x*x

a=[-1, -2, 4, 0, 3]
a.sort(key=lambda x:fff(x))
print('Case.2',a)

a=[-1, -2, 4, 0, 3]
a.sort(key=fff)
print('Case.3',a)

a=['b21','b1','d','cccc','aaaa']
a.sort(key=len)
print('Case.4',a)

a=['5','4','-3','0','99']
a.sort(key=int)
print('Case.5',a)
#出力02
Case.1 [0, -1, -2, 3, 4]
Case.2 [0, -1, -2, 3, 4]
Case.3 [0, -1, -2, 3, 4]
Case.4 ['d', 'b1', 'b21', 'cccc', 'aaaa']
Case.5 ['-3', '0', '4', '5', '99']
備考
(1) keyを用いたソート

list.sort(key = 関数)
関数の部分にlistのそれぞれの要素を代入し、その結果をソートのkeyにする。

 例えばコード03では、key=の後のlambda式「lambda x:x*x」は入力値xに対して、x*xを出力する関数です。つまり、リストa=[-1, -2, 4, 0, 3]の各要素をそれぞれlambda式に渡すと、[-1*-1, -2*-2, 4*4, 0*0, 3*3] = [1, 4, 16, 0, 9]が並べ替えのkeyとなります。つまり、keyの[1, 4, 16, 0, 9]が小さい順に並ぶように、リストa=[-1, -2, 4, 0, 3]をソートすると、出力03のように[0, -1, -2, 3, 4]となります。

#コード03
a=[-1, -2, 4, 0, 3]
a.sort(key=lambda x:x*x)
print('Case.1',a)
#出力03
Case.1 [0, -1, -2, 3, 4]