【Python】リストの関連メソッドを図解する【機能別10選】

スポンサーリンク
Pythonの基礎文法(リストの生成と関連メソッド) Python

シリーズ「Pythonプログラミングの始め方」では次のようなコンテンツで構成されています。Pythonの基礎文法を図を用いて分かりやすく解説していきます。

<Pythonプログラミング始め方>
  • part1.基本編
    1. ステートメント
      • ・インデント,コメント,変数/定数 >>
    2. データ型
      • ・数値型, 文字列型, 各種演算子 >>
    3. データ構造
      • 3.1 リスト
        • ・生成・参照と更新・連結・比較【基礎編】>>
        • リストオブジェクトのメソッド【応用編】>>
      • 3.2 タプル >>
      • 3.3 辞書 >>
      • 3.4 内包表記 >>
    4. 構文
      • 4.1 条件分岐(if文句) >>
      • 4.2 繰り返し(for文句, While文句…) >>
      • 4.3 例外処理 >>
  • Part2.応用編
    1. 関数 >>
    2. 組込み関数 >>
    3. クラス >>

前回の記事では、Pythonのデータ構造の1つであるリスト<List>の扱い方を紹介しました。

リストは、[要素1, 要素2, ・・・]のように、”[]”(角カッコ)の中に要素が“,”(カンマ)区切りで並びます。リストは、ミュータブル(mutable)なデータ構造で、要素の追加・更新・削除を自由に行うことができるのでした。

List(リスト)の定義(生成)方法、参照と更新、連結といった基本操作については以下の記事を参考にしてください。

さらに、Pythonにおけるリストは、他言語の配列のような役割を持ち、タプルや辞書といったその他のデータ構造よりも、制約が少なく扱いやすいデータ構造である説明もしました。

配列との違いは以下のようなものがあります。

  • 要素数の可変長がしやすい
  • 異なるデータ型の要素を混在させることができる
  • 物理メモリ配置(アドレス)を意識しない

データ構造(タプル)との違いは以下のようなものがあります。タプルについてはこちら

  • イミュータブルで要素の追加・更新・削除ができない
  • リストよりも、生成速度が速く、メモリーの使用量が小さくて済む

データ構造(辞書)との違いは以下のようなものがあります。辞書についてはこちら

  • 要素の並び順を意識することはない(キーを識別子として各要素にアクセスする)
  • 同じキーを重複してもたせることはできない(値は重複できます)

さて、リストの基本事項の復習はこのあたりにしておきたいと思います。

今回は、リスト解説の【応用編】としてリストオブジェクトが提供するメソッドについて解説したいと思います。

重要度:★★★★☆

多用されるリストには、生成やさまざまな操作を効率的にしてくれる便利なメソッドが予め用意されています。自分で処理記述をコーディングする前に、Pytnonが提供するメソッドに対応するものがないか調べ、積極的に活用すべきです。

Listオブジェクトのメソッドの一例
  • リストの末尾要素を追加する:append()
  • リストの任意の場所に要素を挿入する:insert()
  • 任意の要素を抜き取る:pop()
  • 要素を昇順・降順に並び替える:sort()

…など

本記事では、「Python標準ライブラリ」のシーケンス型、ミュータブルなシーケンス型に記載されているすべてのメソッドについて図解で解説しています。

Python標準ライブラリ シーケンス型(ミュータブル)

https://docs.python.org/ja/3/library/stdtypes.html#mutable-sequence-types

それでは、次節よりリストオブジェクトのメソッドの使い方について、図解で解説していきます。

スポンサーリンク

1. 要素を追加する(append/extend/insert)

Python_基本文法_内包表記

1.1 末尾に要素を追加する(1) <append()>

既存のListオブジェクトに要素を末尾に追加(末尾)するには、append()メソッド を使います。書式と概略図は次のとおりです。

append() メソッド

Listオブジェクト.append (val)


引数: val: 末尾に追加する値やシーケンス型のオブジェクトを指定する

