FooBarNinja

言語バージョン 3.9.0

公開日 2020年12月24日 JST

更新日 2020年12月29日 JST

コード例の出力としてprint関数を使用しています。

使用方法がわからない場合は以下のページを参照してからコード例を確認してください。

print関数の使用方法

list（リスト、配列）

このページでは豊富な例を用いてPythonのリスト（list、配列）の使い方を学ぶことができます。

特定の操作をより詳しく知りたい場合は、 説明欄や各コード例の下に関連するメソッド・関数のリンクをおきますので、 そのリンクからより詳細な説明ページへ飛んでください。

リストは複数の値をまとめて保持できるデータ型です。
他のプログラミング言語における配列というデータ型に多くの点で似ていますが、リストは配列と同等ではありません。
「Pythonにおける配列に似た特徴を持つデータ型の1つ」として認識するのがよいでしょう。

また、リストの中の各要素は0から始まる整数でインデックス（indexed）されており、 この整数のことは各要素に対するインデックスやインデックス番号などと呼ばれます。

TL;DR

初期化

# リストの作成:1
list1 = []
print(list1)
==> []



# リストの作成:2（リストクラスのコンストラクタを使用する）
list2 = list()
print(list2)
==> []



# リストの作成:3（異なる型の要素を格納することも可能）
list3 = ['Python', 100]
print(list3)
==> ['Python', 100]



# リストの作成:4（コンストラクタの引数に反復可能オブジェクトを指定できます）
tuple1 = ('Foo', 'Bar', 'Ninja')
list3 = list(tuple1)
print(list3)
==> ['Foo', 'Bar', 'Ninja']



# リストの作成:5（文字列は反復可能オブジェクト）
str1 = 'ABCDE'
list4 = list(str1)
print(list4)
==> ['A', 'B', 'C', 'D', 'E']

要素の取得

# []（角括弧、添字表記）の中にインデックスを指定して要素を取得
list1 = [100, 200, 300]
print(list1[0])
==> 100
print(list1[2])
==> 300
# インデックス-1は最後尾の要素を取得します
print(list1[-1])
==> 300



# 存在しないインデックスを指定するとエラー
list1 = [100, 200, 300]
print(list1[4])
==> IndexError: list index out of range



# for文を使用して取得
list2 = ['py', 'ts', 'java']
for e in list2:
    print(e)
==> py
==> ts
==> java

関連情報：forの使用方法

値の代入

# インデックスが0の要素に新たな値を代入する
list1 = ['Python', 'JavaScript']
list1[0] = 100
print(list1)
==> [100, 'JavaScript']



list2 = [100, True, ('Python',), 'Java']
print(list2)
==> [100, True, ('Python',), 'Java']

for i, _ in enumerate(list2):
    list2[i] = 'py'
print(list2)
==> ['py', 'py', 'py', 'py']

関連情報：enumerateの使用方法

リストの長さ

# len関数を使って長さ（要素の数）を得る
list1 = [0, 1, 2, 3, 4, 5]
print(len(list1))
==> 6



list2 = list()
print(len(list2))
==> 0

要素の追加

# appendメソッド（追加したい要素を指定）
list1 = [0, 1, 2]
list1.append(100)
print(list1)
==> [0, 1, 2, 100]



# insertメソッド（第1引数にインデックス、第2引数に追加する値を指定）
list2 = ['python', 'javascript']
list2.insert(1, True)
print(list2)
==> ['python', True, 'javascript']



# extendメソッド
list3 = [100, 200, 300]
list4 = ['Foo', 'Bar', 'Ninja']
list3.extend(list4)
print(list3)
==> [100, 200, 300, 'Foo', 'Bar', 'Ninja']



# +演算子
list5 = [True, False]
list6 = [{'name': 'Joshua'}, {'name': 'Ellie'}]
list5 += list6
print(list5)
==> [True, False, {'name': 'Joshua'}, {'name': 'Ellie'}]

関連情報：appendメソッド（listクラス）の使用方法

関連情報：insertメソッド（listクラス）の使用方法

関連情報：extendメソッド（listクラス）の使用方法

要素の削除

# removeメソッド（要素の値を指定）
list1 = [100, 200, 300]
list1.remove(200)
print(list1)
==> [100, 300]



# popメソッドの使用
list2 = ['python', 'kotlin', 'java']
return_value1 = list2.pop()
print(list2)
==> ['python', 'kotlin']
print(return_value1)
==> java



# clearメソッド
list3 = [True, True, False]
list3.clear()
print(list3)
==> []



# del文
list4 = [1, 'python', 'py', True]
del list4[0]
print(list4)
==> ['python', 'py', True]

