Pythonのリスト（list）の解説【append, extend】
- 作成日: 2025-07-02
- 更新日: 2025-07-07
- カテゴリ: 基本
- タグ: list, リスト内包表記, append, insert, sort
Pythonのリスト（list）の使い方を解説します。追加、削除、結合、ソート、検索、重複削除、初期化など。サンプルコードも踏まえて実用的な使い方を解説していきます。
参考ドキュメントは以下になります。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
- Pythonのリスト（list）の解説【append, extend】
Pythonのlistに要素を追加するには？
Pythonのlistに要素（データ）を追加するには、以下のような方法があります。
- appendメソッドを使う（1つずつの要素の追加）
- insertメソッドを使う（特定の位置への要素の挿入）
- スライスを使う
Pythonのlistにappendで要素を追加するには？
Pythonのlistに1つずつ要素を追加するにはappendメソッドを使います。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# x は整数、文字列、リスト、タプルなど、あらゆるデータが可能
list.append(x)
lis = []
lis.append(1)
lis.append('abc')
lis.append(3.14)
print(lis) # [1, 'abc', 3.14]
appendメソッドには整数や文字列などあらゆるデータ型が渡せます。
appendメソッドでリストに要素を追加すると、その追加した要素分だけリストの長さが1増えます。リストの長さはlen関数で確認できます。
lis = [1, 2]
print(len(lis)) # 2
print(lis) # [1, 2]
lis.append(3)
print(len(lis)) # 3
print(lis) # [1, 2, 3]
appendの動作はスライスを使った以下のコードや、insertを使った以下のコードと等価です。
lis = []
# このコードと
lis.append(1)
# このコードは等価
lis[len(lis):] = [2]
# このコードも等価
lis.insert(len(lis), 3)
print(lis) # [1, 2, 3]
Pythonのlistのappendは遅いのか？
Pythonのlistのappendは比較的に遅い、と言われています。
以下はリストに要素を追加するコードの比較で、appendとリスト内包表記を比較しています。
import timeit
# append を使うバージョン
def append_version():
result = []
for i in range(1000000):
result.append(i * 2)
return result
# 内包表記バージョン
def comprehension_version():
return [i * 2 for i in range(1000000)]
# 時間を計測
append_time = timeit.timeit(append_version, number=10)
comprehension_time = timeit.timeit(comprehension_version, number=10)
print(f"append: {append_time:.4f} 秒 (10 回平均)")
print(f"内包表記: {comprehension_time:.4f} 秒 (10 回平均)")
上記のコードの実行結果は、筆者の環境では以下になりました。
append: 0.7477 秒 (10 回平均)
リスト内包表記: 0.6758 秒 (10 回平均)
リスト内包表記で要素を追加したほうが0.07秒ほど速いのが分かります。リストに要素を追加する場合はリスト内包表記が使えないか検討してみてください。
Pythonのlistにinsertで要素を挿入するには？
Pythonのリストにはinsertメソッドがあり、これを使うとリストの特定の位置に要素を挿入できます。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# indexの添え字の位置に、xを挿入する
list.insert(index, x)
lis = [1, 2]
lis.insert(0, 10)
print(lis) # [10, 1, 2]
lis.insert(1, 20)
print(lis) # [10, 20, 1, 2]
lis.insert(-1, 30)
print(lis) # [10, 20, 1, 30, 2]
insertの第1引数のindexの位置に、第2引数のxを挿入します。
indexに0を指定した場合は、リストの0番目の添え字の位置に挿入し、1を指定した場合はリストの1番目の添え字の位置に挿入します。
indexは負数も可能で-1を指定した場合はリストの末尾から1番目の位置に要素を挿入します。
insertの以下のコードは、appendやスライスの以下のコードと等価です。
lis = []
# このコードと
lis.insert(len(lis), 1)
# このコードは等価
lis.append(2)
# このコードも等価
lis[len(lis):] = [3]
print(lis) # [1, 2, 3]
Pythonのlistのinsertは遅いのか？
Pythonのlistのinsertは、appendよりも遅いと言われています。
以下はappendとinsertの比較コードです。
import timeit
# append を使うバージョン（100万）
def append_version():
result = []
for i in range(1000000):
result.append(i * 2)
return result
# insert でリスト末尾に挿入するバージョン（100万）
def insert_tail_version():
result = []
for i in range(1000000):
result.insert(len(result), i * 2)
return result
# insert でリスト先頭に挿入するバージョン（10万）
def insert_head_version():
result = []
for i in range(100000):
result.insert(0, i * 2)
return result
# 時間を計測
append_time = timeit.timeit(append_version, number=10)
insert_tail_time = timeit.timeit(insert_tail_version, number=10)
insert_head_time = timeit.timeit(insert_head_version, number=10)
print(f"append: {append_time:.4f} 秒 (10 回平均)")
print(f"insert (末尾): {insert_tail_time:.4f} 秒 (10 回平均)")
print(f"insert (先頭): {insert_head_time:.4f} 秒 (10 回平均)")
上記のコードを筆者の環境で実行すると以下の結果になります。
append: 0.7449 秒 (10 回平均)
insert (末尾): 1.1409 秒 (10 回平均)
insert (先頭): 15.7950 秒 (10 回平均)
リスト末尾にinsertする場合は、appendの方が速いことがわかります。また、リスト先頭にinsertする場合は、リスト末尾と比較した場合に大変遅いのがわかります。
これはPythonのリストの実装が理由だと思われます。CPythonでは、リストはC言語の動的配列で実装されています。Pythonのリストはリストと言う名前ですが、データ構造的には配列なんですね。なので配列の先頭に要素を挿入しようとすると、先頭から末尾までの要素の移動がゴリっと必要になって、これが大変パフォーマンスに影響していると考えられます。Pythonのリストを扱う場合は、リストのデータ構造は配列、だということを思い出してください。
Pythonのlistにスライスで要素を挿入するには？
Pythonにはスライスという機能があり、これはlistにも使うことができます。このスライスを使ってリストの特定の位置に要素を挿入することができます。
出典：3. 形式ばらない Python の紹介 — Python 3.13.5 ドキュメント
slice(start, stop)
スライスはstartの添え字とstopの添え字で表現します。たとえばリストの場合は
lis = [1, 2, 3]
lis[start:stop]
と言う風にアクセスします。スライスではstartの位置からstopの位置までの要素が取得されます。
startとstopの値の対応は以下の通りです。
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
startとstopに0を指定し、そこに別のリストを代入すると、リストの先頭に要素を追加することができます。
lis = [1, 2, 3]
# 1の前に4, 5を挿入する
lis[0:0] = [4, 5]
print(lis) # [4, 5, 1, 2, 3]
リストの途中の位置に挿入したい場合は、途中の添え字をstartとstopに指定して、リストを代入します。
lis = [1, 2, 3]
# 2と3の間に4, 5を挿入する
lis[2:2] = [4, 5]
print(lis) # [1, 2, 4, 5, 3]
リストの末尾に代入したい場合は、startにリストの長さを指定します。この時、stopは省略することができます（コロン:は省略しません）。
lis = [1, 2, 3]
# 3のあとに4, 5を挿入する
lis[len(lis):] = [4, 5]
print(lis) # [1, 2, 3, 4, 5]
Pythonのlistを結合するには？
Pythonのlistを他のリストに結合するには以下の方法があります。
- extendメソッドを使う（別のリストをリストに結合する）
- スライスを使う
Pythonのlistでextendで他リストを結合するには？
Pythonのリストのメソッドextendを使うと、他のリストをそのリストに結合することができます。
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b) # bをaの末尾に結合する
print(a) # [1, 2, 3, 4, 5, 6]
extendはリストを破壊的に変更し、引数のリストをリストの末尾に結合します。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
Pythonのlistのextendは遅いのか？
Pythonのlistのextendはappendを使うよりも速いです。
以下は比較用コードです。
import timeit
def get_list():
return [i for i in range(1000000)]
# append を使うバージョン
def append_version():
a = get_list()
b = get_list()
for c in b:
a.append(c)
return a
# extend を使うバージョン
def extend_version():
a = get_list()
b = get_list()
a.extend(b)
return a
# 時間を計測
append_time = timeit.timeit(append_version, number=10)
extend_time = timeit.timeit(extend_version, number=10)
print(f"append: {append_time:.4f} 秒 (10 回平均)")
print(f"extend: {extend_time:.4f} 秒 (10 回平均)")
上記のコードを筆者の環境で実行した場合、以下のような結果になります。
append: 1.4809 秒 (10 回平均)
extend: 1.0860 秒 (10 回平均)
appendでリスト末尾に愚直に要素を追加する場合と比べて、extendで二つのリストを結合する場合は、extendの方が速くなる結果になりました。
異なるリストを結合する場合はextendの使用を検討しましょう。
Pythonのlistにスライスで別のリストを結合するには？
Pythonのlistではスライス機能が使えるので、スライスを使ってリストに別のリストを結合することができます。
出典：3. 形式ばらない Python の紹介 — Python 3.13.5 ドキュメント
slice(start, stop)
list[start:stop]
スライスはstartとstopに添え字を指定します。リストの先頭を表す添え字は0で、リストの末尾を表す添え字はlen(list)です。
リストの先頭にスライスで別のリストを結合したい場合は以下のようにします。
lis = [1, 2, 3]
# 1の前に4, 5を挿入する
lis[0:0] = [4, 5]
print(lis) # [4, 5, 1, 2, 3]
リストの末尾にスライスで別のリストを結合したい場合は以下のようにします。
lis = [1, 2, 3]
# 3のあとに4, 5を挿入する
lis[len(lis):] = [4, 5]
print(lis) # [1, 2, 3, 4, 5]
Pythonのlistのスライスはextendより速いのか？
Pythonのリストの結合はスライスもextendもほとんど速度差はありません。
以下は検証用コードです。
import timeit
def get_list():
return [i for i in range(1000000)]
# slice を使ってリスト先頭に結合するバージョン
def slice_head_version():
a = get_list()
b = get_list()
a[0:0] = b
return a
# slice を使ってリスト末尾に結合するバージョン
def slice_tail_version():
a = get_list()
b = get_list()
a[len(a):] = b
return a
# extend を使うバージョン
def extend_version():
a = get_list()
b = get_list()
a.extend(b)
return a
# 時間を計測
slice_head_time = timeit.timeit(slice_head_version, number=10)
slice_tail_time = timeit.timeit(slice_tail_version, number=10)
extend_time = timeit.timeit(extend_version, number=10)
print(f"slice（先頭）: {slice_head_time:.4f} 秒 (10 回平均)")
print(f"slice（末尾）: {slice_tail_time:.4f} 秒 (10 回平均)")
print(f"extend: {extend_time:.4f} 秒 (10 回平均)")
上記のコードを筆者の環境で実行すると以下の結果になります。
slice（先頭）: 1.2359 秒 (10 回平均)
slice（末尾）: 1.1254 秒 (10 回平均)
extend: 1.1378 秒 (10 回平均)
リスト末尾へのリストの結合は、スライスの方が若干程度早いですが、ほとんど速度差は見られませんでした。
またリスト先頭へのリストの結合も、末尾への結合と比べて若干遅い程度でした。
Pythonのlistから要素を削除するには？
Pythonのlistから特定の要素を削除するには以下の方法があります。
- pop（リストから要素を取り出して削除）
- remove（リストから要素を削除）
- clear（リストの要素をすべて削除）
Pythonのlistからpopで要素を取り出して削除するには？
Pythonのpopメソッドを使うと、引数のindexの位置の要素をリストから取り出し、削除できます。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# index無しだとリスト末尾の要素を取り出して削除
list.pop()
# index有りだとindexの位置の要素を取り出して削除
list.pop(index)
popメソッドは返り値として取り出した要素を返します。indexを指定してる場合で、要素が存在しない場合はIndexErrorを送出します。
lis = [1, 2, 3, 4]
# リスト末尾要素を削除
print(lis.pop()) # 4
print(lis) # [1, 2, 3]
# リスト先頭の要素を削除
print(lis.pop(0)) # 1
print(lis) # [2, 3]
try:
# 存在しない要素を削除しようとすると
lis.pop(100)
except IndexError as e:
# IndexErrorが送出される
print(e) # pop index out of range
# 空のリストでpopするとIndexErrorになる
lis = []
try:
lis.pop()
except IndexError as e:
print(e) # pop from empty list
Pythonのlistのpopは遅いのか？
Pythonのlistのpopで先頭要素を削除するのは、末尾要素の削除に比べて遅いです。
以下は比較用のコードです。
import timeit
def get_list():
return [i for i in range(100000)]
# pop を使い末尾要素を削除するバージョン
def pop_tail_version():
a = get_list()
while len(a):
a.pop()
# pop を使い先頭要素を削除するバージョン
def pop_head_version():
a = get_list()
while len(a):
a.pop(0)
# 時間を計測
pop_tail_time = timeit.timeit(pop_tail_version, number=10)
pop_head_time = timeit.timeit(pop_head_version, number=10)
print(f"pop（末尾）: {pop_tail_time:.4f} 秒 (10 回平均)")
print(f"pop（先頭）: {pop_head_time:.4f} 秒 (10 回平均)")
上記のコードを筆者の環境で実行すると以下の結果になります。
pop（末尾）: 0.1192 秒 (10 回平均)
pop（先頭）: 8.4711 秒 (10 回平均)
リストの末尾のpopに比べると、リストの先頭のpopは8倍ぐらい遅いのが分かります。これも、Pythonのリストのデータ構造が原因だと思われます。CPythonはリストは配列で実装されているので、先頭の要素を削除すると残りの要素の移動が必要になり、大変遅くなるのでしょう。
popでリスト先頭の要素を削除するのはそれなりにコストが高いということは覚えておきましょう。
Pythonのlistでremoveで要素を削除するには？
Pythonのlistのremoveメソッドを使うと指定した要素を削除できます。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# xの値の要素を削除する。xが見つからなければValueError.
list.remove(x)
removeはxの値の要素をリストから削除します。値が見つからない場合はValueErrorを送出します。
lis = [1, 2, 3]
lis.remove(2) # リストから2の値の要素を削除
print(lis) # [1, 3]
lis.remove(3) # リストから3の値の要素を削除
print(lis) # [1]
try:
# 存在しない要素
lis.remove(100)
except ValueError as e:
print(e) # list.remove(x): x not in list
xは値であるので整数だけでなく文字列や浮動小数点数もいけます。
lis = [1, 3.14, "abc"]
lis.remove(3.14)
lis.remove('abc')
print(lis) # [1]
また、リストの中にあるリストや辞書も削除できます。
lis = [[1, 2, 3], {'a': 1, 'b': 2}]
lis.remove([1, 2, 3])
lis.remove({'a': 1, 'b': 2})
print(lis) # []
Pythonのlistのremoveは遅いのか？
Pythonのlistのremoveは、末尾要素の削除が遅いです。
以下は比較用コードです。
import timeit
N = 10000
def get_list():
return [i for i in range(N)]
# remove を使い末尾要素を削除するバージョン
def remove_tail_version():
lis = get_list()
for n in range(N-1, -1, -1):
lis.remove(n)
# remove を使い先頭要素を削除するバージョン
def remove_head_version():
lis = get_list()
for n in range(N):
lis.remove(n)
# 時間を計測
remove_tail_time = timeit.timeit(remove_tail_version, number=10)
remove_head_time = timeit.timeit(remove_head_version, number=10)
print(f"remove（末尾）: {remove_tail_time:.4f} 秒 (10 回平均)")
print(f"remove（先頭）: {remove_head_time:.4f} 秒 (10 回平均)")
上記のコードを実行すると筆者の環境では以下の結果になります。
remove（末尾）: 4.1532 秒 (10 回平均)
remove（先頭）: 0.0562 秒 (10 回平均)
なんと末尾要素の削除の方が遅く、先頭要素の削除の方が速い、という結果になりました。
おそらくですが、removeでxの要素を探索するときに、リストの先頭から探索しているんだと思います。そうすると、末尾の要素を見つけるには毎回探索でO(n)かかることになります。先頭の要素から削除する場合は探索はO(1)で終わるので、その分の計算量の差が比較に出ているのだと推測できます。
removeで末尾にある要素を見つけて削除するのは、計算コストが高い、と覚えておきましょう。
Pythonのlistでclearで全要素を削除するには？
Pythonのlistのclearメソッドを使うと、リストの全要素を削除できます。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
list.clear()
lis = [1, 2, 3]
lis.clear() # 全要素を削除
print(lis) # []
Pythonのlistをソート（sort）するには？
Pythonのlistをソートするには以下の方法があります。
- list.sort()を使う（破壊的ソート）
- sorted関数を使う（非破壊的ソート）
Pythonのlistをlist.sortでソートするには？
Pythonのlistにはsortメソッドがあり、これを使うと破壊的にリストをソートできます。破壊的と言うのはリストの中身を直接変更するという意味です。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# keyに関数を指定するとソート方法を指定できる。
# reverseをTrueにすると逆順にソートされる。
list.sort(*, key=None, reverse=False)
reverseがFalseの時はリストは昇順（ASC）でソートされます。
lis = [3, 1, 4, 2]
# リストの中身を昇順にソート
lis.sort()
print(lis) # [1, 2, 3, 4]
reverseをTrueにするとリストは降順（逆順, DESC）にソートされます。
lis = [3, 1, 4, 2]
# リストの中身を降順（逆順）にソート
lis.sort(reverse=True)
print(lis) # [4, 3, 2, 1]
keyにラムダ式などを指定すると、その関数の返り値に応じてソートを行います。たとえばオブジェクトの特定の属性や、辞書の特定のキーの値でソートしたいときなどに有効です。keyに指定した関数の引数にはソート中の要素が渡されます。
lis = [
{'num': 3},
{'num': 1},
{'num': 4},
{'num': 2},
]
# リスト内の辞書のnumキーをキーにソートする。
lis.sort(key=lambda item: item['num'])
print(lis)
# [{'num': 1}, {'num': 2}, {'num': 3}, {'num': 4}]
Pythonのlistをsorted関数でソートするには？
Pythonのlistは組み込み関数のsorted関数でもソートできます。
出典：sorted — 組み込み関数 — Python 3.13.5 ドキュメント
# iterableにはリストやタプルなどを渡す。
# keyにはソートのキーを指定する関数を渡す。
# reverseがFalseの時は昇順、Trueの時は降順になる。
sorted(iterable, /, *, key=None, reverse=False)
sorted関数はリストを非破壊的にソートします。非破壊的と言うのはリストのコピーを作ってソートして、そのコピーを返り値として返すということです。
reverseがFalseの時は昇順（ASC）でソートされます。
lis = [2, 1, 4, 3]
# lisを昇順にソート。
sorted_lis = sorted(lis)
print(sorted_lis) # [1, 2, 3, 4]
reverseをTrueにするとリストは降順（逆順, DESC）にソートされます。
lis = [3, 1, 4, 2]
# リストの中身を降順（逆順）にソート
sorted_lis = sorted(lis, reverse=True)
print(sorted_lis) # [4, 3, 2, 1]
keyにラムダ式などを指定すると、その関数の返り値に応じてソートを行います。たとえばオブジェクトの特定の属性や、辞書の特定のキーの値でソートしたいときなどに有効です。keyに指定した関数の引数にはソート中の要素が渡されます。
lis = [
{'num': 3},
{'num': 1},
{'num': 4},
{'num': 2},
]
# リスト内の辞書のnumキーをキーにソートする。
sorted_lis = sorted(lis, key=lambda item: item['num'])
print(sorted_lis)
# [{'num': 1}, {'num': 2}, {'num': 3}, {'num': 4}]
Pythonのsorted関数のコピーはシャローコピーなのかディープコピーなのか？
コピーにはシャローコピー（浅いコピー）とディープコピー（深いコピー）の2種類があります。
sorted関数はリストなどをコピーしてソートしますが、このコピーはシャローコピーです。以下が検証用コードです。
d1 = {'num': 1}
d2 = {'num': 2}
d3 = {'num': 3}
lis = [d1, d2, d3]
sorted_lis = sorted(lis, key=lambda item: item['num'])
print(sorted_lis)
# [{'num': 1}, {'num': 2}, {'num': 3}]
# sorted_lisの要素とd1などは同じメモリ。
print(sorted_lis[0] is d1) # True
print(sorted_lis[1] is d2) # True
print(sorted_lis[2] is d3) # True
sorted_lis[0]の要素とd1はis演算子で比較するとTrueになります。これは、オブジェクトの識別値が一致している、つまりメモリ上で同じものだということです。この点がシャローコピーの特徴です。ディープコピーだと、メモリ上で違うオブジェクトになります。
Pythonのlistのサイズ（要素数）を取得するには？
Pythonのlistの要素数を取得するにはlen関数を使います。
出典：len — 組み込み関数 — Python 3.13.5 ドキュメント
# xの要素数（長さ）を得る
len(x)
lis = []
print(len(lis)) # 0
lis = [1, 2, 3]
print(len(lis)) # 3
要素が空のリストではlen関数で0が求まり、要素が3つ入ったリストでは3が求まります。
Pythonのlistをlen関数で回すには？
Pythonのlistをfor文で回したいときにlen関数を使うこともできます。
関連記事：Pythonのfor文（繰り返し処理、ループ）を解説【range, enumerate】
lis = [1, 2, 3]
for i in range(len(lis)):
print(lis[i])
1
2
3
rangeにlen関数の返り値を渡してfor文を回すと、リストの添え字が得られます。その添え字でリストにアクセスすると、リストの要素を得ることができます。
Pythonのlistのindex（添え字）を検索するには？
Pythonのlistのindex（添え字）を取得するにはindexメソッドを使います。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# xの要素の添え字を取得。
# 要素が見つからなかった場合はValueErrorが送出される。
list.index(x)
# xの要素の添え字をstartから計算して取得。
list.index(x, start)
# xの要素の添え字をstartとendの範囲で取得。
list.index(x, start, end)
indexメソッドは引数xの値の要素の添え字を返します。要素が見つからない場合はValueErrorを送出します。要素の検索はリスト先頭から行います。
オプションの引数のstartとendで添え字の範囲を指定できます。startは検索を始める開始点、endは検索を終える終了点です。
lis = [1, 2, 3]
print(lis.index(1)) # 0
print(lis.index(2)) # 1
print(lis.index(3)) # 2
# 要素が見つからない場合はValueError
try:
lis.index(4)
except ValueError as e:
print(e) # 4 is not in list
リスト内の特定の範囲に絞って検索したい場合はstartとendに添え字を指定します。
lis = [10, 10, 20, 30, 40]
i = lis.index(10, 1) # 添え字1から検索
print(i) # 1
i = lis.index(30, 1, 4) # 添え字1から4の範囲で検索
print(i) # 3
Pythonのlistで重複削除を行うには？
Pythonのlistで重複した要素を削除するにはsetを使うと簡単です。
出典：5. 集合型 — データ構造 — Python 3.13.5 ドキュメント
lis = [1, 1, 2, 2, 3, 3]
lis = list(set(lis))
print(lis) # [1, 2, 3]
setは集合型のクラスです。集合型は重複した要素を格納しませんので、リストを一度集合に変換し、再度リストに変換することでリストから重複した要素を除去できます。
Pythonのlistを初期化するには？
Pythonのlistを初期化するには[]かlistクラスの呼び出しを行います。
lis_1 = [1, 2, 3] # []を使った初期化
lis_2 = list([4, 5, 6]) # list()を使った初期化
print(lis_1) # [1, 2, 3]
print(lis_2) # [4, 5, 6]
一般的にはリストの初期化は[]を使いますが、用途に合わせてlist()も使えます。list()はタプルや集合などをリストに変換したいときに使うことができます。
tup = (1, 2, 3) # タプル
s = {4, 5, 6} # 集合
print(list(tup)) # [1, 2, 3]
print(list(s)) # [4, 5, 6]
辞書をリストに変換する場合はdict.keys()やdict.values(), dict.items()などをlist()に渡します。
d = {'a': 1, 'b': 2, 'c': 3}
print(list(d.keys())) # ['a', 'b', 'c']
print(list(d.values())) # [1, 2, 3]
print(list(d.items())) # [('a', 1), ('b', 2), ('c', 3)]
一定範囲の順列をリストにしたい場合はrange()をlist()に渡します。
print(list(range(4))) # [0, 1, 2, 3]
print(list(range(4, 8))) # [4, 5, 6, 7]
print(list(range(4, 12, 2))) # [4, 6, 8, 10]
Pythonのlistで要素をcount（カウント）するには？
Pythonのlistで要素をカウントするにはcountメソッドを使います。
出典：5. リスト — データ構造 — Python 3.13.5 ドキュメント
# リストの中でのxの出現回数を返す。
list.count(x)
count()の引数xにカウントしたい要素の値を指定します。
lis = [1, 2, 1, 2, 1, 3]
print(lis.count(1)) # 3
print(lis.count(2)) # 2
print(lis.count(3)) # 1
上記ではlisの中には1が3つ、2が2つ、3が1つという結果になりました。
Pythonのlistをfor文で回すには？
Pythonのlistはfor文で回すことができます。
出典：8. for文 — 複合文 (compound statement) — Python 3.13.5 ドキュメント
関連記事：Pythonのfor文（繰り返し処理、ループ）を解説【range, enumerate】
# for文の文法
for target_list in starred_list:
suite
# リスト
lis = [1, 2, 3]
# リストをfor文で回す
for item in lis:
print(item)
1
2
3
for文のstarred_listにリストを渡すと、そのリストをfor文で回すことができます。上記の場合itemがリストの要素です。
Pythonのlistをwhile文で回すには？
Pythonのlistはwhile文で回すことができます。
出典：8. while文 — 複合文 (compound statement) — Python 3.13.5 ドキュメント
# while文の文法
while assignment_expression:
suite
リストをwhile文で回すにはカウント変数を作り、そのカウント変数をカウントすることでリストの要素にアクセスします。
lis = [1, 2, 3] # リスト
i = 0 # カウント変数
while i < len(lis):
print(lis[i]) # 出力
i += 1 # カウント変数を加算
1
2
3
len関数でリストの長さ（要素数）が求まります。これをカウント変数iと比較します（i < len(lis)）。そしてカウント変数でリストにアクセスしたら（lis[i]）、カウント変数iを加算して（i += 1）次の要素を参照します。