(引数valを一つの要素として追加する)

戻り値: なし(元のListオブジェクトを変更する)

append関数のイメージ
図1. appendメソッド概略図

appendメソッドの使用例を示します。新規リストを作る場合は中身のない空のリストをあらかじめ用意しそこに要素を追加していきます。追加できる要素には数値や文字列はもちろんのことリストやタプル、辞書といったオブジェクトも追加することができます。

# append()メソッドの使用例

# 空のリストを用意
data = []

# 末尾に10を追加
data.append(10)
# 末尾に20を追加
data.append(20)

print(data)         # ➀>>[10, 20]

# 末尾に30を追加
data.append(30)

print(data)         # ➁>>[10, 20, 30]

#-----------------------------------------------------------------------------

# リストを追加
data.append([1, 2])
# 辞書を追加
data.append({ "key1": 123 })
# タプルを追加
data.append((1, 2))

print(data)          # ➂>> [10, 20, 30, [1, 2], {'key1': 123}, (1, 2)]

append()の実行結果

➀ 》[10, 20]

➁ 》[10, 20, 30]

➂ 》[10, 20, 30, [1, 2], {‘key1’: 123}, (1, 2)]

append()メソッドは、戻り値は返しません、元のListオブジェクトを変更しますので注意してください。

1.2 末尾に要素を追加する(2) <extend()>

<1.1項>の append()メソッド と同じようにリストの末尾に要素を追加する機能を提供する「extend()メソッド」もあります。書式は以下の通りです。

append() メソッド

Listオブジェクト.extend (val)


引数: val: 末尾に追加する値やシーケンス型のオブジェクトを指定する

(引数valのシーケンスオブジェクト展開しながら一つづつ要素として追加していく)

戻り値: なし(元のListオブジェクトを変更する)

append()メソッド との違いは、引数で指定するシーケンスオブジェクトの取り扱い方です。append()メソッド は、(シーケンス)オブジェクトを1つの要素として末尾に追加しますが、extend()メソッド は、(シーケンス)オブジェクトを展開しながら一つづつ追加していく点が異なります。

extend関数のイメージ_rev0.1

「extend()メソッド」の使用例を示します。2つのListオブジェクトを同メソッドで連結しています。こちらも、戻り値は返さず元のListオブジェクトを変更します。

# extend()メソッドの使用例

data_1 = [1, 2, 3]
data_2 = ['a', 'b', 'c']

# ➀ extend()メソッドの実行(data_1にdata_2を追加)
data_1.extend(data_2)
print(data_1)            # >>[1, 2, 3, 'a', 'b', 'c']

data_1 = [1, 2, 3] # 元リストの初期化

# ➁ extend()メソッドの実行(data_2にdata_1を追加)
data_2.extend(data_1)
print(data_2)            # >>['a', 'b', 'c', 1, 2, 3]

extend()の実行結果

➀ 》[1, 2, 3, ‘a’, ‘b’, ‘c’]

➁ 》[‘a’, ‘b’, ‘c’, 1, 2, 3]

1.3 新規要素を挿入する <insert()>

Listオブジェクトの指定した位置(インデックス)に要素を挿入する場合は、insert()メソッド を使います。第1引数に挿入する位置、第2引数に挿入する要素を指定します。書式と概略図は次のとおりです。

insert() メソッド

Listオブジェクト.insert(index, val)


引数: index :要素を挿入する位置(インデックス)を指定する

引数: val :挿入する要素を指定する

戻り値: なし(元のListオブジェクトを変更する)

Listオブジェクト[i:i] = 値 と等価

insert関数のイメージ
図3. insertメソッド概略図

insert()メソッドの使用例を示します。挿入した要素以降のインデックスは、一つずつ後ろにずれていきます。追加できる要素には数値や文字列はもちろんのことリストやタプル、辞書といったオブジェクトも追加することができます。

# insert()メソッドの使用例

data = ["a", "b", "c", "d", "e"]