関連情報：popメソッド（listクラス）の使用方法

関連情報：removeメソッド（listクラス）の使用方法

関連情報：clearメソッド（listクラス）の使用方法

要素の並び替え

# sortメソッド
list1 = [4, 1, 3, 2]
list1.sort()
print(list1)
==> [1, 2, 3, 4]



# sortメソッド（キーワード引数keyの指定、2から距離の近い順に並び替え）
list1 = [4, 1, 3, 2]
list1.sort(key=lambda e: abs(2 - e))
print(list1)
==> [2, 1, 3, 4]



# sortメソッド（キーワード引数reverse）
list1 = [4, 1, 3, 2]
list1.sort(reverse=True)
print(list1)
==> [4, 3, 2, 1]



# sorted関数
list2 = ['C', 'A', 'D', 'B']
sorted_list2 = sorted(list2)
print(sorted_list2)
==> ['A', 'B', 'C', 'D']



# sorted関数（キーワード引数reverse）
list2 = ['C', 'A', 'D', 'B']
sorted_list2 = sorted(list2, reverse=True)
print(sorted_list2)
==> ['D', 'C', 'B', 'A']

関連情報：sortメソッド（listクラス）の使用方法

関連情報：sorted関数の使用方法

要素の検索

# in演算子（指定したオブジェクトがあればTrue）
list1 = ['python', 'java']
is_included1 = 'python' in list1
print(is_included1)
==> True



# not in演算子
list1 = ['python', 'java']
print('python' not in list1)
==> False



# indexメソッド（指定した要素のインデックスを返す）
list2 = ['A', 'B', 'C']
print(list2.index('B'))
==> 1



# countメソッド（指定した要素の個数を返す）
list3 = ['py', 'py', 'js', 'java', 'py']
print(list3.count('py'))
==> 3

関連情報：countメソッド（listクラス）の使用方法

関連情報：indexメソッド（listクラス）の使用方法

リストのコピー

# 浅いコピー（shallow copy）
list1 = ['python', True, {'id': 1}]
copied_list1 = list1.copy()
print(list1)
==> ['python', True, {'id': 1}]
print(copied_list1)
==> ['python', True, {'id': 1}]

# コピー先の複合オブジェクト（リスト、クラスインスタンス、辞書型のようなオブジェクト）は影響を受ける
list1[1] = False
list1[2]['id'] = 100
print(list1)
==> ['python', False, {'id': 100}]
print(copied_list1)
==> ['python', True, {'id': 100}]




from copy import deepcopy

# 深いコピー（deep copy）
list1 = ['python', True, {'id': 1}]
deepcopied_list1 = deepcopy(list1)
print(list1)
==> ['python', True, {'id': 1}]
print(deepcopied_list1)
==> ['python', True, {'id': 1}]

# コピー先の複合オブジェクトは影響を受けない
list1[1] = False
list1[2]['id'] = 100
print(list1)
==> ['python', False, {'id': 100}]
print(deepcopied_list1)
==> ['python', True, {'id': 1}]

関連情報：copyメソッド（リストクラス）の使用方法

スライス操作

# スライス操作1
list1 = [0, 1, 2, {'id': 3}, 4, 5]
sliced_list1 = list1[2:5]
print(list1)
==> [0, 1, 2, {'id': 3}, 4, 5]
print(sliced_list1)
==> [2, {'id': 3}, 4]

# スライス操作で作られるオブジェクトは浅いコピーなので、
# 複合オブジェクト（リスト、クラスインスタンス、辞書型のようなオブジェクト）は影響を受ける
list1[3]['id'] = 100
print(list1)
==> [0, 1, 2, {'id': 100}, 4, 5]
print(sliced_list1)
==> [2, {'id': 100}, 4]




# スライス操作2
list1 = [0, 1, 2, {'id': 3}, 4, 5]
sliced_list2 = list1[2:]
print(sliced_list2)
==> [2, {'id': 3}, 4, 5]




# スライス操作3
list1 = [0, 1, 2, {'id': 3}, 4, 5]
sliced_list3 = list1[:5]
print(sliced_list3)
==> [0, 1, 2, {'id': 3}, 4]




# スライス操作4
list1 = [0, 1, 2, {'id': 3}, 4, 5]
sliced_list4 = list1[:]
print(sliced_list4)
==> [0, 1, 2, {'id': 3}, 4, 5]

多次元リスト

# 多次元リスト
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list1)
==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 多次元リストの要素の取得
for inner_list in list1:
    print(inner_list)
==> [1, 2, 3]
==> [4, 5, 6]
==> [7, 8, 9]

