Pythonのリスト（list）入門：基本操作徹底解説
はじめに：Pythonプログラミングにおけるデータの管理
プログラミングにおいて、単一のデータを扱うことはもちろん重要ですが、複数のデータをまとめて効率的に扱うことはさらに一般的であり、必要不可欠なスキルです。例えば、クラスの生徒の点数リスト、オンラインストアの商品の在庫リスト、ゲームのキャラクターの座標リストなど、現実世界の多くの情報は複数の関連データの集まりとして表現されます。
Pythonには、このような複数のデータを整理し、操作するための強力なデータ構造がいくつか用意されています。その中でも最も基本的で、最もよく使われるのが「リスト（list）」です。リストは非常に柔軟で、多様な場面で活用できます。Pythonプログラマーにとって、リストをマスターすることは、Pythonによるプログラミング能力を飛躍的に向上させるための第一歩と言えるでしょう。
この記事では、Pythonのリストに焦点を当て、その定義から基本的な作成、アクセス、変更、操作方法までを徹底的に解説します。約5000語のボリュームで、各操作について豊富なコード例とともに詳しく説明しますので、Python初心者の方でもリストの概念と使い方をしっかりと理解できるようになることを目指します。リストの基本をしっかりと身につけ、Pythonプログラミングの世界をさらに深く探求しましょう。
1. Pythonリストとは？：その本質を理解する
Pythonのリストは、順序付けられた、変更可能な（ミュータブルな）、異種要素を含むことができるコレクションです。これはPythonの組み込み型であり、非常に強力で柔軟なデータ構造です。
1.1. 定義：[]で囲まれたシーケンス
リストは角括弧 [] を使って表現され、要素はカンマ , で区切られます。
“`python
空のリスト
empty_list = []
数値のリスト
numbers = [1, 2, 3, 4, 5]
文字列のリスト
fruits = [‘apple’, ‘banana’, ‘cherry’]
異なる型の要素を含むリスト
mixed_list = [1, ‘hello’, 3.14, True]
“`
1.2. 順序付けられている：インデックスの存在
リストの要素は追加された順序、あるいは明示的に指定された順序で並びます。この順序は保たれます。各要素は、その位置を示すインデックスを持ちます。インデックスは0から始まり、リストの最初の要素がインデックス0、次の要素がインデックス1、というように続きます。
順序があるということは、リストの要素には位置情報があり、その位置を使って特定の要素にアクセスできることを意味します。
1.3. 変更可能（ミュータブル）：後から要素を変えられる
リストは「ミュータブル（mutable）」なオブジェクトです。これは、リストを作成した後でも、その要素を変更したり、新しい要素を追加したり、既存の要素を削除したりできるという意味です。この性質は、後から内容が変わる可能性のあるデータを扱うのに非常に便利です。
“`python
my_list = [10, 20, 30]
print(my_list) # 出力: [10, 20, 30]
要素を変更
my_list[1] = 25
print(my_list) # 出力: [10, 25, 30]
要素を追加
my_list.append(40)
print(my_list) # 出力: [10, 25, 30, 40]
“`
変更可能性はリストの大きな特徴であり、文字列（str）やタプル（tuple）といったPythonの他のシーケンス型との重要な違いの一つです。文字列やタプルは「イミュータブル（immutable）」、つまり作成後に内容を変更できません。
1.4. 異種要素を含むことができる：柔軟性
リストの要素は、数値、文字列、ブール値など、どのような型のオブジェクトでも構いません。さらに、リストの中に別のリストを含めることもできます（ネストされたリスト）。
python
mixed_list = [1, 'apple', 3.14, True, [10, 20]]
print(mixed_list) # 出力: [1, 'apple', 3.14, True, [10, 20]]
この柔軟性により、リストは非常に多様な種類のデータをまとめて扱うことができます。
1.5. シーケンス型：共通操作
リストはPythonの「シーケンス型」の一種です。シーケンス型には他に文字列（str）、タプル（tuple）などがあります。これらの型は、順序付けられているという特徴を共有しており、共通の操作が可能です。例えば、インデックスを使ったアクセス、スライス、len()関数による長さの取得、forループによる要素の繰り返し処理などです。
まとめると、Pythonのリストは、順序付き、変更可能、異種要素混在可能という特徴を持つ、非常に柔軟で汎用性の高いデータ構造です。これらの特徴を理解することが、リストを効果的に使う上での基礎となります。
2. リストの作成：様々な方法
リストを作成する方法はいくつかあります。状況に応じて最適な方法を選べます。
2.1. 空のリストを作成する
最も基本的な方法は、角括弧 [] を使う方法と、組み込み関数 list() を使う方法です。
“`python
角括弧を使う方法
empty_list_1 = []
print(empty_list_1) # 出力: []
list() 関数を使う方法
empty_list_2 = list()
print(empty_list_2) # 出力: []
“`
どちらの方法でも同じ空のリストが作成されます。通常は [] を使う方が簡潔なのでよく使われます。
2.2. 初期値を指定してリストを作成する
作成時にすでに含めたい要素が決まっている場合は、角括弧の中に要素をカンマ区切りで列挙します。
“`python
数値リスト
prime_numbers = [2, 3, 5, 7, 11]
print(prime_numbers) # 出力: [2, 3, 5, 7, 11]
文字列リスト
colors = [‘red’, ‘green’, ‘blue’]
print(colors) # 出力: [‘red’, ‘green’, ‘blue’]
異なる型を含むリスト
student_info = [‘Alice’, 20, 165.5, True]
print(student_info) # 出力: [‘Alice’, 20, 165.5, True]
リストのリスト（ネストされたリスト）
matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix) # 出力: [[1, 2], [3, 4], [5, 6]]
“`
2.3. list() コンストラクタを使った作成
list() 関数は、他のイテラブル（iterable）なオブジェクト（文字列、タプル、rangeオブジェクト、他のリストなど）をリストに変換するためにも使われます。
“`python
文字列からリストを作成（各文字が要素になる）
text = “Python”
list_from_string = list(text)
print(list_from_string) # 出力: [‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]
タプルからリストを作成
my_tuple = (1, 2, 3)
list_from_tuple = list(my_tuple)
print(list_from_tuple) # 出力: [1, 2, 3]
rangeオブジェクトからリストを作成
numbers_list = list(range(5)) # range(5) は 0, 1, 2, 3, 4 というシーケンスを生成
print(numbers_list) # 出力: [0, 1, 2, 3, 4]
“`
2.4. リスト内包表記（List Comprehensions）による作成
リスト内包表記は、既存のリストや他のイテラブルから新しいリストを効率的かつ簡潔に作成するためのPythonらしい方法です。これは [式 for 要素 in イテラブル if 条件] のような構文をとります。
“`python
0から9までの数値のリストを作成
numbers = [i for i in range(10)]
print(numbers) # 出力: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0から9までの偶数のリストを作成（条件付き）
even_numbers = [i for i in range(10) if i % 2 == 0]
print(even_numbers) # 出力: [0, 2, 4, 6, 8]
文字列のリストから、各文字列の長さを要素とするリストを作成
words = [‘apple’, ‘banana’, ‘cherry’]
word_lengths = [len(word) for word in words]
print(word_lengths) # 出力: [5, 6, 6]
元のリストの各要素を2倍した新しいリストを作成
original_list = [1, 2, 3, 4]
doubled_list = [x * 2 for x in original_list]
print(doubled_list) # 出力: [2, 4, 6, 8]
“`
リスト内包表記は、コードを短く、読みやすくする強力なツールです。特に、簡単なループ処理で新しいリストを作成する場合に非常に役立ちます。
リストを作成する方法は複数ありますが、目的や元となるデータに応じて適切な方法を選ぶことが重要です。
3. リストへのアクセス：要素や部分を取り出す
リストの要素は順序付けられているため、その位置（インデックス）を使って個々の要素にアクセスしたり、複数の要素をまとめて取り出したり（スライス）することができます。
3.1. インデックスを使ったアクセス
リストの各要素は、0から始まるインデックスで識別されます。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’, ‘date’, ‘elderberry’]
最初の要素（インデックス0）
print(fruits[0]) # 出力: apple
3番目の要素（インデックス2）
print(fruits[2]) # 出力: cherry
“`
負のインデックス
Pythonでは、リストの末尾から要素にアクセスするために負のインデックスも使用できます。インデックス -1 は最後の要素、-2 は最後から2番目の要素、というようになります。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’, ‘date’, ‘elderberry’]
最後の要素（インデックス -1）
print(fruits[-1]) # 出力: elderberry
最後から2番目の要素（インデックス -2）
print(fruits[-2]) # 出力: date
“`
負のインデックスは、リストの長さを知らなくても末尾の要素に簡単にアクセスできるため便利です。
インデックスエラー (IndexError)
存在しないインデックスにアクセスしようとすると、IndexErrorが発生します。
“`python
my_list = [10, 20, 30]
存在しないインデックスにアクセス
print(my_list[3])
これを実行すると IndexError: list index out of range が発生します
負のインデックスでも同様
print(my_list[-4])
これを実行すると IndexError: list index out of range が発生します
“`
リストにアクセスする際は、インデックスが有効な範囲内にあるか注意が必要です。リストの有効なインデックスの範囲は -[リストの長さ] から リストの長さ - 1 です。
3.2. スライスを使ったアクセス：部分リストの取得
スライスは、リストの連続した部分（サブリスト）を新しいリストとして取り出すための強力な機能です。スライスは [start:stop:step] の形式で指定します。
start: スライスを開始するインデックス（含まれる）。省略された場合はリストの先頭（0）から。stop: スライスを終了するインデックス（含まれない）。省略された場合はリストの末尾まで。step: 要素をスキップする間隔。デフォルトは1（1つずつ進む）。省略された場合は1。
基本的なスライス [start:stop]
step を省略した場合、start から stop の手前までの要素を含む新しいリストが作成されます。
“`python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
インデックス2から5の手前まで（インデックス2, 3, 4の要素）
print(numbers[2:5]) # 出力: [2, 3, 4]
インデックス0から4の手前まで（インデックス0, 1, 2, 3の要素）
print(numbers[0:4]) # 出力: [0, 1, 2, 3]
“`
start または stop の省略
start を省略すると、リストの先頭から始まります。stop を省略すると、リストの末尾まで含まれます。
“`python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
先頭からインデックス5の手前まで
print(numbers[:5]) # 出力: [0, 1, 2, 3, 4]
インデックス5から末尾まで
print(numbers[5:]) # 出力: [5, 6, 7, 8, 9]
全体のコピー（startもstopも省略）
print(numbers[:]) # 出力: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
“`
[:] はリストのシャローコピーを作成する一般的な方法です。
step を指定したスライス [start:stop:step]
step を指定すると、指定した間隔で要素を取り出せます。
“`python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1つおきに要素を取得（インデックス0から末尾まで、ステップ2）
print(numbers[::2]) # 出力: [0, 2, 4, 6, 8]
インデックス1から末尾まで、1つおきに要素を取得
print(numbers[1::2]) # 出力: [1, 3, 5, 7, 9]
インデックス2から8の手前まで、ステップ2で取得
print(numbers[2:8:2]) # 出力: [2, 4, 6]
“`
負の step
step に負の値を指定すると、リストを逆方向にスライスできます。
“`python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
リストを完全に反転
print(numbers[::-1]) # 出力: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
末尾から先頭へ、1つおきに取得
print(numbers[::-2]) # 出力: [9, 7, 5, 3, 1]
“`
負のステップを使う場合、start と stop の意味合いが逆転することに注意が必要です。例えば [5:2:-1] はインデックス5から始まり、2の手前まで（つまり3まで）を逆順に進みます。
python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[5:2:-1]) # 出力: [5, 4, 3]
スライスの結果は新しいリスト
スライス操作によって得られる結果は、常に新しいリストです。元のリストの一部を指しているわけではありません。
“`python
original = [1, 2, 3, 4, 5]
subset = original[1:4]
print(subset) # 出力: [2, 3, 4]
新しいリストなので、subsetを変更してもoriginalは変わらない
subset[0] = 99
print(subset) # 出力: [99, 3, 4]
print(original) # 出力: [1, 2, 3, 4, 5]
“`
この性質は、リストの変更や操作を行う際に重要になります。
リストへのアクセス（インデックスとスライス）は、リストの要素を取り出すための最も基本的な方法です。これらの操作をマスターすることで、リスト内の特定のデータや範囲に効率的にアクセスできるようになります。
4. リストの要素の変更、追加、削除：リストの可変性を活用する
リストはミュータブルであるため、作成後に要素を変更したり、新しい要素を追加したり、不要な要素を削除したりできます。
4.1. 要素の変更
インデックスを使った単一要素の変更
特定のインデックスにある要素は、インデックスを指定して新しい値を代入することで変更できます。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’]
print(fruits) # 出力: [‘apple’, ‘banana’, ‘cherry’]
インデックス1の要素を’grape’に変更
fruits[1] = ‘grape’
print(fruits) # 出力: [‘apple’, ‘grape’, ‘cherry’]
“`
存在しないインデックスを指定すると IndexError が発生します。
スライスを使った複数要素の変更・置き換え
スライスを使ってリストの一部分を、別のリストの要素で置き換えることもできます。置き換える側のリストの要素数と、置き換えられる側のスライスの要素数が異なっていても構いません。これにより、リストのサイズが変わることがあります。
“`python
numbers = [1, 2, 3, 4, 5]
print(numbers) # 出力: [1, 2, 3, 4, 5]
インデックス1から3の手前まで（要素2, 3）を[‘a’, ‘b’, ‘c’]で置き換え
numbers[1:3] = [‘a’, ‘b’, ‘c’]
print(numbers) # 出力: [1, ‘a’, ‘b’, ‘c’, 4, 5] # 要素数が変わった
インデックス0から2の手前まで（要素1, ‘a’）を[‘x’]で置き換え
numbers[0:2] = [‘x’]
print(numbers) # 出力: [‘x’, ‘b’, ‘c’, 4, 5] # さらに要素数が変わった
スライスを使って空のリストで置き換える = 削除と同じ効果
numbers[1:4] = []
print(numbers) # 出力: [‘x’, 5]
“`
このスライス代入は非常に柔軟で強力な機能です。
4.2. 要素の追加
append()：末尾に単一要素を追加
append() メソッドは、リストの末尾に単一の要素を追加します。リストを1つだけ追加したい場合でも、そのリスト全体が1つの要素として追加されます。
“`python
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # 出力: [1, 2, 3, 4]
リストを要素として追加
my_list.append([5, 6])
print(my_list) # 出力: [1, 2, 3, 4, [5, 6]]
“`
append() はリストそのものを変更する破壊的な操作です。戻り値は None です。
extend()：リストや他のイテラブルの要素を末尾に追加
extend() メソッドは、引数に指定したイテラブル（リスト、タプル、文字列など）の各要素を取り出し、それを元のリストの末尾に順番に追加します。
“`python
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) # 出力: [1, 2, 3, 4, 5, 6] # list2の要素が分解されて追加された
my_list = [10, 20]
my_list.extend(‘abc’) # 文字列もイテラブル
print(my_list) # 出力: [10, 20, ‘a’, ‘b’, ‘c’]
my_list = [100, 200]
my_list.extend((300, 400)) # タプルもイテラブル
print(my_list) # 出力: [100, 200, 300, 400]
“`
extend() もリストそのものを変更する破壊的な操作で、戻り値は None です。append() と extend() の違いは、引数がリストである場合に顕著です。append() は引数のリストをそのまま単一要素として追加し、extend() は引数のリストの要素を分解して追加します。
insert()：指定した位置に要素を挿入
insert(index, element) メソッドは、指定した index の位置に element を挿入します。既存の要素は後方にシフトされます。
“`python
my_list = [‘a’, ‘b’, ‘d’]
my_list.insert(2, ‘c’) # インデックス2の位置に’c’を挿入
print(my_list) # 出力: [‘a’, ‘b’, ‘c’, ‘d’]
my_list.insert(0, ‘start’) # 先頭に挿入
print(my_list) # 出力: [‘start’, ‘a’, ‘b’, ‘c’, ‘d’]
my_list.insert(100, ‘end’) # 存在しない大きなインデックスを指定すると末尾に追加される
print(my_list) # 出力: [‘start’, ‘a’, ‘b’, ‘c’, ‘d’, ‘end’]
“`
insert() もリストそのものを変更する破壊的な操作で、戻り値は None です。
加算演算子 + による結合
2つのリストを + 演算子で結合すると、新しいリストが生成されます。元のリストは変更されません。
python
list1 = [1, 2]
list2 = [3, 4]
combined_list = list1 + list2
print(combined_list) # 出力: [1, 2, 3, 4]
print(list1) # 出力: [1, 2] # 元のリストは変わらない
print(list2) # 出力: [3, 4] # 元のリストは変わらない
この方法は新しいリストを作成するため、元のリストを保持したい場合に便利です。ただし、大きなリストを繰り返し結合する場合、新しいリストの生成オーバーヘッドが発生するため、パフォーマンスに影響を与える可能性があります。多数の要素を効率的に追加したい場合は extend() を使う方が良いことが多いです。
乗算演算子 * による繰り返し
リストを整数で * 演算子を使うと、そのリストの要素を指定した回数だけ繰り返した新しいリストが生成されます。
“`python
my_list = [0, 1]
repeated_list = my_list * 3
print(repeated_list) # 出力: [0, 1, 0, 1, 0, 1]
zero_list = [0] * 5
print(zero_list) # 出力: [0, 0, 0, 0, 0]
“`
これも新しいリストを生成する非破壊的な操作です。ただし、繰り返されるリストの中にミュータブルなオブジェクト（例えば別のリスト）が含まれている場合、そのミュータブルなオブジェクトは同じものが繰り返し参照されるため、注意が必要です。
“`python
NG 例: 内側のリストがミュータブルな場合
matrix = [[0]] * 3
print(matrix) # 出力: [[0], [0], [0]]
内側のリストを変更してみる
matrix[0][0] = 99
print(matrix) # 出力: [[99], [99], [99]] # 全ての要素が変わってしまった！
“`
このように、[[0]] * 3 は [[0], [0], [0]] のように見えますが、実際には3つの外側のリスト要素がすべて同じ内側のリストオブジェクト [0] を参照しています。そのため、1つの内側のリストを変更すると、他の全ての内側のリストも変更されたように見えます。
このようなネストされたミュータブルなリストを作成したい場合は、リスト内包表記を使うのが安全です。
“`python
OK 例: リスト内包表記を使う
matrix = [[0] for _ in range(3)]
print(matrix) # 出力: [[0], [0], [0]]
内側のリストを変更してみる
matrix[0][0] = 99
print(matrix) # 出力: [[99], [0], [0]] # 変更されたのは最初の要素だけ
“`
これは、リスト内包表記がループごとに新しい [0] リストを作成するためです。
4.3. 要素の削除
要素を削除する方法もいくつかあります。
del ステートメント：インデックスやスライスを指定して削除
del キーワードを使用すると、指定したインデックスの単一要素、または指定したスライスの複数要素をリストから削除できます。
“`python
my_list = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
print(my_list) # 出力: [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
インデックス2の要素を削除
del my_list[2] # ‘c’が削除される
print(my_list) # 出力: [‘a’, ‘b’, ‘d’, ‘e’]
インデックス1から3の手前まで（’b’, ‘d’）を削除
del my_list[1:3]
print(my_list) # 出力: [‘a’, ‘e’]
リスト全体を削除（リスト自体がメモリから解放される）
del my_list
print(my_list) # これを実行すると NameError が発生します
“`
del ステートメントは非常に柔軟ですが、リストを直接変更するため、特にループ処理中に使う場合は注意が必要です。
remove()：値を指定して削除
remove(value) メソッドは、リスト内で最初に見つかった指定した値を持つ要素を削除します。
“`python
my_list = [‘apple’, ‘banana’, ‘cherry’, ‘banana’]
print(my_list) # 出力: [‘apple’, ‘banana’, ‘cherry’, ‘banana’]
最初に見つかった’banana’を削除
my_list.remove(‘banana’)
print(my_list) # 出力: [‘apple’, ‘cherry’, ‘banana’]
“`
指定した値がリスト内に存在しない場合は、ValueErrorが発生します。
“`python
my_list = [1, 2, 3]
my_list.remove(4)
これを実行すると ValueError: list.remove(x): x not in list が発生します
“`
remove() もリストそのものを変更する破壊的な操作で、戻り値は None です。
pop()：指定した位置の要素を削除し、その値を返す
pop(index) メソッドは、指定した index の要素をリストから削除し、削除したその要素の値を返します。インデックスを省略した場合（pop()）、リストの末尾の要素が削除され、その値が返されます。
“`python
my_list = [‘a’, ‘b’, ‘c’, ‘d’]
print(my_list) # 出力: [‘a’, ‘b’, ‘c’, ‘d’]
インデックス1の要素を削除し、その値を取得
removed_element = my_list.pop(1)
print(removed_element) # 出力: b
print(my_list) # 出力: [‘a’, ‘c’, ‘d’]
インデックスを指定しない場合は末尾を削除
last_element = my_list.pop()
print(last_element) # 出力: d
print(my_list) # 出力: [‘a’, ‘c’]
“`
存在しないインデックスを指定すると IndexError が発生します。
pop() は要素を削除しつつ、その値を後続の処理で使いたい場合に便利です。例えば、スタック（stack）やキュー（queue）のようなデータ構造をリストで実装する際によく使われます（スタックの場合は append() と pop()、キューの場合は append() と pop(0)）。
clear()：リストのすべての要素を削除
clear() メソッドは、リストのすべての要素を削除し、リストを空にします。リストオブジェクト自体は削除されません。
“`python
my_list = [1, 2, 3, 4, 5]
print(my_list) # 出力: [1, 2, 3, 4, 5]
my_list.clear()
print(my_list) # 出力: []
“`
これは del my_list[:] と同じ効果があります。
まとめると、リストの要素の変更、追加、削除には様々な方法があります。単一要素の変更にはインデックス代入、複数要素にはスライス代入。追加には末尾への append、複数の要素を分解しての追加には extend、任意の位置への挿入には insert。削除にはインデックス/スライス指定の del、値指定の remove、位置指定かつ値取得が必要な pop、全要素削除の clear があります。これらの操作を使い分けることで、リストの内容を柔軟に管理できます。
5. リストの操作とメソッド：リストをさらに活用する
Pythonのリストには、要素数を知る、要素を検索する、並べ替えるなど、様々な操作や便利なメソッドが用意されています。
5.1. リストの要素数を知る：len() 関数
リストに含まれる要素の数は、組み込み関数 len() を使って取得できます。
“`python
my_list = [10, 20, 30, 40, 50]
print(len(my_list)) # 出力: 5
empty_list = []
print(len(empty_list)) # 出力: 0
“`
5.2. 要素の存在確認：in 演算子
特定の要素がリスト内に存在するかどうかは、in 演算子を使って確認できます。結果はブール値（True または False）になります。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’]
print(‘banana’ in fruits) # 出力: True
print(‘grape’ in fruits) # 出力: False
print(‘apple’ not in fruits) # 出力: False (存在しないことの確認)
“`
5.3. 要素のインデックスを取得する：index()
index(value, start, end) メソッドは、リスト内で最初に見つかった指定した value のインデックスを返します。オプションで検索を開始・終了するインデックス start と end を指定できます。
“`python
my_list = [‘a’, ‘b’, ‘c’, ‘b’, ‘d’]
print(my_list.index(‘c’)) # 出力: 2 (最初に見つかった’c’のインデックス)
print(my_list.index(‘b’)) # 出力: 1 (最初に見つかった’b’のインデックス)
print(my_list.index(‘b’, 2)) # インデックス2以降で’b’を検索 -> 出力: 3
print(my_list.index(‘b’, 0, 2)) # インデックス0から2の手前までで’b’を検索 -> 出力: 1
“`
指定した値がリスト内に存在しない場合は、ValueErrorが発生します。
“`python
my_list = [1, 2, 3]
print(my_list.index(4))
これを実行すると ValueError: 4 is not in list が発生します
“`
5.4. 要素の出現回数をカウントする：count()
count(value) メソッドは、リスト内に指定した value がいくつ含まれているかを返します。
“`python
my_list = [1, 2, 3, 2, 1, 2, 4]
print(my_list.count(2)) # 出力: 3
print(my_list.count(1)) # 出力: 2
print(my_list.count(5)) # 出力: 0 (存在しない要素は0を返す)
“`
5.5. リストをソートする：sort() と sorted()
リストを要素の順序で並べ替えるには、2つの方法があります。
sort()：リストをインプレースでソート（破壊的）
sort() メソッドは、リストそのものを直接変更し、要素を昇順に並べ替えます。戻り値は None です。
“`python
numbers = [5, 2, 8, 1, 9]
numbers.sort()
print(numbers) # 出力: [1, 2, 5, 8, 9]
降順にソートしたい場合は reverse=True 引数を使用
fruits = [‘banana’, ‘apple’, ‘cherry’]
fruits.sort(reverse=True)
print(fruits) # 出力: [‘cherry’, ‘banana’, ‘apple’]
“`
異なる型の要素が混在するリストをソートしようとすると、型エラーが発生することがあります（比較できない型の場合）。
sort() には key 引数を指定することで、要素自体ではなく、各要素に特定の関数を適用した結果に基づいてソートすることも可能です。
“`python
words = [‘banana’, ‘Apple’, ‘cherry’, ‘Date’]
通常のアルファベット順（大文字小文字を区別）
words.sort()
print(words) # 出力: [‘Apple’, ‘Date’, ‘banana’, ‘cherry’]
文字列を全て小文字にしてから比較（大文字小文字を区別しないソート）
words.sort(key=str.lower)
print(words) # 出力: [‘Apple’, ‘banana’, ‘cherry’, ‘Date’]
文字列の長さを基準にソート
words.sort(key=len)
print(words) # 出力: [‘Date’, ‘Apple’, ‘cherry’, ‘banana’]
“`
key 引数は、ソートの基準となる「キー」を計算するための関数を指定します。この関数はリストの各要素を引数として受け取り、ソート時にはその戻り値が比較に使用されます。
sorted()：新しいソート済みリストを返す（非破壊的）
組み込み関数 sorted(iterable, key=None, reverse=False) は、指定したイテラブル（リストに限らず、タプルや文字列なども可）の要素をソートした新しいリストを返します。元のイテラブルは変更されません。
“`python
numbers = [5, 2, 8, 1, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 出力: [1, 2, 5, 8, 9]
print(numbers) # 出力: [5, 2, 8, 1, 9] # 元のリストはそのまま
fruits = [‘banana’, ‘apple’, ‘cherry’]
sorted_fruits_desc = sorted(fruits, reverse=True)
print(sorted_fruits_desc) # 出力: [‘cherry’, ‘banana’, ‘apple’]
print(fruits) # 出力: [‘banana’, ‘apple’, ‘cherry’] # 元のリストはそのまま
“`
sorted() 関数も key 引数をサポートしており、sort() メソッドと同様に使えます。
どちらを使うかは、元のリストを破壊的に変更したいか、それとも新しいソート済みリストが必要かで判断します。
5.6. リストを反転する：reverse()
reverse() メソッドは、リストの要素の順序をインプレースで反転させます。戻り値は None です。
python
my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list) # 出力: [5, 4, 3, 2, 1]
これは要素の値を逆順に並べ替えるのではなく、要素の物理的な位置を反転させる点に注意してください。ソートとは異なります。リストをソートした後に逆順にしたい場合は、sort() や sorted() の reverse=True を使う方が意図が明確になります。
リストの逆順を新しいリストとして取得したい場合は、スライス [::-1] を使うのが一般的です。
python
my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list) # 出力: [5, 4, 3, 2, 1]
print(my_list) # 出力: [1, 2, 3, 4, 5] # 元のリストはそのまま
5.7. リストのコピー：シャローコピーとディープコピーの重要性
リストはミュータブルなオブジェクトです。これは、変数にリストを代入する際に、リストそのものではなく、リストが格納されているメモリ上の場所（参照）がコピーされるという重要な意味を持ちます。
“`python
list1 = [1, 2, 3]
list2 = list1 # list1の参照をlist2に代入
print(list1) # 出力: [1, 2, 3]
print(list2) # 出力: [1, 2, 3]
list2を変更すると、list1も変更される！
list2.append(4)
print(list1) # 出力: [1, 2, 3, 4]
print(list2) # 出力: [1, 2, 3, 4]
これは list1 と list2 が同じリストオブジェクトを参照しているため
print(id(list1)) # 例: 140700790235776
print(id(list2)) # 例: 140700790235776 (list1と同じID)
“`
このように、単なる代入 = ではリストのコピーは作られず、同じリストへの参照が共有されます。リストの独立したコピーが必要な場合は、明示的にコピーを作成する必要があります。
シャローコピー (Shallow Copy)
シャローコピーは、元のリストとその直下の要素をコピーして新しいリストを作成します。ただし、要素自体がミュータブルなオブジェクト（別のリストなど）である場合、そのミュータブルなオブジェクトはコピーされず、元のリストとコピーされたリストで共有されます。
シャローコピーを作成する方法はいくつかあります。
1. copy() メソッドを使用する
2. スライス [:] を使用する
3. list() コンストラクタを使用する
“`python
original_list = [1, 2, [3, 4]] # 内側にミュータブルなリストを含む
copy() メソッド
shallow_copy_1 = original_list.copy()
print(shallow_copy_1) # 出力: [1, 2, [3, 4]]
スライス [:]
shallow_copy_2 = original_list[:]
print(shallow_copy_2) # 出力: [1, 2, [3, 4]]
list() コンストラクタ
shallow_copy_3 = list(original_list)
print(shallow_copy_3) # 出力: [1, 2, [3, 4]]
いずれも新しいリストオブジェクトであることは確認できる
print(id(original_list)) # 例: 140700790235776
print(id(shallow_copy_1)) # 例: 140700806300992 (original_listと異なるID)
“`
さて、シャローコピーの場合に何が起きるかを見てみましょう。
“`python
original_list = [1, 2, [3, 4]]
shallow_copy = original_list.copy()
外側の要素を変更
original_list[0] = 99
print(original_list) # 出力: [99, 2, [3, 4]]
print(shallow_copy) # 出力: [1, 2, [3, 4]] # シャローコピーには影響しない (トップレベルの要素はコピーされているため)
内側のミュータブルな要素を変更
original_list[2].append(5)
print(original_list) # 出力: [99, 2, [3, 4, 5]]
print(shallow_copy) # 出力: [1, 2, [3, 4, 5]] # シャローコピーも影響を受けてしまった！
“`
これは、original_list[2] と shallow_copy[2] が、どちらも同じ内側のリストオブジェクト [3, 4] を参照しているためです。これがシャローコピーの挙動です。トップレベルの要素はコピーされますが、ネストされたミュータブルなオブジェクトは参照が共有されます。
ディープコピー (Deep Copy)
ディープコピーは、元のリストとその中に含まれるすべてのオブジェクト（ネストされたミュータブルなオブジェクトも含む）を再帰的にコピーして、完全に独立した新しいリストを作成します。これには copy モジュールの deepcopy() 関数を使用します。
“`python
import copy
original_list = [1, 2, [3, 4]]
ディープコピーを作成
deep_copy = copy.deepcopy(original_list)
print(deep_copy) # 出力: [1, 2, [3, 4]]
内側のミュータブルな要素を変更
original_list[2].append(5)
print(original_list) # 出力: [1, 2, [3, 4, 5]]
print(deep_copy) # 出力: [1, 2, [3, 4]] # ディープコピーは影響を受けない！
“`
ディープコピーは完全に独立したコピーを作成するため、元のリストやそのネストされた要素の変更がコピーに影響することはありません。
リストをコピーする際は、ネストされたミュータブルな要素があるかどうか、そしてその要素の変更がコピーに影響しても良いかどうかを考慮し、シャローコピーかディープコピーかを選択する必要があります。通常、ネストされたミュータブルなオブジェクトがなく、単純なコピーで十分な場合は、スライス [:] や copy() メソッドによるシャローコピーが簡潔で効率的です。完全に独立したコピーが必要な場合は copy.deepcopy() を使用します。
6. リストのループ処理：要素を順番に扱う
リストの要素を一つずつ取り出して処理することは非常によく行われます。Pythonではいくつかの方法でリストをループ処理できます。
6.1. for ループを使った基本的なイテレーション
最も一般的でPythonらしい方法は、for ループを使ってリストの要素を直接イテレートすることです。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’]
for fruit in fruits:
print(fruit)
“`
出力:
apple
banana
cherry
この方法では、ループごとにリストの次の要素が変数 fruit に代入され、ループブロックが実行されます。シンプルで読みやすく、要素自体にのみ関心がある場合に最適です。
6.2. range() とインデックスを使ったループ
C言語などの影響を受けたプログラミング言語では、インデックスを使ってループすることが一般的です。Pythonでもリストの長さを len() で取得し、range() と組み合わせてインデックスを生成し、そのインデックスを使ってリストの要素にアクセスすることで同様のループが可能です。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’]
for i in range(len(fruits)):
print(f”Index {i}: {fruits[i]}”)
“`
出力:
Index 0: apple
Index 1: banana
Index 2: cherry
この方法は、ループ処理中に要素の値だけでなく、そのインデックスも必要となる場合に便利です。ただし、要素自体にしか関心がない場合は、最初の方法（要素を直接イテレート）の方がPython的で推奨されます。
6.3. enumerate() を使ったインデックスと値の同時取得
インデックスと要素の値の両方が必要な場合、range() とインデックスを使うよりも、組み込み関数 enumerate() を使う方がよりPython的で効率的です。enumerate(iterable) は、イテラブルの要素をループしながら、その要素のインデックスと値のペアをタプル (index, value) として生成します。
“`python
fruits = [‘apple’, ‘banana’, ‘cherry’]
for index, fruit in enumerate(fruits):
print(f”Item {index + 1}: {fruit}”) # 1から始まる番号で表示する場合
“`
出力:
Item 1: apple
Item 2: banana
Item 3: cherry
enumerate() は、ループ中にインデックスが必要な場合に非常に便利です。デフォルトではインデックスは0から始まりますが、enumerate(iterable, start=1) のように start 引数を指定することで開始インデックスを変更することも可能です。
6.4. リスト内包表記によるループ処理（繰り返し操作やフィルタリング）
リスト内包表記は、ループ処理の結果として新しいリストを作成する場合に非常に強力です。前述の「2.4. リスト内包表記」で基本的な使い方を見ましたが、これは実質的にループと要素の変換・フィルタリングを組み合わせたものです。
“`python
numbers = [1, 2, 3, 4, 5]
各要素を2乗したリストを作成 (変換)
squares = [x**2 for x in numbers]
print(squares) # 出力: [1, 4, 9, 16, 25]
偶数のみを含むリストを作成 (フィルタリング)
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers) # 出力: [2, 4]
偶数のみを2乗したリストを作成 (変換とフィルタリング)
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares) # 出力: [4, 16]
“`
リスト内包表記は、単純なループと append() で新しいリストを作成するよりも、簡潔で読みやすく、多くの場合で高速です。
リストのループ処理は、リスト内のすべての要素に対して何らかの操作を行いたい場合に不可欠です。for ループ（要素直接）、for + range + len （インデックス使用）、for + enumerate （インデックスと値両方）、そして新しいリスト生成のためのリスト内包表記など、状況に応じて適切な方法を選びましょう。
7. リストと他のデータ型：比較と関連
Pythonにはリスト以外にも様々なデータ構造があります。リストがどのような特徴を持ち、他の主要なデータ型とどう異なるかを理解することは、適切なデータ構造を選択する上で重要です。
7.1. 文字列（str）との比較
文字列は、文字のシーケンスという点でリストと似ています。インデックスを使ったアクセスやスライス、len()、in 演算子、for ループによるイテレーションなど、多くのシーケンス操作を共有します。
“`python
my_string = “Python”
my_list = [‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]
print(my_string[0]) # 出力: P
print(my_list[0]) # 出力: P
print(my_string[1:4]) # 出力: yth
print(my_list[1:4]) # 出力: [‘y’, ‘t’, ‘h’]
print(‘P’ in my_string) # 出力: True
print(‘P’ in my_list) # 出力: True
“`
しかし、決定的な違いはミュータブル性です。文字列はイミュータブルであり、一度作成すると内容を変更できません。リストはミュータブルであり、内容を変更できます。
“`python
my_list = [1, 2, 3]
my_list[0] = 99 # OK
print(my_list) # 出力: [99, 2, 3]
my_string = “hello”
my_string[0] = ‘H’ # これはエラーになる (TypeError)
“`
文字列を変更したい場合は、新しい文字列を作成する必要があります。このミュータブル性の違いは、データ構造を選ぶ上での重要な考慮点となります。
7.2. タプル（tuple）との比較
タプルもリストと同様に、順序付けられた要素のシーケンスです。インデックスアクセス、スライス、len()、in 演算子、ループなど、多くのシーケンス操作をリストと共有します。タプルは丸括弧 () または括弧なしで要素をカンマ区切りで表現します（要素が1つの場合はカンマが必要です）。
“`python
my_tuple = (1, 2, 3)
my_list = [1, 2, 3]
print(my_tuple[0]) # 出力: 1
print(my_list[0]) # 出力: 1
print(my_tuple[1:3]) # 出力: (2, 3) (結果はタプル)
print(my_list[1:3]) # 出力: [2, 3] (結果はリスト)
“`
リストとタプルの最も重要な違いは、やはりミュータブル性です。タプルはイミュータブルであり、一度作成すると要素の追加、削除、変更ができません。
“`python
my_list = [1, 2, 3]
my_list.append(4) # OK
my_list[0] = 99 # OK
del my_list[1] # OK
my_tuple = (1, 2, 3)
my_tuple.append(4) # これはエラーになる (AttributeError)
my_tuple[0] = 99 # これはエラーになる (TypeError)
del my_tuple[1] # これはエラーになる (TypeError)
“`
タプルは、変更されることのない固定されたデータの集まり（例えば、座標 (x, y)、RGBカラー値 (r, g, b)、データベースのレコードなど）を表現するのに適しています。リストは、要素が頻繁に追加、削除、変更される可能性がある動的なコレクションに適しています。タプルはリストよりもわずかに高速で、イミュータブルであるため、辞書のキーやセットの要素として使用できますが、リストはできません（リストはハッシュ可能ではないため）。
7.3. セット（set）との比較
セットは、順序付けられていない、重複しない要素のコレクションです。リストのように順序やインデックスはなく、要素の追加や削除は可能ですが、要素の変更はできません（ミュータブルな要素をセットに入れることはできません）。セットは集合論的な操作（和集合、積集合、差集合など）を得意とします。波括弧 {} または set() コンストラクタで表現します（空のセットは {} ではなく set() で作成する必要があります）。
“`python
my_list = [1, 2, 2, 3, 4, 4, 5]
my_set = {1, 2, 2, 3, 4, 4, 5} # 重複は自動的に排除される
print(my_list) # 出力: [1, 2, 2, 3, 4, 4, 5] (順序は保持され、重複もそのまま)
print(my_set) # 出力: {1, 2, 3, 4, 5} (順序は不定、重複は排除)
リストはインデックスでアクセス可能
print(my_list[0]) # 出力: 1
セットはインデックスでアクセスできない
print(my_set[0]) # これはエラーになる (TypeError)
“`
セットは要素の存在確認 (in 演算子) がリストよりも非常に高速です。多数の要素の中から特定の要素を探す必要がある場合は、セットが適していることがあります。リストは要素の順序や重複が重要であり、インデックスによるアクセスやスライスが必要な場合に使用します。
7.4. 辞書（dict）との比較
辞書は、キーと値のペアを格納するコレクションです。リストのように数値インデックスでアクセスするのではなく、キーを使って値にアクセスします。辞書は順序付けられていませんでしたが、Python 3.7以降（Cpython 3.6以降の実装詳細に依存）では挿入順序が保持されるようになりました。辞書は波括弧 {} でキーと値のペアを : で区切り、ペア間をカンマ , で区切って表現します。
“`python
my_list = [‘apple’, ‘banana’, ‘cherry’]
my_dict = {‘fruit1’: ‘apple’, ‘fruit2’: ‘banana’, ‘fruit3’: ‘cherry’}
リストはインデックスでアクセス
print(my_list[0]) # 出力: apple
辞書はキーでアクセス
print(my_dict[‘fruit1’]) # 出力: apple
print(my_dict[0]) # これはエラーになる (KeyError または TypeError)
“`
リストは要素の位置に基づいてアクセスし、辞書は要素の名前（キー）に基づいてアクセスします。リストは順序付きのコレクションで、要素の順番が重要だったり、位置によって要素を特定したりする場合に適しています。辞書は、要素が名前（キー）と関連付けられており、その名前を使って効率的にアクセスしたい場合に適しています。
7.5. リストとミュータブルなオブジェクトに関する注意点（参照渡しのような挙動）
これは「5.7. リストのコピー」で述べたシャローコピーの例で示したように、リストがミュータブルであること、そしてPythonの変数がオブジェクトへの参照を持つことに関連する重要な注意点です。
あるリストを別の変数に単純に代入 (=) した場合、新しいリストが作成されるわけではなく、両方の変数が同じリストオブジェクトを参照します。
“`python
list_a = [1, 2, 3]
list_b = list_a # 同じリストオブジェクトを参照
list_a.append(4)
print(list_b) # 出力: [1, 2, 3, 4] # list_aの変更がlist_bにも影響
list_b[0] = 99
print(list_a) # 出力: [99, 2, 3, 4] # list_bの変更がlist_aにも影響
“`
これは、リストを関数の引数として渡す際にも同様の挙動を示します。関数内でリストを変更すると、関数の外側の元のリストも変更されます。これは他のプログラミング言語でいうところの「参照渡し」に似ています（厳密にはPythonはオブジェクトへの参照を値として渡す「call by object reference」または「call by sharing」という方式ですが、ミュータブルなオブジェクトに関しては参照渡しのように振る舞います）。
“`python
def modify_list(my_list):
my_list.append(100)
my_list[0] = -1
original = [1, 2, 3]
modify_list(original)
print(original) # 出力: [-1, 2, 3, 100] # 関数内で変更された
“`
もし関数内でリストを変更しても、元のリストに影響させたくない場合は、関数にリストのコピーを渡す必要があります。
“`python
import copy
def modify_list_safe(my_list):
# リストのシャローコピーを作成して操作
copied_list = my_list.copy() # または my_list[:] または list(my_list)
copied_list.append(100)
copied_list[0] = -1
print(f”Inside function: {copied_list}”) # 関数内でコピーを変更
original = [1, 2, 3]
modify_list_safe(original)
print(f”Outside function: {original}”) # 出力: Outside function: [1, 2, 3] # 元のリストは変わらない
“`
ネストされたミュータブルなオブジェクトを含むリストを関数に渡し、関数内でそのネストされたオブジェクトを変更する可能性がある場合は、copy.deepcopy() を使って渡すのが安全です。
リストがミュータブルであること、そして代入や関数引数渡しにおける参照の共有は、リストを扱う上で非常に重要な概念です。意図しない副作用を避けるため、特にリストを変更する操作を行う場合は、この点を意識するようにしましょう。
8. 応用的なリスト操作：より高度なテクニック
リストの基本操作を理解した上で、より高度な操作方法を知っておくと、さらに効率的にPythonプログラミングを行うことができます。
8.1. リスト内包表記の詳細
前述の「2.4. リスト内包表記」で基本的な使い方を説明しましたが、リスト内包表記はさらに複雑な処理にも対応できます。
条件付きリスト内包表記
if 句を使って要素をフィルタリングする例は既に示しましたが、if-else 式を使って要素の値を変換することも可能です。
“`python
numbers = [1, 2, 3, 4, 5, 6]
偶数ならその数を、奇数なら0を要素とするリスト
processed_numbers = [x if x % 2 == 0 else 0 for x in numbers]
print(processed_numbers) # 出力: [0, 2, 0, 4, 0, 6]
“`
この場合、if-else 式は for 句の前に置かれることに注意してください。if 句が for 句の後に置かれる場合はフィルタリングです。
ネストされたリスト内包表記
複数の for 句を組み合わせることで、ネストされたループ構造を持つリスト内包表記を作成できます。これは、ネストされたリストをフラット化したり、複数のリストの組み合わせを生成したりするのに便利です。
“`python
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
ネストされたリストをフラット化
flat_list = [element for row in matrix for element in row]
print(flat_list) # 出力: [1, 2, 3, 4, 5, 6, 7, 8, 9]
2つのリストの要素のすべての組み合わせを含むタプルのリストを作成
list1 = [‘a’, ‘b’]
list2 = [1, 2, 3]
combinations = [(l1, l2) for l1 in list1 for l2 in list2]
print(combinations) # 出力: [(‘a’, 1), (‘a’, 2), (‘a’, 3), (‘b’, 1), (‘b’, 2), (‘b’, 3)]
“`
ネストされたリスト内包表記は、可読性が低下する場合があるため、複雑になりすぎる場合は通常の for ループを使う方が良いこともあります。しかし、単純なケースではコードを非常に簡潔にできます。
8.2. zip() 関数を使った複数リストの同時処理
zip() 関数は、複数のイテラブル（リスト、タプルなど）を並行してループ処理したい場合に非常に便利です。zip() は、各イテラブルから対応する位置にある要素を取り出し、それらをタプルにまとめて生成します。
“`python
names = [‘Alice’, ‘Bob’, ‘Charlie’]
scores = [85, 92, 78]
名前とスコアをペアにして処理
for name, score in zip(names, scores):
print(f”{name}: {score}”)
“`
出力:
Alice: 85
Bob: 92
Charlie: 78
zip() は、最も短いイテラブルの長さで停止します。
“`python
names = [‘Alice’, ‘Bob’, ‘Charlie’]
scores = [85, 92] # scoresの方が短い
for name, score in zip(names, scores):
print(f”{name}: {score}”)
“`
出力:
Alice: 85
Bob: 92
zip() の結果はタプルのイテレータですが、list() でリストに変換することもできます。
python
zipped_list = list(zip(names, scores))
print(zipped_list) # 出力: [('Alice', 85), ('Bob', 92)]
8.3. map(), filter(), reduce()
これらの組み込み関数は、関数型プログラミングのスタイルでリストなどのイテラブルを操作するためによく使われます。最近はリスト内包表記の方がよく使われる傾向にありますが、知っておくと役立ちます。
map(function, iterable): イテラブルの各要素にfunctionを適用し、その結果を生成します。filter(function, iterable): イテラブルの各要素にfunctionを適用し、functionがTrueを返した要素のみを生成します。reduce(function, iterable): （functoolsモジュールにあります）イテラブルの要素を、要素を2つずつ取るfunctionを繰り返し適用して単一の値に集約します。
“`python
map の例 (リスト内包表記と同等)
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers) # 出力: [1, 4, 9, 16, 25]
リスト内包表記の場合: [x**2 for x in numbers]
filter の例 (リスト内包表記と同等)
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 出力: [2, 4, 6]
リスト内包表記の場合: [x for x in numbers if x % 2 == 0]
reduce の例 (functoolsをインポートする必要がある)
from functools import reduce
numbers = [1, 2, 3, 4, 5]
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers) # 出力: 15
sum() 関数を使った方がPython的: sum(numbers)
“`
map と filter はリスト内包表記で代替できることが多く、リスト内包表記の方がコードが簡潔で読みやすい場合が多いです。reduce は特定の集約処理に便利ですが、sum(), max(), min() のような組み込み関数や、単純なループで代替できる場合もあります。
8.4. リストのネスト（リストのリスト）
リストの中に別のリストを要素として含むことは、行列や多次元データを表現する際によく使われます。
“`python
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
要素へのアクセス (行、列の順)
print(matrix[0]) # 出力: [1, 2, 3] (最初の行)
print(matrix[0][0]) # 出力: 1 (最初の行の最初の要素)
print(matrix[1][2]) # 出力: 6 (2番目の行の3番目の要素)
“`
ネストされたリストをループ処理するには、ネストされた for ループを使用します。
“`python
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for row in matrix:
for element in row:
print(element, end=” “) # 要素を横に並べて表示
print() # 各行の後に改行
“`
出力:
1 2 3
4 5 6
7 8 9
また、ネストされたリスト内包表記を使って、ネストされたリストを作成することもよくあります。
“`python
3×3の0で埋められた行列を作成
zero_matrix = [[0 for col in range(3)] for row in range(3)]
print(zero_matrix) # 出力: [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
注意！この書き方でネストされたミュータブルなリストを作るのは安全だった (前述の [[0]] * 3 の問題は起きない)
“`
ネストされたリストを扱う際は、インデックスの指定順序や、内側のリストがミュータブルであることによるコピーの問題などに注意が必要です。
これらの応用的な操作をマスターすることで、リストを使ったデータ処理の幅が広がります。特にリスト内包表記と zip() 関数は、Pythonで効率的かつ簡潔なコードを書く上で非常に役立ちます。
9. よくある落とし穴と注意点
Pythonのリストは非常に強力ですが、そのミュータブル性やオブジェクトの参照に関する挙動から、初心者が陥りやすい落とし穴がいくつかあります。
9.1. ミュータブルなオブジェクトのコピーの問題
「5.7. リストのコピー」で詳しく解説したように、リストを単純に = で代入したり、シャローコピー（[:] や copy()）を使ったりする場合、ネストされたミュータブルなオブジェクト（リストの中に別のリストなど）はコピーされず、参照が共有されます。これにより、一方のリストでネストされた要素を変更すると、もう一方のリストの同じ要素も変更されてしまうという意図しない副作用が発生します。
“`python
list_a = [[1, 2], [3, 4]]
list_b = list_a.copy() # シャローコピー
list_a[0].append(5) # ネストされたリストを変更
print(list_b) # 出力: [[1, 2, 5], [3, 4]] # list_bも影響を受けてしまった！
“`
完全に独立したコピーが必要な場合は、copy.deepcopy() を使うことを忘れないようにしましょう。
9.2. ループ中にリストを変更する際の注意点
リストを for ループでイテレートしている最中に、そのリストに対して要素の追加や削除といった変更を行うと、予期しない結果になることがあります。これは、リストの要素が追加・削除されることで、ループのインデックスやイテレーションの順序がずれてしまうためです。
削除の場合
“`python
numbers = [1, 2, 3, 4, 5]
リストから偶数を削除したい場合 (NGな例)
for number in numbers:
if number % 2 == 0:
numbers.remove(number) # ループ中にリストを変更！
print(numbers) # 出力: [1, 3, 5] と期待するが…
実際の出力は実行環境やタイミングによって異なる可能性もあるが、
例えば [1, 3, 5] のようになることもあれば、[1, 3] や [1, 4] のようになることもある
Python 3.xでは [1, 3, 5] になる可能性が高いが、保証されない
何が起こるか：
1 (奇数) -> OK
2 (偶数) -> 削除される。リストは [1, 3, 4, 5] になる。
次のループではインデックスが1つ進むが、要素が削除されたため、本来次に処理されるべき3ではなく4が処理される。
4 (偶数) -> 削除される。リストは [1, 3, 5] になる。
次のループではインデックスが1つ進むが、要素が削除されたため、本来次に処理されるべき5ではなくループが終了してしまう。
“`
ループ中にリストから要素を安全に削除したい場合は、以下のいずれかの方法を使用します。
-
新しいリストを作成する: 削除したくない要素だけを集めて新しいリストを作成する（リスト内包表記が適しています）。
“`python
numbers = [1, 2, 3, 4, 5]偶数でない要素だけを集めて新しいリストを作成
odd_numbers = [number for number in numbers if number % 2 != 0]
print(odd_numbers) # 出力: [1, 3, 5]
“` -
リストのコピーをループする: 元のリストのコピーをループし、コピーを操作するのではなく、元のリストから要素を削除する。
“`python
numbers = [1, 2, 3, 4, 5]リストのコピーをループ
for number in numbers.copy(): # または list(numbers)
if number % 2 == 0:
numbers.remove(number) # 元のリストから削除
print(numbers) # 出力: [1, 3, 5]
“`
この方法では、コピーをループしている間、元のリストのインデックスや構造が変化しても、ループの進行には影響がありません。 -
逆順にループする: インデックスを使って逆順にループし、要素を削除する。
“`python
numbers = [1, 2, 3, 4, 5]末尾から先頭に向かってインデックスを使ってループ
for i in range(len(numbers) – 1, -1, -1):
if numbers[i] % 2 == 0:
del numbers[i]
print(numbers) # 出力: [1, 3, 5]
“`
末尾から削除していく場合、削除によって前方の要素のインデックスがずれることはありません。
追加の場合
ループ中に要素を追加する場合も同様の問題が発生する可能性があります。特に、追加によってリストの長さが増加すると、無限ループに陥る可能性もあります。
一般的に、ループ中にリストを直接変更（追加・削除）することは避けるべきです。代わりに、新しいリストを作成するか、ループとは別の方法で要素を変更することを検討しましょう。
9.3. インデックスエラー (IndexError) と 値エラー (ValueError)
リスト操作では、指定したインデックスが存在しない場合に IndexError、指定した値が存在しない場合（remove() や index()）に ValueError が発生することがあります。これらのエラーが発生しないように、事前に要素の存在を確認したり、インデックスの範囲をチェックしたりすることが重要です。
“`python
my_list = [1, 2, 3]
インデックスエラーの例
print(my_list[3]) # IndexError
値エラーの例 (remove)
my_list.remove(4) # ValueError
値エラーの例 (index)
my_list.index(4) # ValueError
“`
これらのエラーを処理する必要がある場合は、try...except ブロックを使用します。
“`python
my_list = [‘a’, ‘b’, ‘c’]
try:
print(my_list[5])
except IndexError:
print(“指定されたインデックスは存在しません。”)
try:
my_list.remove(‘d’)
except ValueError:
print(“指定された値はリストに存在しません。”)
“`
9.4. パフォーマンスに関する考慮事項
ほとんどの日常的なプログラミングタスクでは、リストの基本的な操作のパフォーマンスを深く気にする必要はありません。しかし、非常に大きなリストを扱ったり、パフォーマンスが重要なアプリケーションを開発したりする場合は、いくつかの操作のパフォーマンス特性を知っておくと役立ちます。
- 末尾への追加 (
append): リストの末尾への要素追加は非常に効率的で、通常 O(1) の計算量です（amortized constant time）。これは、リストが内部的に動的配列として実装されており、容量が足りなくなった場合にのみ大きな再割り当てが発生するためです。 - 任意の位置への挿入 (
insert): リストの先頭や途中への要素挿入は効率が悪く、通常 O(n) の計算量です。これは、挿入位置より後にあるすべての要素を1つずつずらす必要があるためです（n はリストの長さ）。リストの先頭に頻繁に要素を追加・削除する必要がある場合は、リストよりもcollections.dequeを検討した方が良いでしょう。 - 末尾からの削除 (
pop()): 末尾の要素を削除するpop()は効率的で、通常 O(1) です。 - 任意の位置からの削除 (
pop(index),del list[index]): 任意の位置の要素を削除するpop(index)やdel list[index]も効率が悪く、通常 O(n) です。これは、削除位置より後にあるすべての要素を1つずつずらす必要があるためです。 - 値による削除 (
remove()): 値を検索して削除するremove()は、まず要素を検索する必要があるため、検索に O(n)、削除に O(n) かかるため、全体として O(n) の計算量になります。 - 要素のアクセス（インデックス）: インデックスを使った単一要素へのアクセスは非常に効率的で、通常 O(1) です。
- 要素の存在確認 (
in演算子): リスト内の要素を検索するin演算子は、線形検索（要素を端から順番に見ていく）を行うため、通常 O(n) の計算量になります。要素の存在確認が頻繁に行われる場合は、リストではなくセット（set）や辞書（dict）を使う方が効率的です（セットや辞書での検索は通常 O(1)）。 - リスト内包表記: 通常の
forループとappendで同じ処理を行うよりも、リスト内包表記の方がわずかに高速であることが多いです。これは、Pythonのインタプリタがリスト内包表記をより効率的に実行できるように最適化されているためです。
これらのパフォーマンス特性は、非常に大きなリストやパフォーマンスがクリティカルな部分でコードを書く場合に考慮すると良いでしょう。一般的な用途では、コードの読みやすさや簡潔さを優先してリストを使用しても問題ないことがほとんどです。
10. まとめ：Pythonリストの重要性
この記事では、Pythonの最も基本的なデータ構造であるリストについて、その定義から作成、アクセス、変更、削除、様々な操作メソッド、ループ処理、他のデータ型との比較、そして応用的なテクニックや注意点まで、幅広く詳細に解説しました。
リストはPythonプログラミングにおいて非常に頻繁に利用されるデータ構造です。その順序付き、変更可能、異種要素混在可能という特性は、多様な種類のデータを柔軟に扱うことを可能にします。インデックスやスライスを使ったアクセス、append や extend による要素の追加、del や remove、pop による削除、sort や sorted による並べ替えなど、基本的な操作をマスターすることは、Pythonでのデータ処理能力の基盤となります。
また、リスト内包表記のようなPythonらしい簡潔な記述方法や、zip() のような便利な関数、さらにはミュータブルなオブジェクトとしてのリストの挙動（参照とコピー）に関する理解は、より高度なプログラミングや意図しないバグの回避に役立ちます。
Pythonのリストは、そのシンプルさと強力さから、初学者が最初に学ぶべきデータ構造の一つであり、経験豊富な開発者にとっても日々のコーディングに欠かせないツールです。
この記事を通して、リストの基本をしっかりと理解し、様々な状況でリストを自信を持って活用できるようになっていれば幸いです。リストの次は、タプル、セット、辞書といった他の組み込みデータ構造や、それらを組み合わせたより複雑なデータ構造についても学んでいくと、Pythonによるプログラミングの可能性はさらに広がります。
Pythonのリストを使いこなし、データ処理の楽しさを体験してください！