# 2つ目の要素に(先頭3番目の要素)数値を挿入
data.insert(2, 1)

print(data)    # ➀ >>['a', 'b', 1, 'c', 'd', 'e']

# 2つ目の要素に文字列を挿入
data.insert(2, "apple")
print(data)    # ➁ >>['a', 'b', 'apple', 1, 'c', 'd', 'e']


#-----------------------------------------------------------------------------
# リストオブジェクトを挿入
data.insert(2, [1, 2])

# 辞書オブジェクトを挿入
data.insert(2, { "key1": 123 })

# タプルオブジェクトを挿入
data.insert(2, (1, 2))

print(data)
# ➂ >>['a', 'b', (1, 2), {'key1': 123}, [1, 2], 'apple', 1, 'c', 'd', 'e']

insert()の実行結果

➀ 》[‘a’, ‘b’, 1, ‘c’, ‘d’, ‘e’]

➁ 》[‘a’, ‘b’, ‘apple’, 1, ‘c’, ‘d’, ‘e’]

➂ 》[‘a’, ‘b’, (1, 2), {‘key1’: 123}, [1, 2], ‘apple’, 1, ‘c’, ‘d’, ‘e’]

スポンサーリンク

2. 要素を抜き取る(pop, remove)

2.1 インデックスを指定して要素を抜き取る <pop()>

Listオブジェクトから、指定した要素を抜き取るには、pop()メソッド を次の書式のように使用します。

pop()メソッド

Listオブジェクト.pop(index)


引数: index: 抜き取る要素の位置 (インデックス)を指定する※

※引数を省略すると末尾の要素をが抜き取られます。

※空のリスト(空になったリスト)から、さらにpop()するとIndexエラーが発生する。

戻り値:抜き取った要素

インデックス指定の仕方により動作がかわります。引数を省略した場合は最後の要素が抜き取りの対象になります。これは、インデックスに「-1」を指定した時と等価となります。(1)

pop(1)
図4. popメソッド概略図(1)

また、要素を指定して抜き取る場合には、引数でインデックスを設定します。(2)(例えば、pop(0)で先頭の要素、pop(1)で2番目の要素といった具合)抜き取った後の、以降の要素は前方に順次おくられ再配置されます。

pop(2)
図5. popメソッド概略図(2)

また、(1)(2)のいずれの場合も抜き取り対象の要素が戻り値となります。


次は、pop()メソッドの使用例です。2つの要素をもつリストから順番に末尾のデータを抜き出します。空のリストから、さらにpop()を実行しようとするとエラー(IndexError)が発生します。

# pop()メソッドの使用例

words = ["blue", "red"]


# 末尾の要素(red)を抜き取る
pop_word = words.pop()
print(words)               # ➀>>['blue'] 残ったリストは'blue'のみ
print(pop_word)            # ➁>>red 抜き出した要素'red'が戻り値になる

# 末尾の残りの要素(blue)を抜き取る
pop_word = words.pop()
print(words)               # ➂>>[]空のリストとなる
print(pop_word)            # ➃>>blue 抜き出した要素'blue'が戻り値になる


#-----------------------------------------------------------------------
# 空のリストから抜き取る(エラー発生)
pop_word = words.pop()    # ➄>>IndexError: pop from empty list

pop()の実行結果

➀ 》[‘blue’]

➁ 》red

➂ 》[]

➃ 》blue

➄ 》IndexError: pop from empty list

2.2 要素(値)を指定して抜き取る <remove()>

Listオブジェクトから要素の値を指定して、削除をすることができます。<1.4項>の「pop()メソッド」とは異なりインデックスを予め知っておくことが不要となります。本機能は「remove()メソッド」を次の書式のようにして使います。

remove()メソッド

Listオブジェクト.remove(targetVal)


引数: targetVal: 抜き取る要素(値)を指定する※

※指定した要素(値)がリストに複数個存在する場合は、最初の一つ目が削除される

※引数targetVa lがリストに存在しなかった場合は、Valueエラーが発生する

戻り値:なし