# 中のリストの要素の取得
for inner_list in list1:
    for e in inner_list:
        print(e, end=' ')
==> 1 2 3 4 5 6 7 8 9




# 多次元リストの平坦化（flatten）にリスト内包表記を用いる
list2 = [['py'], ['js'], ['ts', 'rb']]
flattened_list2 = [inner_e for e in list2 for inner_e in e]
print(flattened_list2)
==> ['py', 'js', 'ts', 'rb']

# 上記の処理を冗長に書き直したもの
list2 = [['py'], ['js'], ['ts', 'rb']]
flattened_list3 = []
for e in list2:
    for inner_e in e:
        flattened_list3.append(inner_e)
print(flattened_list3)
==> ['py', 'js', 'ts', 'rb']

リスト内包表記

# 通常のリスト生成
list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1)
==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]



# リスト内包表記でのリスト生成
list_comprehension1 = [e for e in range(10)]
print(list_comprehension1)
==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]



tuple1 = ('python', 'java', 'kotlin')
list_comprehension2 = [e.upper() for e in tuple1]
print(list_comprehension2)
==> ['PYTHON', 'JAVA', 'KOTLIN']

関連情報：rangeの使用方法

解説

初期化

リストオブジェクトは複数の方法で生成することができます。
主な生成方法は[]（角括弧）とlist()関数（リストクラスのコンストラクタ）を用いる方法です。

角括弧を用いる生成の場合、,（カンマ）区切りで要素を列挙していきます。
list関数を用いる場合は、引数無し、または引数に反復可能オブジェクト（iterable）を指定します。

また、リストオブジェクトは複数の異なる型を要素として含むこともできます。

list1 = []
print(list1)
==> []



# リストクラスのコンストラクタを使用する
list2 = list()
print(list2)
==> []



# 異なる型の要素を格納することも可能
list3 = ['Python', False, 'TypeScript']
print(list3)
==> ['Python', False, 'TypeScript']



# タプルオブジェクトは反復可能オブジェクト
tuple1 = (1, 2, 3, 4, 5)
list4 = list(tuple1)
print(list4)
==> [1, 2, 3, 4, 5]

要素の取得

リストの各要素にはインデックス（インデックス番号）という0から始まる整数の値が振られています。
このインデックスと[]（角括弧、添字表記）を用いることにより各要素を取得することが可能です。

他の方法としては、 for文 を用いて各要素にアクセスする方法などがあります。

# インデックスを指定して値を取得
list1 = [True, False]
print(list1[0])
==> True
print(list1[1])
==> False
print(list1[-1])
==> False



# 存在しないインデックスを指定するとエラー
list2 = ['python', 'javascript']
print(list2[3])
==> IndexError: list index out of range



# for文を使用して取得
list3 = [{'id': 0, 'name': 'Alice'}, {'id': 1, 'name': 'John'}]
for element in list3:
    print(element)
==> {'id': 0, 'name': 'Alice'}
==> {'id': 1, 'name': 'John'}

値の代入

すでに要素があるリストのインデックス位置に別の値を代入することも可能です。 その場合は値を代入したいインデックスを指定し、=を用いて値を代入します。

# インデックスが1の要素に新たな値を代入する
list1 = ['py', 'ts', 'js']
list1[2] = True
print(list1)
==> ['py', 'ts', True]



list2 = [1, False, ('java',), {'id': 1}]
print(list2)
==> [1, False, ('java',), {'id': 1}]

for index, _ in enumerate(list2):
    list2[index] = 'list'
print(list2)
==> ['list', 'list', 'list', 'list']

関連情報：enumerateの使用方法

リストの長さ

組み込み関数のlen関数を用いることで、リストの長さ（要素の数）を取得することができます。

list1 = ['python', True, 100]
print(len(list1))
==> 3



list2 = []
print(len(list2))
==> 0

要素の追加

リストは可変型（mutable type）ですので、生成した後にも要素を追加することができます。
要素の追加方法は複数あり、このページでは appendメソッド、 insertメソッド、 extendメソッド、 +演算子を使用した方法を紹介します。

appendメソッドはリストの末尾に引数で与えた要素を追加することができます。

insertメソッドはリストのインデックス位置を指定することで任意の位置に要素を追加します。

extendメソッドは引数にリストや他の反復可能オブジェクトをとり、使用したリストを拡張します。

+演算子はリスト同士を連結することができます。

# appendメソッド
list1 = ['py', 'ts', 'js']
list1.append('py')
print(list1)
==> ['py', 'ts', 'js', 'py']



# insertメソッド（第1引数にインデックス、第2引数に追加する値を指定）
list2 = [0, 0, 0]
list2.insert(2, 100)
print(list2)
==> [0, 0, 100, 0]



