Python リスト append の使い方を徹底解説：基本から応用、効率まで
はじめに
Pythonにおいて、リスト（list）は最も頻繁に使用されるデータ構造の一つです。複数の要素を順序付けて格納し、要素の追加、削除、変更などが容易に行える柔軟性を持っています。リスト操作の中でも、新しい要素をリストの末尾に追加する操作は非常に一般的であり、そのための主要なメソッドがappend()です。
append()は一見単純なメソッドですが、その内部の仕組み、異なるデータ型を渡した場合の挙動、他のリスト操作メソッドとの違い、効率性など、深く理解することでPythonによるプログラミングスキルを向上させることができます。
本記事では、Pythonのリストメソッドappend()について、その基本的な使い方から始まり、様々なデータ型を扱った場合の詳細な挙動、内部実装に基づく効率性、他のリスト操作メソッドとの比較、そしてよくある落とし穴やベストプラクティスに至るまで、徹底的に解説します。この記事を読むことで、あなたはappend()を自信を持って使いこなし、より効率的で堅牢なPythonコードを書けるようになるでしょう。
さあ、Pythonリストのappend()メソッドの世界へ深く潜り込んでいきましょう。
1. list.append() とは何か？
まず、list.append()が何をするメソッドなのかを明確に定義します。
list.append(x)
このメソッドは、リストの末尾に単一の要素 x を追加します。
重要なポイントは以下の通りです。
- 末尾に追加: 要素はリストの最後に新しい要素として追加されます。既存の要素の順序は変更されません。
- 単一の要素:
append()は引数として渡されたxをそのまま一つの要素として追加します。たとえxがリストやタプルなどのコレクション型であっても、そのコレクション全体が単一の要素としてリストに追加されます。 - インプレース操作 (In-place operation):
append()メソッドは、呼び出し元のリストオブジェクト自体を直接変更します。新しいリストを作成して返すわけではありません。 - 返り値:
append()メソッドは、リスト自体を変更しますが、呼び出し元にはNoneを返します。これは多くのインプレースでリストを変更するメソッド（sort(),reverse()など）に共通する挙動です。
この「インプレース操作であり、Noneを返す」という性質は、特に初心者が陥りやすい間違いの原因となることがあります。例えば、new_list = old_list.append(element) のように書いてしまうと、new_listには期待する新しいリストではなく、Noneが代入されてしまいます。正しい使い方は、単に my_list.append(element) と記述し、その後に my_list を参照するという形になります。
2. 基本的な使い方と簡単な例
append()の基本的な使い方を見てみましょう。数値、文字列など、単純なデータ型をリストに追加する例です。
“`python
空のリストを作成
my_list = []
print(f”初期状態: {my_list}”) # 出力: 初期状態: []
数値を追加
my_list.append(10)
print(f”10を追加後: {my_list}”) # 出力: 10を追加後: [10]
文字列を追加
my_list.append(“apple”)
print(f”‘apple’を追加後: {my_list}”) # 出力: ‘apple’を追加後: [10, ‘apple’]
別の数値を追加
my_list.append(3.14)
print(f”3.14を追加後: {my_list}”) # 出力: 3.14を追加後: [10, ‘apple’, 3.14]
真偽値を追加
my_list.append(True)
print(f”Trueを追加後: {my_list}”) # 出力: Trueを追加後: [10, ‘apple’, 3.14, True]
Noneを追加
my_list.append(None)
print(f”Noneを追加後: {my_list}”) # 出力: Noneを追加後: [10, ‘apple’, 3.14, True, None]
appendの返り値を確認
result = my_list.append(“last_item”)
print(f”‘last_item’を追加後: {my_list}”) # 出力: ‘last_item’を追加後: [10, ‘apple’, 3.14, True, None, ‘last_item’]
print(f”appendの返り値: {result}”) # 出力: appendの返り値: None
“`
この例からわかるように、append()は引数に指定された値を、その型に関係なく、リストの末尾にそのまま追加します。返り値がNoneであることも確認できます。
3. 様々なデータ型を append した場合の詳細
append()の「単一の要素として追加する」という性質は、引数にリストやタプルなどのコンテナ型が渡された場合に特に重要になります。この点を深く掘り下げてみましょう。
3.1. リストを append する場合
リストを別のリストにappend()すると、追加される側のリストの中に、追加する側のリスト全体が一つの要素として格納されます。これはextend()メソッドとの大きな違いです。
“`python
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(f”list1 (初期): {list1}”) # 出力: list1 (初期): [1, 2, 3]
print(f”list2 (初期): {list2}”) # 出力: list2 (初期): [4, 5, 6]
list2 を list1 に append
list1.append(list2)
print(f”list1 (list2をappend後): {list1}”) # 出力: list1 (list2をappend後): [1, 2, 3, [4, 5, 6]]
print(f”list1の長さ: {len(list1)}”) # 出力: list1の長さ: 4 (要素が4つ)
print(f”list1の最後の要素: {list1[-1]}”) # 出力: list1の最後の要素: [4, 5, 6]
“`
結果を見ると、list1の末尾に[4, 5, 6]というリストそのものが要素として追加されていることがわかります。list1の要素数は4つになりました。最後の要素は、元のlist2と同じオブジェクトです。
この「同じオブジェクト」という点が非常に重要です。append()はオブジェクトの参照をリストに追加します。つまり、追加された後のリスト内の要素は、元のリストオブジェクトとメモリ上の同じ場所を指しています。したがって、元のリストを変更すると、追加先のリスト内の要素もその変更を反映します。
“`python
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.append(list2)
print(f”append直後: {list1}”) # 出力: append直後: [1, 2, 3, [4, 5, 6]]
元の list2 の要素を変更してみる
list2.append(7)
print(f”list2を変更後: {list2}”) # 出力: list2を変更後: [4, 5, 6, 7]
print(f”list1の状態: {list1}”) # 出力: list1の状態: [1, 2, 3, [4, 5, 6, 7]] (list1内のlist2も変わっている!)
print(f”list1[-1] と list2 は同じオブジェクトか？: {list1[-1] is list2}”) # 出力: list1[-1] と list2 は同じオブジェクトか？: True
list1内のlist2自体を変更してみる (例えば、list1の最後の要素をクリア)
list1[-1].clear() # list1内のlist2 (つまり list2そのもの) をクリアする
print(f”list1[-1]をクリア後: {list1}”) # 出力: list1[-1]をクリア後: [1, 2, 3, []]
print(f”list2の状態: {list2}”) # 出力: list2の状態: [] (元のlist2もクリアされている!)
“`
この挙動は、意図しない副作用を引き起こす可能性があるため注意が必要です。もし、追加するリストの内容をコピーして追加したい場合は、スライスを使ってコピーを作成するか、copy()メソッドを使用する必要があります。
“`python
listA = [1, 2]
listB = [3, 4]
listB の内容をコピーして listA に追加
listA.append(listB.copy()) # または listA.append(listB[:])
print(f”コピーをappend後: {listA}”) # 出力: コピーをappend後: [1, 2, [3, 4]]
元の listB を変更
listB.append(5)
print(f”listBを変更後: {listB}”) # 出力: listBを変更後: [3, 4, 5]
print(f”listAの状態: {listA}”) # 出力: listAの状態: [1, 2, [3, 4]] (listA内の要素は変わらない)
print(f”listA[-1] と listB は同じオブジェクトか？: {listA[-1] is listB}”) # 出力: listA[-1] と listB は同じオブジェクトか？: False
“`
このように、リストをappend()するとリストの中にリストが入れ子になり、元のリストへの参照が格納されるという点をしっかり理解しておくことが重要です。
3.2. タプルを append する場合
タプルもリストと同様にコレクション型ですが、タプルはイミュータブル（変更不可能）です。タプルをリストにappend()すると、タプル全体が単一の要素として追加されます。
“`python
my_list = [1, 2]
my_tuple = (3, 4, 5)
print(f”my_list (初期): {my_list}”) # 出力: my_list (初期): [1, 2]
print(f”my_tuple (初期): {my_tuple}”) # 出力: my_tuple (初期): (3, 4, 5)
my_list.append(my_tuple)
print(f”my_list (my_tupleをappend後): {my_list}”) # 出力: my_list (my_tupleをappend後): [1, 2, (3, 4, 5)]
print(f”my_listの長さ: {len(my_list)}”) # 出力: my_listの長さ: 3
print(f”my_listの最後の要素: {my_list[-1]}”) # 出力: my_listの最後の要素: (3, 4, 5)
“`
リストをappendした時と同様に、タプル全体が単一の要素として追加されています。タプルはイミュータブルなので、追加後に元のタプルを変更することはできません。したがって、参照が追加されたことによる意図しない副作用は、タプル自体を変更するという形では発生しません。ただし、タプルの中にミュータブルな要素（例：リスト）が含まれている場合は、そのミュータブルな要素を変更することで影響が出る可能性があります。
“`python
list_with_mutable_tuple = []
mutable_item_in_tuple = [9, 8]
tuple_with_mutable = (1, 2, mutable_item_in_tuple)
list_with_mutable_tuple.append(tuple_with_mutable)
print(f”タプルをappend後: {list_with_mutable_tuple}”) # 出力: タプルをappend後: [(1, 2, [9, 8])]
元のミュータブルな要素を変更
mutable_item_in_tuple.append(7)
print(f”ミュータブル要素変更後: {mutable_item_in_tuple}”) # 出力: ミュータブル要素変更後: [9, 8, 7]
print(f”リストの状態: {list_with_mutable_tuple}”) # 出力: リストの状態: [(1, 2, [9, 8, 7])] (リスト内のタプル内のリストも変わっている)
“`
3.3. 辞書（dict）を append する場合
辞書も単一の要素として追加されます。
“`python
my_list = [“a”, “b”]
my_dict = {“key1”: 1, “key2”: 2}
print(f”my_list (初期): {my_list}”) # 出力: my_list (初期): [‘a’, ‘b’]
print(f”my_dict (初期): {my_dict}”) # 出力: my_dict (初期): {‘key1’: 1, ‘key2’: 2}
my_list.append(my_dict)
print(f”my_list (my_dictをappend後): {my_list}”) # 出力: my_list (my_dictをappend後): [‘a’, ‘b’, {‘key1’: 1, ‘key2’: 2}]
print(f”my_listの長さ: {len(my_list)}”) # 出力: my_listの長さ: 3
print(f”my_listの最後の要素: {my_list[-1]}”) # 出力: my_listの最後の要素: {‘key1’: 1, ‘key2’: 2}
“`
辞書はミュータブルなので、リストの場合と同様に、元の辞書を変更すると、リスト内の要素もその変更を反映します。
“`python
my_list = [“a”, “b”]
my_dict = {“key1”: 1, “key2″: 2}
my_list.append(my_dict)
print(f”append直後: {my_list}”) # 出力: append直後: [‘a’, ‘b’, {‘key1’: 1, ‘key2’: 2}]
元の辞書を変更
my_dict[“key3″] = 3
print(f”my_dictを変更後: {my_dict}”) # 出力: my_dictを変更後: {‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
print(f”my_listの状態: {my_list}”) # 出力: my_listの状態: [‘a’, ‘b’, {‘key1’: 1, ‘key2’: 2, ‘key3’: 3}] (リスト内の辞書も変わっている)
“`
3.4. セット（set）を append する場合
セットも単一の要素として追加されます。ただし、セットはハッシュ可能である必要があります（ミュータブルな要素を含まないなど）。セット自体はミュータブルですが、リストの要素としては追加可能です。
“`python
my_list = [10, 20]
my_set = {30, 40, 50} # セットを作成
print(f”my_list (初期): {my_list}”) # 出力: my_list (初期): [10, 20]
print(f”my_set (初期): {my_set}”) # 出力: my_set (初期): {40, 50, 30} (セットは順不同)
my_list.append(my_set)
print(f”my_list (my_setをappend後): {my_list}”) # 出力例: my_list (my_setをappend後): [10, 20, {40, 50, 30}]
print(f”my_listの長さ: {len(my_list)}”) # 出力: my_listの長さ: 3
print(f”my_listの最後の要素: {my_list[-1]}”) # 出力例: my_listの最後の要素: {40, 50, 30}
“`
セットもミュータブルなので、辞書と同様に、元のセットを変更するとリスト内の要素も影響を受けます。
3.5. オブジェクト（クラスのインスタンス）を append する場合
ユーザー定義クラスのインスタンスも、リストの要素として追加できます。この場合も、オブジェクトの参照が追加されます。
“`python
class MyObject:
def init(self, name):
self.name = name
def __repr__(self): # リスト表示時にわかりやすくするため
return f"MyObject('{self.name}')"
my_list = [“item1”]
obj1 = MyObject(“first_obj”)
print(f”my_list (初期): {my_list}”) # 出力: my_list (初期): [‘item1’]
print(f”obj1 (初期): {obj1}”) # 出力: obj1 (初期): MyObject(‘first_obj’)
my_list.append(obj1)
print(f”my_list (obj1をappend後): {my_list}”) # 出力: my_list (obj1をappend後): [‘item1’, MyObject(‘first_obj’)]
print(f”my_listの長さ: {len(my_list)}”) # 出力: my_listの長さ: 2
print(f”my_listの最後の要素: {my_list[-1]}”) # 出力: my_listの最後の要素: MyObject(‘first_obj’)
元のオブジェクトの状態を変更
obj1.name = “changed_obj”
print(f”obj1を変更後: {obj1}”) # 出力: obj1を変更後: MyObject(‘changed_obj’)
print(f”my_listの状態: {my_list}”) # 出力: my_listの状態: [‘item1’, MyObject(‘changed_obj’)] (リスト内のオブジェクトも変わっている)
“`
3.6. まとめ：何を append しても「単一の要素」
これらの例からわかるように、append()メソッドは、引数として渡されたものが何であれ、それを丸ごとリストの末尾に一つの要素として追加します。これがリスト、タプル、辞書などのコレクション型であっても、その中身が展開されて追加されるわけではありません。コレクション自体が単一の要素として格納されます。そして、ミュータブルなオブジェクト（リスト、辞書、セット、多くのカスタムオブジェクト）をappendした場合、元のオブジェクトを変更すると、リスト内に格納された要素もその変更を反映します。これは、append()がオブジェクトの参照をリストに追加するためです。
4. append() の効率性（パフォーマンス）
append()メソッドは、リストの末尾に要素を追加するという操作において、非常に効率的です。ほとんどの場合、その時間計算量は O(1)、正確には 償却 O(1) (amortized O(1)) となります。
なぜ「償却 O(1)」なのでしょうか？
Pythonのリストは、内部的には「動的配列（dynamic array）」あるいは「可変長配列」と呼ばれるデータ構造で実装されています。これは、要素を連続したメモリ領域に格納する配列ですが、通常の静的配列と異なり、必要に応じてサイズを自動的に拡張する機能を持ちます。
append()が呼ばれたとき、Pythonはまず現在の配列の末尾に新しい要素を格納する十分な空間があるかを確認します。
* 空間がある場合: 新しい要素は既存のメモリ領域の最後に単純に格納されます。この操作は非常に高速で、要素数に依存しません。時間計算量は O(1) です。
* 空間がない場合: 現在の配列は満杯です。要素を追加するためには、より大きな新しいメモリ領域を確保し、既存のすべての要素をその新しい領域にコピーし、その後で新しい要素を末尾に格納する必要があります。この「再配置（reallocation）」と「コピー」の操作は、現在のリストの要素数（N）に比例する時間を要します。時間計算量は O(N) となります。
もし append() が毎回 O(N) の操作を行うとしたら、N個の要素を追加するのに O(N^2) の時間がかかってしまいます。しかし、Python（および他の多くの言語の動的配列実装）では、配列が満杯になったときに一度に比較的大きな新しい領域を確保します。例えば、現在の容量の1.125倍や2倍といった具合です（具体的な増加率はPythonのバージョンや実装に依存します）。
このように、たまに発生する O(N) の再配置コストを、多くの O(1) の追加操作に「償却（amortize）」して均すと、1回あたりの append() 操作にかかる平均的なコストは、要素数Nによらず一定とみなせる O(1) になるのです。
例えば、容量が倍になる戦略の場合、容量1の配列に1要素追加（O(1)）、容量2に拡張して2要素追加（コピーO(1)+追加O(1)）、容量4に拡張して4要素追加（コピーO(3)+追加O(1)）、…、容量2^kに拡張して2^k要素追加（コピーO(2^k-1)+追加O(1)）となります。N個の要素を追加する総コストは、コピーコストの合計がおよそ最初のN個の要素をコピーするコストの合計となり、これはO(N)になります。追加操作自体のコストもN回でO(N)です。総コストがO(N)なので、1回あたりの平均コストは O(N)/N = O(1) となります。
したがって、多数の要素をリストの末尾に順次追加していく場合、append()は非常に効率的な方法です。これは、特にループ内で繰り返しリストを構築するようなシナリオで重要になります。
“`python
100万個の要素をappendで追加する例 (概念的な速さの確認)
import time
my_list = []
start_time = time.time()
for i in range(1_000_000):
my_list.append(i)
end_time = time.time()
print(f”appendで100万個追加にかかった時間: {end_time – start_time:.4f}秒”)
print(f”最終的なリストの長さ: {len(my_list)}”)
参考：リスト連結 (+) で同様の操作を行う場合 (非常に遅い)
list_concat = []
start_time_concat = time.time()
for i in range(10000): # 数万個でも非常に遅くなる
list_concat = list_concat + [i] # 新しいリストが毎回生成される
end_time_concat = time.time()
print(f”リスト連結(+)で1万個追加にかかった時間: {end_time_concat – start_time_concat:.4f}秒”)
“`
（注：リスト連結(+)の例は意図的に小さい数にしていますが、それでもappendより著しく遅いことが確認できます。コメントアウトを外して実行してみてください。）
この例からもわかるように、リストの末尾に要素を一つずつ追加していく作業には、append()が最も適しており、そのパフォーマンスは要素数の増加に対して非常に優れています。
5. append() と他のリスト操作メソッドの比較
Pythonには、リストに要素を追加したり、結合したりするための様々な方法があります。append()の理解を深めるために、これらの方法と比較してみましょう。
5.1. append() vs extend()
これが最も混同しやすいペアかもしれません。違いは、「単一の要素を追加するか」「複数の要素を（iterableから）追加するか」です。
append(x):xを単一の要素としてリストの末尾に追加します。extend(iterable):iterable（リスト、タプル、文字列、範囲など、反復可能なオブジェクト）の各要素をリストの末尾に展開して追加します。
“`python
list_append = [1, 2, 3]
list_extend = [1, 2, 3]
another_list = [4, 5, 6]
appendの場合
list_append.append(another_list)
print(f”append(another_list)の結果: {list_append}”) # 出力: append(another_list)の結果: [1, 2, 3, [4, 5, 6]] (リストがネストされる)
extendの場合
list_extend.extend(another_list)
print(f”extend(another_list)の結果: {list_extend}”) # 出力: extend(another_list)の結果: [1, 2, 3, 4, 5, 6] (要素が平坦化される)
文字列を渡した場合
list_str_append = [1, 2]
list_str_extend = [1, 2]
my_string = “abc”
list_str_append.append(my_string)
print(f”append(‘abc’)の結果: {list_str_append}”) # 出力: append(‘abc’)の結果: [1, 2, ‘abc’]
list_str_extend.extend(my_string) # 文字列は文字のiterable
print(f”extend(‘abc’)の結果: {list_str_extend}”) # 出力: extend(‘abc’)の結果: [1, 2, ‘a’, ‘b’, ‘c’]
“`
append()は引数全体を一つの箱として追加するイメージ、extend()は引数の中身を取り出して一つずつ追加するイメージです。多数の要素をまとめて追加したい場合はextend()を使うのが効率的です。内部的にはextend()も効率的に（恐らくappend()をループで呼ぶより高速に）実装されています。
5.2. append() vs insert()
append(x): 要素を常に末尾に追加します。時間計算量は償却 O(1) です。insert(index, x): 指定したindexの位置に要素xを挿入します。既存の要素は右にずらされます。
“`python
my_list = [1, 2, 3]
my_list.append(4)
print(f”append(4)の結果: {my_list}”) # 出力: append(4)の結果: [1, 2, 3, 4]
my_list.insert(0, 0) # 先頭に挿入
print(f”insert(0, 0)の結果: {my_list}”) # 出力: insert(0, 0)の結果: [0, 1, 2, 3, 4]
my_list.insert(2, 99) # インデックス2に挿入
print(f”insert(2, 99)の結果: {my_list}”) # 出力: insert(2, 99)の結果: [0, 1, 99, 2, 3, 4]
“`
insert()メソッドは、挿入位置より後ろにあるすべての要素を一つずつずらす必要があるため、その時間計算量は挿入位置より後ろの要素数に比例します。リストの先頭（インデックス0）や中間への挿入は、リストの長さに比例する O(N) の時間がかかります。リストの末尾への挿入、つまり list.insert(len(list), x) は list.append(x) と同じ操作ですが、append() は末尾追加専用に最適化されているため、通常は append() を使う方がわずかに効率的です。
結論として、要素をリストの末尾に追加したい場合は、迷わず append() を使うべきです。
5.3. append() vs リスト連結 (+ 演算子)
リスト連結 (+ 演算子) は、二つのリストを結合して新しいリストを作成します。
“`python
list1 = [1, 2]
list2 = [3, 4]
新しいリストを作成
combined_list = list1 + list2
print(f”list1 + list2 の結果: {combined_list}”) # 出力: list1 + list2 の結果: [1, 2, 3, 4]
print(f”list1 は変わらない: {list1}”) # 出力: list1 は変わらない: [1, 2]
要素を一つ追加する場合と比較
my_list = [1, 2]
element = 3
新しいリストを作成 (非効率な方法)
my_list = my_list + [element] # [element] という新しいリストを作り、結合する
print(f”my_list = my_list + [element] の結果: {my_list}”) # 出力: my_list = my_list + [element] の結果: [1, 2, 3]
“`
要素を一つずつループで追加していく際に、my_list = my_list + [element] のようにリスト連結を繰り返し行うのは非常に非効率です。ループが回るたびに新しいリストオブジェクトが生成され、古いリストの要素が新しいリストにコピーされるため、N個の要素を追加するのに O(N^2) の時間計算量がかかります。
対して、append() はインプレースで既存のリストを効率的に変更するため、繰り返し要素を追加する場面では断然 append() を使用すべきです。
5.4. append() vs スライスを使った代入
スライスを使った代入も、リストの一部または全体を変更できます。末尾に要素を追加する場合、my_list[len(my_list):] = [element] のように書くことも可能です。
“`python
my_list = [1, 2]
element = 3
スライスを使った末尾への要素追加
my_list[len(my_list):] = [element] # [element] はiterableである必要がある
print(f”スライス代入の結果: {my_list}”) # 出力: スライス代入の結果: [1, 2, 3]
スライス代入で複数の要素を追加
my_list = [1, 2]
elements = [3, 4, 5]
my_list[len(my_list):] = elements # my_list[len(my_list):len(my_list)] の位置に elements の要素を挿入
print(f”スライス代入(複数)の結果: {my_list}”) # 出力: スライス代入(複数)の結果: [1, 2, 3, 4, 5]
“`
my_list[len(my_list):] = [element] は、要素が単一の場合でもリストとして渡す必要があります。これは内部的には extend() に近い操作になります。末尾に単一の要素を追加する最も直接的で意図が明確な方法は、やはり append() です。スライス代入は複数の要素を追加する際に使われることがありますが、その場合は extend() の方がより一般的で分かりやすいでしょう。
5.5. append() vs リスト内包表記 (List Comprehension)
リスト内包表記は、既存のiterableから新しいリストを生成するための簡潔な構文です。要素を一つずつ追加するappend()とは目的が異なりますが、同じ結果を得られる場合があります。
例えば、0から9までの偶数のリストを作成する場合：
“`python
append を使う場合
even_numbers_append = []
for i in range(10):
if i % 2 == 0:
even_numbers_append.append(i)
print(f”appendを使った結果: {even_numbers_append}”) # 出力: appendを使った結果: [0, 2, 4, 6, 8]
リスト内包表記を使う場合
even_numbers_comp = [i for i in range(10) if i % 2 == 0]
print(f”リスト内包表記を使った結果: {even_numbers_comp}”) # 出力: リスト内包表記を使った結果: [0, 2, 4, 6, 8]
“`
この例のように、新しいリストを別のiterableやシンプルな変換処理から構築する場合、リスト内包表記の方がコードが短く、Pythonista（Pythonの慣習に従うプログラマー）にとっては読みやすいとされています。また、リスト内包表記は、要素数を事前に見積もって効率的にメモリを確保できる場合があり、場合によってはループとappend()の組み合わせよりも高速になることがあります。
しかし、リストを構築するロジックが複雑で、ループの途中で条件によって追加するかどうかを判断したり、追加する要素がループ変数から直接的に計算できない場合など、リスト内包表記では表現しにくいケースがあります。そのような場合は、素直に空のリストを作成し、ループ内でappend()を使って要素を追加していくのが適切な方法です。
まとめ:
| メソッド/方法 | 説明 | 用途 | 効率（末尾への追加） | 備考 |
|---|---|---|---|---|
append(x) |
x を単一の要素として末尾に追加 |
要素を一つずつ末尾に追加 | 償却 O(1) | 最も推奨される方法。インプレース。返り値は None。 |
extend(iterable) |
iterableの各要素を末尾に展開して追加 |
複数の要素をまとめて末尾に追加 | O(K) (Kはiterableの長さ) | インプレース。返り値は None。appendと間違えやすい。 |
insert(index, x) |
indexの位置に x を挿入 |
リストの任意の位置に要素を挿入 | O(N) (先頭や中間) | 末尾 (insert(len(list), x)) は append よりわずかに遅い可能性。 |
リスト連結 (+) |
list1 + list2 で新しいリストを作成 |
既存のリスト同士を一度だけ結合 | O(N+M) | ループ内での繰り返し使用は O(N^2) となり非効率。 |
スライス代入 ([:]) |
list[start:end] = iterable |
リストの一部を変更/置換、または末尾に複数要素を追加 | O(K) または O(N+K) | 複数の要素追加 (list[len(list):] = iterable) は extend に近い。 |
| リスト内包表記 | [式 for 変数 in iterable if 条件] で新しいリストを生成 |
既存のiterableから変換/フィルタリングして新しいリストを作成 | O(N) | コードが簡潔になるが、複雑なロジックには不向き。新しいリストを生成する（インプレースではない）。 |
このように、append()はリストの末尾に「単一の要素」を効率的に追加するための、明確で推奨されるメソッドです。
6. append() 使用時の注意点とよくある間違い
append()はシンプルですが、その特性から予期せぬ挙動や間違いにつながることがあります。
6.1. append() の返り値 (None) を変数に代入してしまう
前述したように、append() はインプレースでリストを変更し、None を返します。この None を変数に代入してしまう間違いは非常によく見られます。
“`python
my_list = [1, 2]
間違いの例: append の返り値を代入
new_list = my_list.append(3)
print(f”my_list の内容: {my_list}”) # 出力: my_list の内容: [1, 2, 3] (元のリストは変更されている!)
print(f”new_list の内容: {new_list}”) # 出力: new_list の内容: None (期待通りのリストではない)
正しい使い方
another_list = [10, 20]
another_list.append(30) # append を呼び出すだけ
print(f”another_list の内容: {another_list}”) # 出力: another_list の内容: [10, 20, 30]
“`
append() を呼び出した結果のリストを使いたい場合は、append() を呼び出した後に元のリスト変数を参照する必要があります。
6.2. ミュータブルな要素を append し、後から元の要素を変更する
「3. 様々なデータ型を append した場合の詳細」で詳しく解説したように、リスト、辞書、セットなどのミュータブルなオブジェクトを append() すると、リストにはそのオブジェクトへの参照が格納されます。元のオブジェクトを変更すると、リスト内の対応する要素も変更されます。
“`python
list_of_lists = []
row = [1, 2, 3]
list_of_lists.append(row)
print(f”append直後: {list_of_lists}”) # 出力: append直後: [[1, 2, 3]]
元の row を変更
row.append(4)
print(f”元のrowを変更後: {row}”) # 出力: 元のrowを変更後: [1, 2, 3, 4]
print(f”list_of_listsの状態: {list_of_lists}”) # 出力: list_of_listsの状態: [[1, 2, 3, 4]] (リスト内のリストも変わっている!)
“`
特に、ループ内で同じミュータブルなオブジェクト（例えば、一時的なリストや辞書）をクリア/変更しながら複数回 append() する場合にこの問題が発生しやすいです。
“`python
list_of_rows = []
temp_row = []
for i in range(3):
temp_row.append(i + 1)
list_of_rows.append(temp_row) # ここで参照を追加
# 間違いの原因: 次のループのために temp_row をクリア/変更
# temp_row.clear() # こうすると全ての要素が [] になる！
# temp_row = [] # こうしても新しいリストへの参照が追加されるわけではない！
print(f”間違いの例の結果: {list_of_rows}”)
temp_row.clear() の場合: [[], [], []]
temp_row = [] の場合: [[1], [1, 2], [1, 2, 3]] (リストが共有されているわけではないが、appendのタイミングとtemp_rowの値に注意)
例えば i=0で [1]をappend、i=1で [1, 2]をappend、i=2で [1, 2, 3]をappendしてしまう。
期待するのは [[1], [2], [3]] か [[1], [1,2], [1,2,3]] のどちらかではなく [[1], [2], [3]] のような行ごとの独立したリストのはず。
正しい方法: 各要素を追加する際に新しいリストを作成するか、コピーを作成する
list_of_rows_correct = []
for i in range(3):
temp_row = [] # ループごとに新しいリストを作成
temp_row.append(i + 1)
list_of_rows_correct.append(temp_row)
print(f”新しいリストを作成した場合の結果: {list_of_rows_correct}”) # 出力: 新しいリストを作成した場合の結果: [[1], [2], [3]]
list_of_rows_copy_correct = []
temp_row = []
for i in range(3):
temp_row.append(i + 1)
# append する際にコピーを作成
list_of_rows_copy_correct.append(temp_row.copy()) # または temp_row[:]
# 次のループのために元の temp_row をクリア
temp_row.clear()
print(f”コピーを作成した場合の結果: {list_of_rows_copy_correct}”) # 出力: コピーを作成した場合の結果: [[1], [2], [3]]
“`
リストや辞書のリストを作成するような場合は、ループ内で新しいオブジェクトを作成して追加するか、追加する直前に .copy() などでシャローコピーを作成して追加するかのいずれかを行うのが安全です。
6.3. リスト自身を append してしまう（再帰的なリスト）
リスト自身をそのリストに append() することも可能ですが、これは非常に特殊なケースであり、通常は避けるべきです。リストが自身を含む再帰的な構造になります。
“`python
recursive_list = [1, 2]
recursive_list.append(recursive_list)
print(f”再帰的なリスト: {recursive_list}”)
出力例: 再帰的なリスト: [1, 2, […]]
[…] は再帰を示唆しています
print(f”リストの最後の要素はリスト自身か？: {recursive_list[-1] is recursive_list}”) # 出力: リストの最後の要素はリスト自身か？: True
“`
このようなリストは、要素を処理する際に無限ループに陥る可能性があるため、取り扱いに注意が必要です。通常のプログラミングではまず使うことはありません。
6.4. イテレータを append して要素が消費される
ジェネレータやイテレータオブジェクトをappend()した場合、リストにはそのイテレータオブジェクト自体が追加されます。リストに追加された後でそのイテレータを反復処理しようとすると、元のイテレータの状態が引き継がれるため、既に要素が消費されている場合は何も得られない可能性があります。
“`python
def my_generator():
yield 1
yield 2
yield 3
my_list = []
gen = my_generator()
イテレータオブジェクトをappend
my_list.append(gen)
print(f”ジェネレータオブジェクトをappend後: {my_list}”) # 出力例: ジェネレータオブジェクトをappend後: […,
リスト内のジェネレータから要素を取り出そうとする
注: 元のジェネレータと同じオブジェクトなので、一度イテレーションすると消費される
print(f”リスト内のジェネレータから要素を取り出す: {list(my_list[-1])}”) # 出力: リスト内のジェネレータから要素を取り出す: [1, 2, 3]
もう一度リスト内のジェネレータから要素を取り出そうとする
print(f”再びリスト内のジェネレータから要素を取り出す: {list(my_list[-1])}”) # 出力: 再びリスト内のジェネレータから要素を取り出す: [] (既に消費されている)
“`
これはappend()の挙動としては正しい（オブジェクト参照を追加しているだけ）ですが、イテレータの中身を展開してリストに追加したい場合は、extend()を使用するか、リスト内包表記で新しいリストを作成する必要があります。
“`python
my_list_extended = []
gen2 = my_generator()
my_list_extended.extend(gen2) # extendはイテレータを展開する
print(f”extendでジェネレータを展開後: {my_list_extended}”) # 出力: extendでジェネレータを展開後: [1, 2, 3]
my_list_comprehension = list(my_generator()) # リスト内包表記やlist()もイテレータを展開する
print(f”list()でジェネレータを展開後: {my_list_comprehension}”) # 出力: list()でジェネレータを展開後: [1, 2, 3]
“`
これらの注意点と落とし穴を理解しておくことで、append()をより安全かつ意図通りに使うことができます。
7. 応用例：リストを append() で構築する様々なシナリオ
append()メソッドは、特にデータを収集したり、条件に基づいて要素を選択したりしながらリストを動的に構築する場面で威力を発揮します。
7.1. ファイルの各行をリストとして読み込む
“`python
file_lines = []
try:
with open(“sample.txt”, “r”, encoding=”utf-8″) as f:
for line in f:
file_lines.append(line.strip()) # strip()で改行文字を除去
except FileNotFoundError:
print(“sample.txt が見つかりません。ダミーデータを使用します。”)
file_lines.append(“Line 1”)
file_lines.append(“Line 2”)
file_lines.append(“Line 3”)
print(f”読み込んだ行のリスト: {file_lines}”)
“`
7.2. 処理結果を収集する
ある処理を行い、その結果のうち特定の条件を満たすものだけをリストに格納するような場面です。
“`python
import random
results = []
for _ in range(10):
value = random.randint(1, 100)
if value > 50:
results.append(value) # 条件を満たす場合だけappend
print(f”50より大きいランダム値のリスト: {results}”)
“`
このような、ループの途中で「追加するかどうか決まる」「追加する要素がその場で生成される」といったケースは、リスト内包表記よりもループとappend()の組み合わせの方が自然に記述できます。
7.3. スタックとしての利用
Pythonのリストは、末尾への追加（append()）と末尾からの削除（pop()）が効率的であるため、後入れ先出し（LIFO: Last-In, First-Out）のデータ構造であるスタックとして簡単に利用できます。
“`python
stack = []
プッシュ (要素の追加)
stack.append(“A”)
stack.append(“B”)
stack.append(“C”)
print(f”スタックの状態 (push後): {stack}”) # 出力: スタックの状態 (push後): [‘A’, ‘B’, ‘C’]
ポップ (末尾要素の取り出しと削除)
top_element = stack.pop()
print(f”取り出した要素: {top_element}”) # 出力: 取り出した要素: C
print(f”スタックの状態 (pop後): {stack}”) # 出力: スタックの状態 (pop後): [‘A’, ‘B’]
stack.pop()
stack.pop()
stack.pop() # 空のスタックで pop() すると IndexError が発生
“`
末尾への追加/削除は O(1) なので、リストはスタックの実装に適しています。一方、キュー（FIFO: First-In, First-Out）として使う場合、先頭からの削除（pop(0)）は O(N) のコストがかかるため非効率です。キューが必要な場合は、collections.deque を使うのが推奨されます。
8. append() の内部実装に関する補足（詳細）
4節で触れたように、Pythonリストは動的配列です。append のたびに容量をどのように増やしているか、もう少し詳しく見てみましょう。
Pythonのリストがどのように容量を増やすかは、内部のC言語による実装（CPythonの場合）に依存します。Pythonのバージョンによって多少異なる可能性がありますが、一般的な戦略は以下の通りです。
- 新しい要素を追加するスペースがあるか確認します（
size < allocated）。 - スペースがあれば、その位置に要素を格納し、
sizeをインクリメントします。これは O(1) です。 - スペースがなければ、新しい容量 (
new_allocated) を計算します。この計算は通常、現在の要素数や割り当て済み容量に基づいて行われます。例えば、現在の容量の約1.125倍に固定の少量（例: 3または4）を加える、あるいは単純に2倍にするなどの戦略があります。 - 計算された
new_allocatedで指定されるサイズの新しいメモリブロックを確保します。 - 既存の要素を古いメモリブロックから新しいメモリブロックへコピーします。これは O(N) です。
- 古いメモリブロックを解放します。
- 新しいメモリブロックをリストの内部データポインタに設定し、
allocatedをnew_allocatedに更新します。 - 新しい要素を新しいメモリブロックの末尾に格納し、
sizeをインクリメントします。
容量増加の具体的な計算式は、CPythonのソースコード（例えば Objects/listobject.c の list_resize 関数あたり）で確認できます。Python 3.11の時点では、以下のようなロジックが含まれています（簡略化）：
c
new_allocated = (newsize >> 3) + newsize + (newsize < 9 ? 3 : 6);
ここで newsize は追加後の要素数です。>> 3 は8で割る操作に相当し、これは既存容量の1/8に新しい要素数を足し、さらに少量を加えるという、既存容量の1.125倍に近いがより細かい調整が入る戦略です。要素数が少ないうちは固定値の加算の影響が大きく、すぐに容量が増えるようになっています。
この動的配列と償却 O(1) の理解は、多数の要素を効率的にリストに追加する際の append の強みを裏付けるものです。ただし、非常に巨大なリストを扱う場合や、メモリ断片化が懸念されるような特殊な環境では、この再配置メカニズムがパフォーマンスに影響を与える可能性がないわけではありません。しかし、ほとんどの一般的な用途では、append はリストの末尾追加において最も推奨される効率的な方法です。
9. まとめとベストプラクティス
Pythonのリストメソッド append() は、リストの末尾に単一の要素を効率的に追加するための基本的かつ非常に重要なツールです。その主な特徴は以下の通りです。
- リストの末尾に要素を追加します。
- 引数として渡されたものをそのまま一つの要素として追加します（コレクション型であっても展開しません）。
- リストをインプレースで変更し、
Noneを返します。 - 要素を一つずつ追加する場合、その時間計算量はほとんどの場合 償却 O(1) となり非常に効率的です。
append() を使うべき主要なシナリオ:
- 空のリストから始めて、ループなどでデータを一つずつ収集/処理しながらリストを構築する場合。
- リストをスタックとして利用する場合（プッシュ操作）。
- リストの末尾に確実に単一の要素を追加したい場合。
append() 使用時のベストプラクティスと注意点:
append()はNoneを返すので、my_list = my_list.append(element)のように返り値を代入しないこと。- ミュータブルなオブジェクト（リスト、辞書など）を
append()する場合、リスト内にはそのオブジェクトへの参照が格納されることを理解しておく。必要であれば、追加する前に.copy()などでコピーを作成する。 - 多数の要素をまとめて追加したい場合は、
extend()を使用する方が意図が明確で、かつ効率的。 - リストの任意の位置に要素を挿入したい場合は
insert()を使用するが、末尾以外への挿入は O(N) のコストがかかることを理解しておく。 - 繰り返し要素を追加する際に、リスト連結（
+）やスライス代入（my_list = my_list[:] + [element]のような形）は非効率なので避ける。 - 単純な変換やフィルタリングで新しいリストを作成する場合は、リスト内包表記の方がコードが簡潔で推奨されることが多い。
append()はPythonプログラミングの基本中の基本ですが、その挙動や他のメソッドとの違い、内部の効率性を深く理解することで、より洗練された、効率的なコードを書くことができるようになります。この記事で解説した内容が、あなたのPythonリスト操作の理解を深める一助となれば幸いです。
10. 最後に
Pythonのリストとappend()メソッドは、その使いやすさと柔軟性から非常に強力なツールです。日常的なプログラミングタスクから、より複雑なデータ処理まで、様々な場面で活躍します。本記事では、append()の表面的な使い方だけでなく、その内部の仕組みや効率性、そして様々なデータ型や他の操作との関連性について、できる限り詳細に掘り下げました。
Pythonの学習において、基本的なデータ構造とその操作メソッドを深く理解することは、堅牢で効率的なコードを書くための基盤となります。特に、インプレース操作やオブジェクト参照といった概念は、Pythonの他の部分を理解するためにも重要です。
この記事が、あなたがlist.append()を完全にマスターし、Pythonによるプログラミングをさらに楽しむための助けになれば幸いです。是非、実際に様々な例を試してみて、その挙動を体感してください。