remove関数のイメージ
図6. removeメソッド概略図

削除したい値が複数個ある場合には、最初に見つかった値が削除されます。一方、削除しようとした値がリストに含まれていない場合はエラー(ValueError)となります。


次は、remove()メソッドの使用例です。リストから特定の要素(‘red’)を指定して削除していきます。

同じ値(‘red’)をもつ要素が複数あるので、実行する度に最初に見つかったものか ら順番に削除されます。

リストに存在しない要素(値)を削除しようとするとValueエラーが発生します。<List5>

# remove()メソッドの使用例(1)

words = ["blue", "red", "yellow", "red", "green"]

# 1つ目の"red"の取り出し
words.remove("red")
print(words)                    # ➀>>['blue', 'yellow', 'red', 'green']

# 2つ目の"red"の取り出し➁
words.remove("red")
print(words)                    # ➁>>['blue', 'yellow', 'green']

# 3つ目の"red"を取り出そうとしてもないのでエラー
words.remove("red")
print(words)                    # ➂>>ValueError: list.remove(x): x not in list

remove()の実行結果(1)

➀ 》[‘blue’, ‘yellow’, ‘red’, ‘green’]

➁ 》[‘blue’, ‘yellow’, ‘green’]

➂ 》ValueError: list.remove(x): x not in list

Valueエラーを防ぐ目的のために実行前に、inステートメント でリストに指定の要素が含まれているかをチェックしています。<List6>

# remove()メソッドの使用例(2)

# if-in文によるエラー回避策

words = ["blue", "red", "yellow", "red", "green"]

# if-in文による判定
if "red" in words:
    words.remove("red")     # 1つ目の"red"の取り出し
    print(words)            #  ➀>>['blue', 'yellow', 'red', 'green']

# if-in文による判定
if "red" in words:
    words.remove("red")     # 2つ目の"red"の取り出し
    print(words)            #  ➁>>['blue', 'yellow', 'green']

# if-in文による判定    
if "red" in words:
    words.remove("red")     # if-in文がFalseになるためこのremoveは実行されない
    print(words)

#-----------------------------------------------------------------------
# while-in文によるエラー回避策

words = ["blue", "red", "yellow", "red", "green"]

# "red"がリストに内包している間くり返してremove()を実行する
while "red" in words:
    words.remove("red")

print(words)    # ➂>>['blue', 'yellow', 'green']

remove()の実行結果(2)

If-in: 構文によるエラー回避

➀ 》[‘blue’, ‘yellow’, ‘red’, ‘green’]

➁ 》[‘blue’, ‘yellow’, ‘green’]

while-in: 構文によるエラー回避

➂ 》[‘blue’, ‘yellow’, ‘green’]

スポンサーリンク

3. 要素を並び替え/調べる(sort, sorted, reverse, index, count)

3.1 要素を昇順・降順に並べる <sort(), sorted()>

Listオブジェクトの要素を昇順または降順に並び替えるには sort()メソッド を使用します。

また、似た機能を提供する、標準関数の sorted() があります。違いは、並び替える対象のListオブジェクトの取り扱い方にあります。「sort()メソッド」は、元のListを変更しますが「sorted()関数」は元のListオブジェクトは変更せず、並び替えた新しいリストを生成されます。

書式と概略図は次のとおりです。(図7)

sort()メソッド / sorted()関数

Listオブジェクト.sort(reverse, key)


引数:reverse: 降順に並び替える場合はTrueを設定します ※1

引数: key: 並び替えの方法/基準を指定(関数)する ※2

※1. オプショナル引数で、省略した場合(default:False)は昇順となります

※2. len(文字数でソート), srt.lower(小文字で比較してソート)など

sorted(target, reverse) 関数


引数:target: 並び替えるListオブジェクトを指定する(変更されない)

引数:reverse: 降順に並び替える場合はTrueを設定します

戻り値:並び替えられた、新しいListオブジェクト

sort関数のイメージ
図7. sortメソッド概略図