# extendメソッド
list3 = ['python']
list4 = [True, False]
list3.extend(list4)
print(list3)
==> ['python', True, False]



# +演算子
list5 = [0, 1, 2]
list6 = [100, 200, 300]
list5 += list6
print(list5)
==> [0, 1, 2, 100, 200, 300]

要素の削除

リストは可変型（mutable type）なので、生成した後に要素を削除することができます。
要素の削除方法は複数あり、このページでは removeメソッド、 popメソッド、 clearメソッド、 del文を使用した方法を簡潔に紹介します。

removeメソッドは引数に値を指定し、最初に一致したリストの要素を削除します。

popメソッドは引数にインデックスを指定することでその位置の要素を削除、引数無しで末尾の要素を削除して戻り値として返します。

clearメソッドはリストの全ての要素を削除します。

del文はインデックスを指定して要素を削除することができます。後述するスライス表記も使用することができます。

# removeメソッド（要素の値を指定）
list1 = ['py', 'java', 'ts', 'js']
list1.remove('js')
print(list1)
==> ['py', 'java', 'ts']



# popメソッドの使用
list2 = [100, 200, 300]
return_value1 = list2.pop(1)
print(list2)
==> [100, 300]
print(return_value1)
==> 200



# clearメソッド
list3 = [0, True, 'python', {'id': 0}]
list3.clear()
print(list3)
==> []



# del文
list4 = ['python', 'kotlin']
del list4[1]
print(list4)
==> ['python']

要素の並び替え

Pythonではリストの要素を並び替えるのに便利なメソッドや関数が用意されています。
ここでは sortメソッド と sorted関数 を紹介します。
（紹介する方法は引数に条件を指定することにより、複雑な並び替えを実現することが可能です。 より詳しい使用方法を知りたい場合はリンク先のページを参照してください。）

sortメソッドはリストクラスのメソッドで、呼び出し元のリストを並び替えます。

sorted関数は引数にリストなどの反復可能オブジェクトをとり、並び替えたリストを戻り値として返します。

# sortメソッド
list1 = [4, 1, 3, 2]
list1.sort()
print(list1)
==> [1, 2, 3, 4]



# sorted関数
list2 = ['C', 'A', 'D', 'B']
sorted_list2 = sorted(list2)
print(sorted_list2)
==> ['A', 'B', 'C', 'D']

要素の検索

リストの中の要素を検索する方法（存在確認する方法）として、 in演算子（not in演算子）、 indexメソッド、 countメソッド を例としてあげます。

in演算子を用いることにより、所属検査演算を行うことができます。
リストにおいてin演算子は、指定した値がリストに含まれていればTrue、そうでない場合はFalseを返します。
not in演算子が返す結果はin演算子と逆になります。

indexメソッドは引数に指定した値がリストに含まれている場合、最初に一致した要素のインデックスを戻り値として返します。

countメソッドは引数に指定した値がリストにいくつ含まれているかを返します。

# in演算子（指定したオブジェクトがあればTrue）
list1 = [0, 1, 2, 3]
is_included1 = 3 in list1
print(is_included1)
==> True



# not in演算子
list1 = [0, 1, 2, 3]
print(4 not in list1)
==> True



# indexメソッド（指定した要素のインデックスを返す）
list2 = [True, True, False, False]
print(list2.index(False))
==> 2



# countメソッド（指定した要素の個数を返す）
list3 = [True, True, True, False, False]
print(list3.count(True))
==> 3

リストのコピー

リストのコピーを作りたい場合、 copyメソッド（リストクラス） や標準ライブラリであるcopyモジュールのdeepcopy関数の使用を検討してみてください。

copyメソッド（リストクラス）はリストのコピーを戻り値として返します。
copyメソッドで生成されたリストは元リストの浅いコピー（shallow copy）であることに注意してください。 浅いコピーの挙動はコード例を参照してください。

浅いコピーではなく、深いコピー（deep copy）のリストを生成したい場合があります。 その場合は、Pythonの標準ライブラリであるcopyモジュールのdeepcopy関数の使用を検討してください。

class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return repr(vars(self))

# 浅いコピー（shallow copy）
list1 = ['python', True, Person('Olivia')]
copied_list1 = list1.copy()
print(list1)
==> ['python', True, {'name': 'Olivia'}]
print(copied_list1)
==> ['python', True, {'name': 'Olivia'}]

# コピー先の複合オブジェクト（リスト、クラスインスタンス、辞書型のようなオブジェクト）は影響を受ける
list1[1] = False
list1[2].name = 'Sophia'
print(list1)
==> ['python', False, {'name': 'Sophia'}]
print(copied_list1)
==> ['python', True, {'name': 'Sophia'}]