並び替えの対象になる要素は「数値」「文字(列)」などリストの要素となり得るデータ型とその混合です。 引数:reverse にTrueを設定することで降順に並べることができます。また、引数:keyには、並び替えの基準を関数形式で指定します。特に指定しなければ値やオブジェクトの大小で比較されますが、文字数や大文字、小文字での比較などカスタムしたい場合には明示します。


次は、sort()メソッドの使用例です。数値・文字列が混載された状態でもソートできます。その場合は、数値が優先されます。また、文字列は大文字が優先されます。(共に昇順の場合、降順の場合はその逆です。)

また、sorted()関数は、元リストをコピーして新たなソートされたリストが戻ります。

# sort()メソッドのソート例

# 昇順に(元リストを)並び替える-------------------------------

# リスト(数値)
numbers = [24, 45, 12, 9, 4, 35]
numbers.sort()
print(numbers)     # ➀>>[4, 9, 12, 24, 35, 45]

# リスト(文字列)
words = ['s','z', 'e', 'a', 'q', 'r' ]
words.sort()
print(words)       # ➁>>['a', 'e', 'q', 'r', 's', 'z']

# リスト(数値, 文字列 混載)
number_word = ['Abc', 'abc', '3', '1']
number_word.sort()
print(number_word)  # ➂>>['1', '3', 'Abc', 'abc']

# 降順に(元リストを)並び替える-------------------------------

numbers = [24, 45, 12, 9, 4, 35]
numbers.sort(reverse = True)
print(numbers)     # ➃>>[45, 35, 24, 12, 9, 4]

number_word = ['Abc', 'abc', '3', '1']
number_word.sort(reverse = True)
print(number_word) # ➄>>['abc', 'Abc', '3', '1']


# sorted関数のソート例--------------------------------------
num = [24, 45, 12, 9, 4, 35]

reverse_num = sorted(num)

print(numbers)       # ➅>>[45, 35, 24, 12, 9, 4] 元のリストには影響しない
print(reverse_num)   # ➆>>[4, 9, 12, 24, 35, 45]  新たなListオブジェクトが生成

sort()メソッド

昇順に(元リストを)並び替える

➀ 》[4, 9, 12, 24, 35, 45]

➁ 》[‘a’, ‘e’, ‘q’, ‘r’, ‘s’, ‘z’]

➂ 》[‘1’, ‘3’, ‘Abc’, ‘abc’]

降順に(元リストを)並び替える

➃ 》[45, 35, 24, 12, 9, 4]

➄ 》[‘abc’, ‘Abc’, ‘3’, ‘1’]

sorted関数

➅ 》[45, 35, 24, 12, 9, 4] 元のリストには影響しない

➆ 》[4, 9, 12, 24, 35, 45] 新たなListオブジェクトが生成

3.2 要素の並びを逆順にする<reverse()>

リストの要素の並び順(インデックス)を逆にするには reverse()メソッド を次の書式のようにして使います。

reverse()メソッド

Listオブジェクト.reverse()

引数の指定はありません

reverse関数のイメージ
図8. reverseメソッド概略図

戻り値ななく、元リストそのものを変更する、不可逆的な入れ替えを行います。

次は、reverse()メソッド の使用例となります。

# reverse()メソッドの使用例

numbers = [24, 45, 12, 9, 4, 35] # 初期リスト
strings = ['A', 'B', 'C']


# 要素(整数)を並びを逆順にする
numbers.reverse()
print(numbers)      # ➀>>[35, 4, 9, 12, 45, 24] 要素の並びが逆順になった


# 要素(文字列)を並びを逆順にする
strings.reverse()
print(strings)      # ➁>>['C', 'B', 'A']

reverse()の実行結果

要素を並びを逆順にする

➀ 》[35, 4, 9, 12, 45, 24]

➁ 》[‘C’, ‘B’, ‘A’]

3.3 要素の位置(インデックス)を調べる <index()>