# 深いコピー（deep copy）
from copy import deepcopy

list1 = ['python', True, Person('Olivia')]
deepcopied_list1 = deepcopy(list1)
print(list1)
==> ['python', True, {'name': 'Olivia'}]
print(deepcopied_list1)
==> ['python', True, {'name': 'Olivia'}]

# コピー先の複合オブジェクトは影響を受けない
list1[1] = False
list1[2].name = 'Sophia'
print(list1)
==> ['python', False, {'name': 'Sophia'}]
print(deepcopied_list1)
==> ['python', True, {'name': 'Olivia'}]

スライス操作

リストに対してスライス操作を行うことができます。

リストにおけるスライス操作とは[]（角括弧、添字表記）の中に:（コロン）を用いてインデックスを指定することにより、 元リストの一部分を切り出したリストを生成することです。

スライス操作を用いて生成したリストは元リストの浅いコピーであることに注意してください。

# スライス操作1
list1 = ['py', 'js', 'ts', {'name': 'java'}]
sliced_list1 = list1[2:4]
print(list1)
==> ['py', 'js', 'ts', {'name': 'java'}]
print(sliced_list1)
==> ['ts', {'name': 'java'}]

# スライス操作で作られるオブジェクトは浅いコピーなので、
# 複合オブジェクト（リスト、クラスインスタンス、辞書型のようなオブジェクト）は影響を受ける
sliced_list1[1]['name'] = 'python'
print(list1)
==> ['py', 'js', 'ts', {'name': 'python'}]
print(sliced_list1)
==> ['ts', {'name': 'python'}]




# スライス操作2
list1 = ['py', 'js', 'ts', {'name': 'java'}]
sliced_list2 = list1[2:]
print(sliced_list2)
==> ['ts', {'name': 'java'}]



# スライス操作3
list1 = ['py', 'js', 'ts', {'name': 'java'}]
sliced_list3 = list1[:3]
print(sliced_list3)
==> ['py', 'js', 'ts']



# スライス操作4
list1 = ['py', 'js', 'ts', {'name': 'java'}]
sliced_list4 = list1[:]
print(sliced_list4)
==> ['py', 'js', 'ts', {'name': 'java'}]

多次元リスト

リストをネストさせることにより、多次元なリストを生成することができます。

# 多次元リスト
list1 = [[1, 2, 3], ['py', 'js', 'ts'], [True, False]]
print(list1)
==> [[1, 2, 3], ['py', 'js', 'ts'], [True, False]]

# 多次元リストの要素の取得
for inner_list in list1:
    print(inner_list)
==> [1, 2, 3]
==> ['py', 'js', 'ts']
==> [True, False]

# 中のリストの要素の取得
for inner_list in list1:
    for e in inner_list:
        print(e, end=' ')
==> 1 2 3 py js ts True False




# 多次元リストの平坦化（flatten）にリスト内包表記を用いる
list2 = [['A'], [1], [True, False]]
flattened_list2 = [inner_e for e in list2 for inner_e in e]
print(flattened_list2)
==> ['A', 1, True, False]

# 上記の処理を冗長に書き直したもの
list2 = [['A'], [1], [True, False]]
flattened_list3 = []
for e in list2:
    for inner_e in e:
        flattened_list3.append(inner_e)
print(flattened_list3)
==> ['A', 1, True, False]

リスト内包表記

リスト内包表記はリストを生成する方法の1つです。
例えば、for文とappendメソッドを組み合わせて実現させるような処理も、 リスト内包表記を用いて角括弧の中にforを記述することにより簡潔に記述することができます。

# 通常のリスト生成
list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1)
==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]



# リスト内包表記でのリスト生成
list_comprehension1 = [e for e in range(10)]
print(list_comprehension1)
==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]



tuple1 = (1, 2, 3, 4, 5)
list_comprehension2 = [e ** 2 for e in tuple1]
print(list_comprehension2)
==> [1, 4, 9, 16, 25]

関連情報：rangeの使用方法

1次情報

リスト型 (list) 組み込み型 - Pythonドキュメント

リスト型 (list) 形式ばらない Python の紹介 - Pythonドキュメント

リスト型についてもう少し - Pythonドキュメント

所属検査演算 - Pythonドキュメント

浅いコピーおよび深いコピー操作 - Pythonドキュメント

リストの内包表記 - Pythonドキュメント

ネストしたリストの内包表記 - Pythonドキュメント

整数インデクスによる効率的な要素アクセス - sequence - Pythonドキュメント