Listオブジェクトの要素の位置(インデックス)を調べるには index()メソッド を使います。書式と概略図は次のとおりです。

index()メソッド

Listオブジェクト.index(serch_val)


引数: search_val: 位置(インデックス)を調べたい要素を指定する

戻り値:インデクス

index関数のイメージ
図9. indexメソッド概略図

引数に指定した値がリストのどの位置にあるのかを調べそのインデックスを返します。もし、リスト内に存在しなかった場合は「ValueError」が発生しますので、先の<1.5項>のサンプルコードのように、あらかじめ inステートメント などで要素の存在を調べた上で実行するのがよいでしょう。


次はindex()メソッドの使用例となります。

# index()メソッドの使用例

list_A = ["apple", "orange",123 , "banana", "remon"]


# 要素のインデックスを調べる
print(list_A.index("apple"))  # ➀>>0 インデックス0の要素である
print(list_A.index("orange")) # ➁>>1 インデックス1の要素である
print(list_A.index(123))      # ➂>>2 インデックス2の要素である

#-------------------------------------------------------------------

# リストに存在しない場合はエラーが発生する
print(list_A.index("xyz")) # ➃>>ValueError: 'xyz' is not in list

index()の実行結果

要素のインデックスを調べる

➀ 》0

➁ 》1

➂ 》2

➃ 》ValueError: ‘xyz’ is not in list

3.4 特定の要素の個数を調べる <count()>

リスト内に特定の要素が何個含まれているかを調べる方法のひとつに count()メソッド があります。書式と概略図は次のとおりです。

count()メソッド

Listオブジェクト.count(target_val)


引数:target_val:個数を調べる要素(値)を指定する

戻り値:リスト内に含まれるtarget_valの個数(存在しなかった場合は、0が戻る)

count関数のイメージ
図10. countメソッド概略図

引数に指定した要素(値)がリスト中に何個含まれるかを数えます。部分一致ではなく完全一致したものをカウントします。たとえば、「a」[aa]の要素は別物としてカウントします。なお、リスト中に存在しなかった場合は0を戻します。(エラーとはなりません)


次は、count()メソッドの使用例を示します。リスト中に存在しない値を指定してもエラーとはならずに0が戻ります。また、「a」[aa][ab]などは別ものとして認識され完全一致した値のみをカウントしていることが確認できます。

# count()メソッドの使用例

numbers = [1, 2, 2, 3, 3, 3, 4, 5, 6]

print(numbers.count(1))  # >> 1
print(numbers.count(2))  # >> 2
print(numbers.count(3))  # >> 3
print(numbers.count(9))  # >> 0

#-------------------------------------------------------------------

words = ['a','a','a','aa','ab','b','b','c','e', 1]

print(words.count('a'))  # >>3 完全一致した場合カウントする'aa', 'ab'など部分一致はカントしない
print(words.count('aa')) # >>1
print(words.count('ab')) # >>1
print(words.count('b'))  # >>2
print(words.count(1))    # >>1 文字・数値が混在したリストからでもカウントすることができる

4. まとめ

いかがでしたでしょうか。

今回はPythonが提供するデータ構造のリスト<List>について解説をしました。

冒頭にも触れましたが、Pythonではリスト(配列)を介してデータ処理を行うプログラミング言語です。今回紹介した、リストの概要や生成方法・リスト型の関連メソッド(関数)は重要であり習得しておきたい内容となりますので、最後にポイントをもう一度整理しておきましょう。

データ構造<List>のポイント
  • データを構成する要素は自在に追加・削除・挿入を行うことができる
  • 異なるデータ型の要素を混在させることができる
  • 同じ値をもつ要素が複数含むことができる
  • 他言語の配列に相当する。(アドレス空間を意識する必要は基本ない)
  • Listオブジェクトには様々なメソッドが用意されている。

また、関連記事としてリスト<List>の参照や更新・連結・比較の解説をしています。 是非こちらもご参照いただければと思います。

最後までお読みいただきありがとうございました。

タイトルとURLをコピーしました