Pythonのリスト型(List)の使い方をプログラミング入門者向けにわかりやすく解説します。
Pythonの「リスト型」とは
リストは、複数の値をひとまとめにして管理できるデータの入れ物です。
[値1, 値2, 値3, …] のように、各値をカンマ(,)で区切って角括弧 [] で囲って書きます。
このような形式のデータ型を「リスト型」と呼びます。
1つ1つの値は「要素」と呼ばれ、インデックス（順番）で取り出すことができます。
記述例
以下は、リストの記述例です。
# 勇者ぴこりのアイテム袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 勇者ぴこりの仲間たち（名前＋レベル）
party_members = ["戦士 星空スバリ", "魔法使い 修士みより", "盗賊 港あくび", 12, 15, 10]
item_bag は、ぴこりが冒険中に持ち歩くアイテムをまとめたリスト型の変数です。
party_members には、仲間の名前とレベルが混在しています。Pythonではこのように異なる型（文字列と整数）を混ぜてリストに格納できます。
また、以下コードのように、角括弧 []の中に何も書かないと、「空のリスト」になります。
# 空のリストを作成する
item_bag = []
# リストの内容を表示する
print(item_bag)
空のリストには、append()メソッドなどで後から要素を追加することが可能です。
要素にアクセス
インデックス
Pythonのリストでは、インデックス（要素番号）は0から始まります。
リストの中の各要素（データ）にアクセスするには、角括弧 [ ] でインデックスを指定します。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 0番目のアイテムを表示（袋の一番上）
print("0番目のアイテム：", item_bag[0]) # 出力：剣
# 1番目のアイテムを表示
print("1番目のアイテム：", item_bag[1]) # 出力：弓
# 2番目のアイテムを表示
print("2番目のアイテム：", item_bag[2]) # 出力：やくそう
0番目のアイテム： 弓
2番目のアイテム： やくそう
インデックスに負の値を指定すると。リストの末尾（最後）から順に要素へアクセスできます。
一番後ろを指定するにはに-1、後ろから2番目を指定する場合はlist[-2]となります。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 末尾（一番後ろ）のアイテムを表示
print("一番後ろのアイテム：", item_bag[-1]) # 出力：ドラゴンのうろこ
# 後ろから2番目のアイテムを表示
print("後ろから2番目のアイテム：", item_bag[-2]) # 出力：魔法の石
後ろから2番目のアイテム： 魔法の石
このようにインデックスを -1, -2, -3…と指定することで要素の最後からアクセスできます。
スライス
スライスは、リストの「一部を切り出す」ための構文です。
書式
sequence[start:stop:step]
start：どこから切り始めるか（インデックス）。 省略すると先頭からになる。stop：どこまで切るか（この位置は含まれない）step：何個おきに切るか。省略すると1個おきになる。
サンプルコード①
以下のコードは、スライスでリストから一部の要素を切り出す例です。
# パーティーメンバー
party = ["勇者ぴこり", "戦士スバリ", "魔法使いみより", "僧侶あくび"]
# パーティーメンバーから一部を切り出し、パーティー１を組む
new_party = party[1:4]
# 結果を表示
print("元のパーティー：", party)
print("新しいパーティー：", new_party)
新しいパーティー：[‘戦士スバリ’, ‘魔法使いみより’, ‘僧侶あくび’]
「party[1:4]」は、インデックス1から始まり、インデックス3（インデックス4の手前）で終わる部分を切り出しています。
サンプルコード②
以下のコードは、 start と step を省略し、リストの先頭から途中まで切り出す例です。
# パーティーメンバー
party = ["勇者ぴこり", "戦士スバリ", "魔法使いみより", "僧侶あくび"]
# パーティーメンバーから一部を切り出し、新しいパーティーを組む
new_party = party[:3]
# 結果を表示
print("元のパーティー：", party)
print("新しいパーティー：", new_party)
元のパーティー： ['勇者ぴこり', '戦士スバリ', '魔法使いみより', '僧侶あくび']
新しいパーティー： ['勇者ぴこり', '戦士スバリ', '魔法使いみより']
「party[0:3]」は、インデックス0から始まり、インデックス2（インデックス3の手前）で終わる部分を切り出しています。
サンプルコード③
以下のコードは、 stop と step を省略し、リストの先頭から途中まで切り出す例です。
# パーティーメンバー
party = ["勇者ぴこり", "戦士スバリ", "魔法使いみより", "僧侶あくび"]
# パーティーメンバーから一部を切り出し、新しいパーティーを組む
new_party = party[1:3]
# 結果を表示
print("元のパーティー：", party)
print("新しいパーティー：", new_party)
新しいパーティー： [‘戦士スバリ’, ‘魔法使いみより’]
「party[1:3]」は、インデックス1から始まり、インデックス2（インデックス3の手前）で終わる部分を切り出しています。
サンプルコード④
以下のコードは、start と stop を省略し、リストの先頭から最後まで2個おきに切り出す例です。
# パーティーメンバー
party = ["勇者ぴこり", "戦士スバリ", "魔法使いみより", "僧侶あくび"]
# パーティーメンバーから一部を切り出し、新しいパーティーを組む
new_party = party[::2]
# 結果を表示
print("元のパーティー：", party)
print("新しいパーティー：", new_party)
新しいパーティー： [‘勇者ぴこり’, ‘魔法使いみより’]
「party[::2]」は、step=2で先頭から最後まで2人おきに切り出しています。
サンプルコード⑤
以下のコードは、step=-1 で逆順に切り出す例です。（逆順スライスといいます）
（後衛から前衛へ）
# パーティーメンバー
party = ["勇者ぴこり", "戦士スバリ", "魔法使いみより", "僧侶あくび"]
# パーティーメンバーから一部を切り出し、新しいパーティーを組む
new_party = party[::-1]
# 結果を表示
print("元のパーティー：", party)
print("新しいパーティー：", new_party)
新しいパーティー： [‘僧侶あくび’, ‘魔法使いみより’, ‘戦士スバリ’, ‘勇者ぴこり’]
要素を追加
末尾に追加
Pythonでは、append メソッドを使うことで、リストの末尾（最後の位置）に新しい要素を追加できます。使い方は簡単で、以下のように対象となるリストに対して追加したい値を指定します。
list.append(追加したい値)
以下のコードは、append()メソッドで1つの値をリストに追加する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 新しく拾ったアイテム
new_item = "おやつ"
# 袋の一番後ろに新しく拾ったアイテムを追加
item_bag.append(new_item)
# 現在の袋の中身を表示
print("袋の中身：", item_bag)
末尾に複数の値を追加
append() は1つずつしか値を追加できません。 複数のアイテムを一気に追加したい場合は、extend() メソッドを使います。
使い方は簡単で、以下のように対象となるリストに対して追加したい値を指定します。
リスト型の変数名.append(追加したい値)
以下のコードは、extend()メソッドで複数の値をリストに追加する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 新しく拾った複数のアイテム
new_item = ["おやつ", "銀の盾"]
# 袋の一番後ろに新しく拾った複数のアイテムを追加
item_bag.extend(new_item)
# 現在の袋の中身を表示
print("袋の中身：", item_bag)
「おやつ」と「銀の盾」が袋に追加されました。
好きな位置に値を追加
一番後ろではなく、「好きな位置」に「値」を追加したい場合、insert() メソッドを使います。
書式
insert()メソッドの第一引数には「挿入したい位置（インデックス）」、第一引数には「追加したい値」を指定します。
リスト型の変数名.insert(インデックス番号, 追加したい値)
サンプルコード
以下のコードは、insert()メソッドで値をリストの好きな位置に追加する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ"]
# 新しく手に入れたアイテム
new_item = "おやつ"
# 2番目の位置（やくそうの前）に追加
item_bag.insert(2, new_item)
# 現在の袋の中身を表示
print("袋の中身：", item_bag)
もともと1番目にあった「やくそう」は、後ろにずれて3番目になります。
要素を削除
Pythonでは、del文やpop(), remove(), clear()メソッドを用いることで要素を削除できます。
| 書式 | 動作 |
|---|---|
del list[n] |
指定したインデックス（n番目）の要素を削除 |
list.pop(n) |
指定したインデックス（n番目）の要素を取り出す（取り出した要素はリストから削除される） |
list.remove(値) |
指定した値を削除（リスト内に指定した値が複数あった場合、最初の1つだけ削除される） |
clear() |
すべての要素を一括で削除 |
サンプルコード
以下のコードは、del文でリストの1番目にある要素を削除する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ", "おやつ"]
# 1番目（弓）を削除
del item_bag[1]
print("袋の中身：", item_bag)
サンプルコード
以下のコードは、pop()メソッドでリストの1番目にある要素を取り出す例です。（取り出した要素はリストから削除されます）
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ", "おやつ"]
# 1番目（弓）を取り出して消す
removed_item = item_bag.pop(1)
print("取り出したアイテム：", removed_item) # 出力：弓
print("袋の中身：", item_bag)
袋の中身： [‘剣’, ‘やくそう’, ‘魔法の石’, ‘ドラゴンのうろこ’, ‘おやつ’]
サンプルコード
以下のコードは、remove()メソッドで指定した要素を取り出す例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ", "おやつ"]
# 「弓」という名前のアイテムを探して消す（最初に見つかった1つだけ）
item_bag.remove("弓")
print("袋の中身：", item_bag)
サンプルコード
以下のコードは、clear()メソッドですべての要素を削除する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ", "おやつ"]
# すべての要素を削除
item_bag.clear()
print("袋の中身：", item_bag)
リストそのものは残るので、変数item_bagは引き続き使えます。ログ管理などで、リストを保持したまま中身だけリセットしたい場面に使えます。
① 位置が分かっていて、値は不要 → `del`文
② 位置が分かっていて、値も使いたい → `pop`()メソッド
③ 値だけ分かっていて、位置は分からない → `remove`()メソッド
④ 値をすべてリセットしたい → `clear`()メソッド
要素を探す
Pythonでは、index(), count()メソッドやin演算子を用いることで、リスト内から要素を探すことができます。
| 書式 | 動作 |
|---|---|
| list.index(値) | 指定した値がリストの要素に含まれていた場合、位置（インデックス）を返す（指定した値が複数あった場合、最初に見つかった位置だけ返します） |
| list.count(値) | 指定した値がリストの要素に含まれていた場合、その個数を返す |
| 値 in list | 指定した値がリストの要素に含まれていたらTrue、含まれていなければFalseを返す |
サンプルコード①
以下のコードは、index()メソッドで最初の位置を探す例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "ドラゴンのうろこ", "おやつ"]
# 「おやつ」が最初に出てくる位置を調査
pos = item_bag.index("おやつ")
print(f"おやつは袋の {pos} 番目にある！")
サンプルコード②
以下のコードは、count()メソッドで同じ値が個数あるかを計算する例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "やくそう"]
# 「やくそう」が何個あるか数える
num = item_bag.count("やくそう")
print(f"やくそうは {num} 個持っている！")
サンプルコード③
以下のコードは、in演算子で要素を探索する例です。
# 勇者ぴこりの袋 item_bag = ["剣", "弓", "やくそう", "魔法の石"] # 「ドラゴンのうろこ」があるか調べる result = "ドラゴンのうろこ" in item_bag print(result)
Falseは、「ドラゴンのうろこ」を持っていない（見つからなかった）ということになります。
要素を順番に取り出す(for文)
for文は、イテラブル（リストなどの「繰り返し可能なデータの集まり」）から要素を1つずつ取り出して処理するための構文です。
書式
for 変数 in イテラブル:
処理（ブロック）
| 部分 | 説明 |
|---|---|
変数 |
取り出した要素を一時的に入れるための変数 |
イテラブル |
繰り返し可能なデータの集まり（リスト、文字列、辞書、rangeなど) |
| 処理（ブロック） | インデントされた処理。取り出した要素に対して毎回実行される。 |
イテラブルから「要素」を順番に取り出します。取り出した「要素の値」は変数に格納され、ブロック（インデントされた「処理内容」の部分）を繰り返し実行します。
インデントとは、行の先頭にスペースを入れて「この処理はfor文の中ですよ」とPythonに教えるためのルールです。
■ブロックってなに？
インデントされた複数行の処理をまとめて「ブロック」と呼びます。for文のブロックは、繰り返し実行される部分です。
サンプルコード
以下のコードは、for文でリストの要素を順番に取り出す例です。
# 勇者ぴこりの袋（リスト=イテラブル）
item_bag = ["剣", "弓", "やくそう", "魔法の石"]
print("袋の中身を確認中…")
# for文でリストから 「要素」を順番に取り出して表示
for item in item_bag:
# ブロック内の処理
print(f"→ {item}")
→ 剣
→ 弓
→ やくそう
→ 魔法の石
item には袋から取り出したアイテムが1つずつ入ります。
要素とインデックスを順番に取り出す(for文)
リストの要素だけでなく、インデックス（順番）も一緒に取り出したいときは、 in演算子のあとに enumerate() 関数を使います。
書式
for 変数名1, 変数名2 in enumerate(リスト名):
処理内容（ブロック）
変数名1：取り出した要素番号（インデックス）が一時的に入る変数変数名2：取り出した要素（値）が一時的に入る変数
「要素」と「要素番号」をリストの先頭から1つずつ取り出します。取り出した「要素」と「要素番号」は変数に格納され、ブロック（インデントされた「処理内容」の部分）を繰り返し実行します。
サンプルコード
以下のコードは、 enumerate()を使ってリストから要素とインデックスを順番に取り出すものです。
# 勇者ぴこりの袋
item_bag = ["剣", "やくそう", "弓", "やくそう", "魔法の石", "やくそう"]
# 「要素」と「要素番号」を順番に取り出して表示
for index, item in enumerate(item_bag):
print(f"袋の {index} 番目 → {item}")
袋の 1 番目 → やくそう
袋の 2 番目 → 弓
袋の 3 番目 → やくそう
袋の 4 番目 → 魔法の石
袋の 5 番目 → やくそう
リスト内包表記
「リスト内包表記」とは「イテラブル」から1つずつ要素を取り出し、式に変換して新しいリストを作るコードを1行で実現できる書き方です。
書式
[式 for 変数 in イテラブル]
イテラブル：繰り返し可能なデータ（リストなど）式：各要素に対して行う処理変数：イテラブルから取り出す要素
サンプルコード①
以下のコードは、パーティーメンバーの名前の後ろに「さん」を付けた新しいリストを作成する例です。
# パーティーメンバーの名前リスト names = ["勇者ぴこり", "魔法使いみより", "戦士スバリ", "僧侶あくび"] # 名前の後ろに「さん」をつける greetings = [name + "さん" for name in names] print(greetings) # ['勇者ぴこりさん', '魔法使いみよりさん', '戦士スバリさん', '僧侶あくびさん']
サンプルコード②
以下のコードは、リスト内のすべての数値を2倍にした新しいリストを作成する例です。
# リスト numbers = [1, 2, 3, 4, 5] # リスト内のすべての数値を2倍にした新しいリストを作成 doubled = [n * 2 for n in numbers] print(doubled) # [2, 4, 6, 8, 10]
条件付きのリスト内包表記
「条件付きのリスト内包表記」とは、「イテラブル」から条件を満たす要素を1つずつ取り出し、式に変換して新しいリストを作るコードを1行で実現できる書き方です。
書式
[式 for 変数 in イテラブル if 条件]
イテラブル：繰り返し可能なもの（リストなど）式：各要素に対して行う処理変数：イテラブルから取り出す要素if 条件：イテラブルから取り出す要素の条件
サンプルコード
以下のコードは、「条件付きのリスト内包表記」でリスト内から指定した値のみの順番（インデックス）を全て調べる例です。
# 勇者ぴこりの袋
item_bag = ["剣", "弓", "やくそう", "魔法の石", "弓", "やくそう", "弓"]
# 「弓」があるすべての位置をスキャン！（内包表記）
bow_positions = [index for index, item in enumerate(item_bag) if item == "弓"]
print("弓の位置：", bow_positions)
内包表記により、「袋の中身を順番に見ながら、item が “弓” だったときだけ、その位置（index）をリストに追加していく」という処理を1行のコードで実現しています。
要素に関数を適用(map)
map() 関数は、リストの中の要素に対して一括で処理を適用できます。
書式
map(関数, イテラブル)
- 関数：各要素に対して実行したい処理（例：キャラのステータスを2倍にする）
- イテラブル：リストやタプルなど、繰り返し可能なデータ
map() は、イテラブルの各要素に関数を適用し、新しい値の集まり（mapオブジェクト）を返します。
サンプルコード①
以下のコードは、勇者ぴこりのステータス（HP, MP, 攻撃力, 防御力, 素早さ）をmap() 関数で2倍にする例です。
# ステータスを2倍に強化する関数
def enhance(status):
return status * 2
# 勇者ぴこりのステータス（HP, MP, 攻撃力, 防御力, 素早さ）
pikori_status = [100, 30, 20, 15, 10]
# map関数ですべてのステータスを2倍に強化
new_pikori_status = map(enhance, pikori_status)
# 結果をリストにまとめて表示
print(type(new_pikori_status)) # 強化後のステータス
# map型からリスト型に変換して表示
print("強化後のステータス：", list(new_pikori_status)) # [200, 60, 40, 30, 20]
強化後のステータス： [200, 60, 40, 30, 20]
map() の返り値は「mapオブジェクト」という特殊な形式なので、list() 関数でリストに変換する必要があります。
また、よく使う処理をまとめて「enhance()関数」として定義しています。関数を自分で作ることで、同じ処理を何度も書かずに済み、コードがスッキリします。関数を自分で定義するときの書き方は以下のとおりです。
def 関数名(引数):
処理内容（ブロック）
return 結果
def文：関数を定義するための構文関数名：関数を呼び出すときの名前（自分で自由に決められる）引数：関数に渡す値（処理の対象）- 処理内容（ブロック）：def文の次の行から、インデント（字下げ）された複数行。インデントが終わると、関数のブロックも終わる。関数を呼び出したときに実行される。
return：処理の結果を返す（ブロック内に入れる、つまりインデントが必要）
今回作成した以下の関数は、渡された引数 status の値を2倍にして返します。
# ステータスを2倍に強化する関数
def enhance(status):
return status * 2
サンプルコード②
また、以下コードのように「簡易関数」を使ってサンプルコード①と同様の処理を行うこともできます。
# 勇者ぴこりのステータス（HP, MP, 攻撃力, 防御力, 素早さ） pikori_status = [100, 30, 20, 15, 10] # lambda式でステータスを2倍に強化 new_pikori_status = map(lambda status: status * 2, pikori_status) # map型の確認 print(type(new_pikori_status)) ## map型からリスト型に変換して表示 print("強化後のステータス：", list(new_pikori_status)) # [200, 60, 40, 30, 20]
強化後のステータス： [200, 60, 40, 30, 20]
通常の関数は `def` を使って名前をつけて定義しますが、`lambda` を使えば名前なしで、1行で関数を作ることができます。
「lambda status: status * 2」は、「渡されたステータスを2倍にする関数」をその場で作って、map() 関数に渡しています。
リスト関数（filter）
ストの中から条件を満たす要素だけを取り出すための便利な関数があります。
そのひとつが filter() 関数です。
書式
filter(関数, イテラブル)
関数：各要素に対して条件を判定する処理（True/Falseを返す） |イテラブル：リストやタプルなど、繰り返し可能なデータの集まり |
サンプルコード
# 使えるアイテムかどうかを判定する魔法（奇数なら使える）
def is_usable(item_power):
return item_power % 2 != 0 # 奇数なら True（使える）
# ぴこりのアイテム袋（アイテムのパワー値）
item_bag = [1, 2, 3, 4, 5]
# 魔法で使えるアイテムだけを選別
usable_items = filter(is_usable, item_bag)
# 結果を袋にまとめて表示
print("使えるアイテム：", list(usable_items)) # [1, 3, 5]
この例では、is_odd() という関数を作って「奇数かどうか」を判定しています。
def is_odd(x):
return x % 2 != 0
filter() はこの関数を使って、リストの各要素に対して順番に判定を行い、True が返されたものだけを残します。
また、filter() の返り値は「filterオブジェクト」という特殊な形式です。そのままでは表示できないので、list() を使ってリストに変換しています。
最大値・最小値・合計・平均
max()関数 と min()関数 は、リストから最大値・最小値をもつ要素を取得できます。
書式
max(イテラブル)
min(イテラブル)
max()：最大の値を返すmin()：最小の値を返す- イテラブル：繰り返し可能なデータ（リスト、タプルなど）
サンプルコード
以下のコードは、数値を格納したリストから、最大値と最小値を取得する例です。
# パーティーメンバーのレベルを格納したリスト
levels = [12, 5, 8, 20]
# 最大レベルと最小レベルを表示
print("最強レベル：", max(levels))
print("最弱レベル：", min(levels))
最弱レベル： 5
以下のコードは、文字列を格納したリストから、最大値と最小値を取得する例です。
※ 文字列の場合は「辞書順（Unicode順）」で判定されます。
# パーティーメンバーの名前を格納したリスト
names = ["ぴこり", "スバリ", "みより", "あくび"]
# 辞書順で最大と最小を表示
print(max(names)) # ゾーラ（辞書順で最大）
print(min(names)) # アリス（辞書順で最小）
あくび
sum()関数でリスト内の要素の合計を計算できます。また、合計を要素数で割ることで平均値を求めることができます。（要素数はlen()関数で求まる）
# パーティーメンバーのレベルを格納したリスト
levels = [12, 5, 8, 20]
# 合計レベルを計算
total_level = sum(levels)
# 合計を要素数で割ることで平均レベルを計算
average_level = total_level / len(levels)
# 結果を表示
print("合計レベル：", total_level)
print("平均レベル：", average_level)
平均レベル： 11.25
要素の順序を反転・ソート
Pythonでは、リストの順番を変えるための便利なメソッドが用意されています。
順序を逆にしたいときは reverse()、並び替えたいときは sort() を使います。
※どちらも「元のリストを直接変更」します（新しいリストは作られません）
| 操作 | 書式 | 説明 |
|---|---|---|
| 順序反転 | list.reverse() |
リストの要素を逆順に並び替える |
| ソート | list.sort() |
リストの要素を昇順（小さい順）に並び替える |
サンプルコード
# リストの生成（アイテムの強さ順ではない）
data = [2, 1, 4, 3]
# リストの反転（順番を逆にする）
data.reverse()
print("反転後：", data) # [3, 4, 1, 2]
# リストのソート（小さい順に並び替える）
data.sort()
print("ソート後：", data) # [1, 2, 3, 4]
ソート後： [1, 2, 3, 4]
reverse()メソッド と sort()メソッド は、元のリストを直接変更するため、元の順番を残しておきたい場合はコピーを作ってから使うと安心です。また、sort() メソッド は、数値だけでなく文字列にも使えますが、並び順はアルファベット順や辞書順になります。
例：ぴこりが袋の中身を「最後に入れた順」で確認したいとき
`sort()` は、数値や文字列を並び替えたいときに使います
例：アイテムの強さ順、名前順など
リストの結合と繰り返し
以下コードのように、リスト同士の結合をする場合は、’+’、リストの繰り返しをする場合は’*’を使います。
# アイテム袋AとB
bag_a = ["剣", "盾"]
bag_b = ["やくそう", "魔法の石"]
# 結合（+）
combined_bag = bag_a + bag_b
print("結合された袋：", combined_bag) # ['剣', '盾', 'やくそう', '魔法の石']
# 繰り返し（*）
repeated_bag = bag_a * 2
print("繰り返された袋：", repeated_bag) # ['剣', '盾', '剣', '盾']
[‘剣’, ‘盾’, ‘剣’, ‘盾’]
ネストされたリスト（2次元リスト）
「ネストされたリスト」とは、リストの中にさらにリストが入っている構造のことです。一般的には「2次元リスト」と呼ばれることが多いです。
記述例
以下は、「ネストされたリスト」の記述例です。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
- 外側のリスト：4人の冒険者
- 内側のリスト：各冒険者が持っているアイテム
このような構造は、以下のような表形式のデータ（行と列）を扱うときに便利です。
| – | 勇者ぴこり | 戦士スバリ | 魔法使いみより | 僧侶あくび |
|---|---|---|---|---|
| 持ち物1 | 勇者の杖 | 力の剣 | 魔法書 | 回復の杖 |
| 持ち物2 | 金の盾 | 力の盾 | 魔法の杖 | 賢者の石 |
| 持ち物3 | 薬草 | 銀の鎧 | マナポーション | 隠れ身のマント |
要素へのアクセス
リスト名[行][列] のように、2段階のインデックス指定で要素にアクセスします。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
print("勇者ぴこりの持ち物（すべて）：", party_items[0])
print("戦士スバリの持ち物3：", party_items[1][2])
戦士スバリの持ち物3： 銀の鎧
要素の追加（append）
普通のリストと同様、2次元リストに要素を追加したいときは、append() を使います。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
# 勇者ぴこりが新しいアイテムを追加
party_items[0].append("魔除けの指輪")
# 結果を表示
print(party_items)
ただし、内側のリストの要素数がバラバラだと、ループ処理や表形式の表示で工夫が必要になることがあります。
要素の変更（代入）
アイテムを入れ替えたいときは、インデックスを指定して代入します。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
# 魔法使いみよりの2番目のアイテムを変更
party_items[2][1] = "炎の杖"
# 結果を表示
print(party_items)
外側のリストに要素を追加（新しい冒険者をパーティに加える）するには、外側のリストに append() します。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
# 新メンバー「盗賊みけ」
party_items.append(["短剣", "盗賊のマント", "煙玉"])
# 結果を表示
print(party_items[-1])
for文
以下のコードは、for文でネストされたリストからインデックス番号と要素を取り出して表示する例です。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
# for文でインデックス番号と要素を取得して表示
for i, items in enumerate(party_items):
print(f"冒険者{i+1}の持ち物：{items}")
冒険者2の持ち物：[‘力の剣’, ‘力の盾’, ‘銀の鎧’]
冒険者3の持ち物：[‘魔法書’, ‘魔法の杖’, ‘マナポーション’]
冒険者4の持ち物：[‘回復の杖’, ‘賢者の石’, ‘隠れ身のマント’]
要素数を調べる
以下のコードは、for文でネストされたリストの要素数を調べて表示する例です。
party_items = [
["勇者の杖", "金の盾", "薬草"], # 「勇者ぴこり」の持ち物
["力の剣", "力の盾", "銀の鎧"], # 「戦士スバリ」の持ち物
["魔法書", "魔法の杖", "マナポーション"], # 「魔法使いみより」の持ち物
["回復の杖", "賢者の石", "隠れ身のマント"] # 「僧侶あくび」の持ち物
]
# 結果を表示
print("パーティーメンバーの人数：", len(party_items))
print("魔法使いみよりの持ち物の数：", len(party_items[2]))
魔法使いみよりの持ち物の数： 3
参照の共有、深いコピー、浅いコピー
参照の共有
Pythonでリストを単純に代入（=）すると、新しいリストが作られるわけではなく、元のリストと同じオブジェクトを参照することになります。これは「コピー」ではなく「参照の共有」といいます。
以下のコードは、「単純な代入（参照の共有）」を行う例です。
# 勇者ぴこりの袋
original_bag = ["剣", "盾", "薬草"]
# 単純な代入（参照の共有）
shared_bag = original_bag
# 要素を追加
shared_bag.append("魔法石")
# 結果を表示
print("original_bag：", original_bag)
print("shared_bag：", shared_bag)
shared_bag： [‘剣’, ‘盾’, ‘薬草’, ‘魔法石’]
`shared_bag = original_bag` は、**original_bagとshared_bagが同じリストを指す**ことになります。（参照の共有）
よって、どちらかで変更を加えると、もう一方にも反映されます。
---
### 浅いコピー
`copy()` メソッドは、「元のリストを壊さずに、同じ内容を持つ新しいリストを作る」ことができます。代入（`=`）とは異なり、コピー後のリストは元のリストとは独立しているため、変更しても元のリストに影響を与えません。このようなコピーを「**浅いコピー（shallow copy）**」といいます。
【書式】
```python
new_list = original_list.copy()
- 元のリスト（original_list）の内容を複製します。
- 新しいリストオブジェクト（new_list）が作られるので、元のリスト（original_list）を変更してもコピーには影響しません。
以下のコードは、copy() メソッドを使って浅いコピーを行ったあと、コピーで作成したリストに要素を追加する例です。
# 勇者ぴこりの袋
original_bag = ["剣", "盾", "薬草"]
# 勇者ぴこりの袋を浅いコピー
copy_bag = original_bag.copy()
# コピーで作成した袋に「魔法石」を追加
copy_bag.append("魔法石")
# 元の袋とコピーされた袋の中身を表示
print("勇者の持ち物：", original_bag)
print("コピーの持ち物：", copy_bag)
コピーの持ち物： [‘剣’, ‘盾’, ‘薬草’, ‘魔法石’]
このように、copy() メソッドを使った浅いコピーでは、元のリストには影響がないことがわかります。
ただし、「ネストされたリスト」に使うと、外側のリストは複製されますが、内側のリストは元のリストと共有されたままになります。
以下のコードは、「ネストされたリスト」に浅いコピーを使用した例です。
# ネストされたリスト（元）
original_bag = [["剣", "盾"], ["薬草", "地図"]]
# ネストされたリスト（浅いコピー）
shallow = original.copy()
# コピー側のインデックス[0, 0]番目のアイテムを変更
shallow[0][0] = "木の棒"
# 結果を表示
print("元のリスト：", original)
print("コピーリスト：", shallow)
元のリスト： [[‘木の棒’, ‘盾’], [‘薬草’, ‘地図’]]
コピーリスト： [[‘木の棒’, ‘盾’], [‘薬草’, ‘地図’]]
<div class="warning-box"> `original.copy()` は、**外側のリスト（＝2つの行）だけを新しく作ります。しかし、各行（内側のリスト）は**元のリストと同じオブジェクト**を指しています。そのため、コピー側で内側の要素を変更すると、元のリストにも反映されてしまいます。</div>
ネストされたリストを**完全に独立したコピー**にしたい場合は、深いコピー（`copy.deepcopy()`） を使います。
### 深いコピー
浅いコピーでは、リストの中にリストが含まれているような**ネストされた構造**の場合、内側のリストは元のリストと共有されてしまいます。これに対して、**すべての階層を完全に複製する**方法が「**深いコピー（deep copy）**」です。
深いコピーを行うには、Pythonの標準ライブラリ `copy` モジュールの `deepcopy()` 関数を使います。
【書式】
```python
import copy
new_list = copy.deepcopy(original_list)
deepcopy()は、元のリストのすべての階層を再帰的に複製します。- ネストされたリストの中身も完全に独立したオブジェクトになります。
以下のコードは、ネストされたリストを深いコピーしたあと、コピー側の内容を変更しても元のリストに影響しないことを示す例です。
import copy # copyモジュールをインポート
# 勇者ぴこりと仲間たちの装備袋（ネストされたリスト）
party_bags = [
["剣", "盾"], # 戦士ぴこりの袋
["弓", "マント"] # 弓使いぴこりの袋
]
# 深いコピーで完全に複製
copied_bags = copy.deepcopy(party_bags)
# コピー側の戦士ぴこりの剣を「木の棒」に変更
copied_bags[0][0] = "木の棒"
# 元の袋とコピーされた袋の中身を表示
print("元の持ち物：", party_bags)
print("コピーの持ち物：", copied_bags)
コピーの持ち物： [[‘木の棒’, ‘盾’], [‘弓’, ‘マント’]]
このように、deepcopy() を使えば、内側のリストも含めて完全に独立したコピーが作成されるため、元のリストには一切影響がありません。
練習問題（基礎固め ＆ 資格勉強用）
本ページで学んだ内容の基礎を固めるため、練習問題を作成しました。
Pythonのリスト型（List）に関する基本操作を確認し、「Python 3 エンジニア認定基礎試験」や「基本情報技術者試験」などの資格取得に向けて、理解を深めましょう。
【問題1】リストの定義方法
次のうち、Pythonでリストを定義する正しい方法を選びなさい。
A. list = {1, 2, 3}
B. list = (1, 2, 3)
C. list = [1, 2, 3]
D. list = <1, 2, 3>
解説：Pythonでは、角括弧 `[]` を使ってリストを定義します。波括弧 `{}` は集合型、丸括弧 `()` はタプル型です。
【問題2】インデックスの基本
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
print(items[1])
A. 剣
B. 盾
C. 薬草
D. エラーになる
解説：Pythonのリストは0から始まるインデックスで要素にアクセスします。`items[1]` は2番目の要素「盾」を指します。
【問題3】末尾の要素を取得する方法
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
print(items[-1])
A. 剣
B. 盾
C. 薬草
D. エラーになる
解説：インデックスに負の値を指定すると、リストの末尾から要素を取得できます。`-1` は最後の要素「薬草」です。
【問題4】append()メソッド
次のコードの実行後、itemsの中身として正しいものを選びなさい。
items = ["剣", "盾"]
items.append("薬草")
A. ["剣", "盾"]
B. ["剣", "薬草", "盾"]
C. ["剣", "盾", "薬草"]
D. ["薬草", "剣", "盾"]
解説：`append()` メソッドは、リストの末尾に要素を追加します。
【問題5】extend()メソッド
次のコードの実行後、itemsの中身として正しいものを選びなさい。
items = ["剣"]
items.extend(["盾", "薬草"])
A. ["剣", ["盾", "薬草"]]
B. ["剣", "盾", "薬草"]
C. ["盾", "薬草", "剣"]
D. ["剣", "盾"]
解説：`extend()` はリストに複数の要素を一括で追加します。ネストせず、要素が展開されます。
【問題6】del文
次のコードの実行後、itemsの中身として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
del items[1]
A. ["剣", "盾", "薬草"]
B. ["剣", "薬草"]
C. ["盾", "薬草"]
D. ["剣", "盾"]
解説：`del` 文は指定したインデックスの要素を削除します。`items[1]` は「盾」なので、それが削除されます。
【問題7】in演算子
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
print("盾" in items)
A. True
B. False
C. “盾”
D. エラーになる
解説：`in` 演算子は、指定した値がリストに含まれているかを判定します。含まれていれば `True` を返します。
【問題8】for文
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾"]
for item in items:
print(item)
A. 剣
B. 盾
C. 剣 盾（改行あり）
D. エラーになる
解説：`for` 文を使うことで、リストの各要素を順番に取り出して処理できます。改行されて2行に表示されます。
【問題9】sortメソッド
次のコードの出力として正しいものを選びなさい。
items = [3, 1, 2]
items.sort()
print(items)
A. [3, 1, 2]
B. [1, 2, 3]
C. [2, 1, 3]
D. エラーになる
解説：`sort()` メソッドはリストの要素を昇順に並び替えます。元のリストが直接変更されるため、`items` は `[1, 2, 3]` になります。
【問題10】copy()メソッド
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾"]
backup = items.copy()
items.append("薬草")
print(backup)
A. ["剣", "盾", "薬草"]
B. ["剣", "盾"]
C. ["薬草"]
D. エラーになる
解説：`copy()` メソッドは元のリストの内容を複製します。`items` に新たに追加された「薬草」は `backup` には影響しません。
【問題11】len()関数
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
print(len(items))
A. 2
B. 3
C. 4
D. エラーになる
解説：`len()` 関数はリストの要素数を返します。この場合、3つの要素があるため `3` が出力されます。
【問題12】スライス
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草", "魔法書"]
print(items[1:3])
A. ["盾", "薬草"]
B. ["剣", "盾", "薬草"]
C. ["薬草", "魔法書"]
D. ["盾", "薬草", "魔法書"]
解説：スライス `[1:3]` は、インデックス1から2までの要素を取得します。終了インデックスは含まれません。
【問題13】+ 演算子
次のコードの出力として正しいものを選びなさい。
a = ["剣"]
b = ["盾", "薬草"]
print(a + b)
A. ["剣", ["盾", "薬草"]]
B. ["剣", "盾", "薬草"]
C. ["盾", "薬草", "剣"]
D. ["剣", "盾"]
解説：`+` 演算子を使うと、2つのリストを結合できます。ネストせず、要素が並びます。
【問題14】*演算子
次のコードの出力として正しいものを選びなさい。
items = ["剣"] * 3
print(items)
A. ["剣", "剣", "剣"]
B. ["剣", "盾", "薬草"]
C. ["剣", "剣"]
D. ["剣"]
解説：`*` 演算子を使うと、リストの要素を指定回数だけ繰り返すことができます。
【問題15】max()メソッドとmin()メソッド
次のコードの出力として正しいものを選びなさい。
numbers = [5, 2, 9]
print(max(numbers), min(numbers))
A. 9 2
B. 5 2
C. 2 9
D. エラーになる
解説：`max()` は最大値、`min()` は最小値を返します。数値リストに対して使用可能です。
【問題16】index()メソッド
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
print(items.index("薬草"))
A. 0
B. 1
C. 2
D. エラーになる
解説：`index()` メソッドは、指定した要素のインデックスを返します。「薬草」は3番目なのでインデックスは `2` です。
【問題17】count()メソッド
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "剣"]
print(items.count("剣"))
A. 1
B. 2
C. 3
D. エラーになる
解説：`count()` メソッドは、指定した要素がリスト内に何回出現するかを返します。「剣」は2回登場しています。
【問題18】reverse() メソッド
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
items.reverse()
print(items)
A. ["剣", "盾", "薬草"]
B. ["薬草", "盾", "剣"]
C. ["盾", "剣", "薬草"]
D. エラーになる
解説：`reverse()` メソッドは、リストの要素を逆順に並び替えます。元のリストが直接変更されます。
【問題19】clear()メソッド
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草"]
items.clear()
print(items)
A. ["剣", "盾", "薬草"]
B. []
C. None
D. エラーになる
解説：`clear()` メソッドは、リストのすべての要素を削除します。空のリスト `[]` が残ります。
【問題20】リストの代入と参照
次のコードの出力として正しいものを選びなさい。
a = ["剣", "盾"]
b = a
a.append("薬草")
print(b)
A. ["剣", "盾"]
B. ["剣", "盾", "薬草"]
C. ["薬草"]
D. エラーになる
解説：`b = a` のように代入すると、`b` は `a` と同じリストオブジェクトを参照します。したがって、`a` に `append()` で要素を追加すると、`b` にも反映されます。
【問題21】内包表記の基本構文
次のうち、Pythonの内包表記として正しい構文を選びなさい。
A. [x for x in range(5)]
B. for x in range(5): [x]
C. list(x for x in range(5))
D. x = [for x in range(5)]
解説：内包表記は `[式 for 変数 in イテラブル]` の形式で書きます。選択肢Aが正しい構文です。
【問題22】偶数だけを抽出する内包表記
次のコードの出力として正しいものを選びなさい。
even = [x for x in range(6) if x % 2 == 0]
print(even)
A. [0, 2, 4, 6]
B. [2, 4, 6]
C. [0, 2, 4]
D. [1, 3, 5]
解説：`range(6)` は 0〜5 を生成します。`x % 2 == 0` により偶数のみ抽出され、結果は `[0, 2, 4]` です。
【問題23】文字列のリスト変換
次のコードの出力として正しいものを選びなさい。
words = "魔法 剣 盾".split()
upper = [w.upper() for w in words]
print(upper)
A. ["魔法", "剣", "盾"]
B. ["魔法".upper(), "剣".upper(), "盾".upper()]
C. ["魔法", "剣", "盾"].upper()
D. ["魔法", "剣", "盾"]（すべて大文字）
解説：`split()` で文字列を分割し、`upper()` で各要素を大文字に変換しています。日本語でも `.upper()` は適用可能です。
【問題24】ネストされた内包表記
次のコードの出力として正しいものを選びなさい。
pairs = [(x, y) for x in range(2) for y in range(2)]
print(pairs)
A. [(0, 0), (0, 1), (1, 0), (1, 1)]
B. [(0, 0), (1, 1)]
C. [(0, 1), (1, 0)]
D. [(0, 0), (1, 0), (0, 1), (1, 1)]
解説：内包表記は左から順にループが展開されます。`x` が外側、`y` が内側のループで、すべての組み合わせが生成されます。
【問題25】条件付き代入を含む内包表記
次のコードの出力として正しいものを選びなさい。
labels = ["even" if x % 2 == 0 else "odd" for x in range(3)]
print(labels)
A. ["even", "even", "even"]
B. ["odd", "odd", "odd"]
C. ["even", "odd", "even"]
D. ["even", "odd", "odd"]
解説：条件式を使った内包表記では、各要素に対して条件分岐が適用されます。`range(3)` は `[0, 1, 2]` なので、偶奇判定の結果は `[“even”, “odd”, “even”]` です。
【問題26】map関数の基本
次のコードの出力として正しいものを選びなさい。
numbers = [1, 2, 3]
result = list(map(lambda x: x * 2, numbers))
print(result)
A. [2, 4, 6]
B. [1, 2, 3]
C. [1, 4, 9]
D. [(1, 2), (2, 4), (3, 6)]
解説：`map()` 関数は、各要素に対して関数を適用します。ここでは `lambda x: x * 2` により、すべての値が2倍になります。
【問題27】filter関数の基本
次のコードの出力として正しいものを選びなさい。
numbers = [1, 2, 3, 4]
result = list(filter(lambda x: x % 2 == 0, numbers))
print(result)
A. [1, 3]
B. [2, 4]
C. [1, 2, 3, 4]
D. [0, 2]
解説：`filter()` 関数は、条件を満たす要素だけを抽出します。ここでは偶数のみが残り、`[2, 4]` になります。
【問題28】map関数と文字列操作
次のコードの出力として正しいものを選びなさい。
words = ["剣", "盾", "薬草"]
result = list(map(str.upper, words))
print(result)
A. ["剣", "盾", "薬草"]
B. ["剣".upper(), "盾".upper(), "薬草".upper()]
C. ["剣", "盾", "薬草"]（すべて大文字）
D. ["剣", "盾", "薬草"].upper()
解説：`map(str.upper, words)` は、各文字列に対して `upper()` を適用します。日本語でも `.upper()` は有効です。
【問題29】filter関数と条件分岐
次のコードの出力として正しいものを選びなさい。
items = ["剣", "盾", "薬草", "魔法書"]
result = list(filter(lambda x: "魔" in x, items))
print(result)
A. ["魔法書"]
B. ["剣", "盾", "薬草"]
C. ["魔法書", "薬草"]
D. ["魔"]
解説：`filter()` に渡されたラムダ式は、「魔」という文字を含む要素だけを抽出します。結果は `[“魔法書”]` です。
【問題30】mapとfilterの組み合わせ
次のコードの出力として正しいものを選びなさい。
numbers = [1, 2, 3, 4, 5]
result = list(map(lambda x: x * 10, filter(lambda x: x % 2 == 1, numbers)))
print(result)
A. [10, 30, 50]
B. [20, 40]
C. [1, 3, 5]
D. [10, 20, 30, 40, 50]
解説：`filter()` で奇数 `[1, 3, 5]` を抽出し、`map()` でそれぞれ10倍に変換します。結果は `[10, 30, 50]` です。
課題（実践力強化用）
Pythonプログラミングの実践力を強化したい人向けの課題を用意しました。仕様通りに動くプログラムを書いたり、エラーメッセージを読んでコードを修正するという作業は、プログラミングおいて重要ですので、初心者の方は是非チャレンジしてみてください。
課題① リストのインデックス指定ミス
以下のコードを実行するとエラーが表示されます。
リストの要素「魔法の石」を正しく表示するようにコードを修正してください。
item_bag = ["剣", "弓", "薬草", "魔法の石"]
print(item_bag[4])
解説：リストのインデックスは0から始まるため、4番目の要素は存在しません。正しくは
item_bag[3] です。
print(item_bag[3])
課題② リストの末尾に要素を追加
以下の仕様を満たすコードを完成させてください。
- 「剣」、「弓」、「薬草」の3つの要素をもつリスト
item_bagを作成する - リスト
item_bagに「ドラゴンのうろこ」を追加する - 追加後のリストを表示する
append() メソッドを使うことで、リストの末尾に要素を追加できます。
item_bag = ["剣", "弓", "薬草", "魔法の石"]
item_bag.append("ドラゴンのうろこ")
print(item_bag)
課題③ リストのスライスで一部を抽出
以下の仕様を満たすコードを完成させてください。
- 「剣」、「弓」、「薬草」の3つの要素をもつリスト
item_bagを作成する - リスト
item_bagの中から「弓」「薬草」だけを抽出して表示する
[start:stop] を使うことで、範囲指定して要素を抽出できます。
item_bag = ["剣", "弓", "薬草", "魔法の石"]
print(item_bag[1:3])
課題④ filter関数で条件抽出
以下のコードを修正して、偶数だけを抽出して表示してください。
numbers = [1, 2, 3, 4, 5]
result = filter(x % 2 == 0, numbers)
print(list(result))
解説：
filter() には関数を渡す必要があります。ラムダ式を使って条件を定義しましょう。
numbers = [1, 2, 3, 4, 5]
result = filter(lambda x: x % 2 == 0, numbers)
print(list(result))
課題⑤ map関数で要素を変換
以下の仕様を満たすコードを完成させてください。
- 1, 2, 3, 4, 5の5つの要素をもつリスト
numbersを作成する - リスト
numbersのすべての要素を2倍にして表示する
map() 関数を使うことで、各要素に処理を一括適用できます。結果は list() で変換して表示します。
numbers = [1, 2, 3, 4, 5]
result = map(lambda x: x * 2, numbers)
print(list(result))
課題⑥ ネストされたリストの要素抽出
以下のコードを修正して、「魔法書」を表示してください。
inventory = [["剣", "盾"], ["薬草", "魔法書"]]
print(inventory[1][2])
解説：ネストされたリストでは、外側と内側のインデックスを正しく指定する必要があります。
inventory[1] は ["薬草", "魔法書"] なので、[1] を使えば「魔法書」が取り出せます。
print(inventory[1][1])
課題⑦ 条件付きリスト生成（内包表記＋条件）
以下の仕様を満たすコードを完成させてください。
- 1〜10のうち、偶数だけを2倍にしてリストに格納する
- 結果を表示する
result = [x * 2 for x in range(1, 11) if x % 2 == 0]
print(result)
課題⑧ リストと関数の副作用
以下のコードを実行すると、意図しない結果になります。
「original」は変更せず、「copy」だけに「魔法石」を追加するように修正してください。
original = ["剣", "盾"]
copy = original
copy.append("魔法石")
print(original)
copy = original は参照コピーのため、copy に変更を加えると original にも影響します。解決策：
copy() メソッドで独立したリストを作成しましょう。
original = ["剣", "盾"]
copy = original.copy()
copy.append("魔法石")
print(original) # ['剣', '盾']
print(copy) # ['剣', '盾', '魔法石']
課題⑨ リストのソート（カスタムキー）
以下の仕様を満たすコードを完成させてください。
- リスト
itemsを「文字数が短い順」に並び替える - 結果を表示する
items = ["魔法書", "剣", "ドラゴンのうろこ", "盾"]
sort() に key=len を指定することで、文字列の長さに基づいて並び替えができます。
items = ["魔法書", "剣", "ドラゴンのうろこ", "盾"]
items.sort(key=len)
print(items)
課題⑩ リストの重複除去と並び替え
以下の仕様を満たすコードを完成させてください。
- リスト
dropsから重複を除去し、昇順に並び替える - 結果を表示する
drops = [5, 3, 5, 2, 3, 1]
set() で重複を除去し、sorted() で並び替えます。元のリストは変更されません。
drops = [5, 3, 5, 2, 3, 1]
unique_sorted = sorted(set(drops))
print(unique_sorted)
課題⑪ インデックスと負の指定
以下のコードを修正して、「魔法の石」と「ドラゴンのうろこ」をそれぞれ表示してください。
item_bag = ["剣", "弓", "薬草", "魔法の石", "ドラゴンのうろこ"]
print(item_bag[4])
print(item_bag[-2])
item_bag[4] は「ドラゴンのうろこ」、item_bag[-2] は「魔法の石」です。
print(item_bag[-1]) # ドラゴンのうろこ
print(item_bag[-2]) # 魔法の石
課題⑫ スライスで一部抽出
以下の仕様を満たすコードを完成させてください。
- リスト
item_bagの中から「弓」「薬草」「魔法の石」だけを抽出して表示する
item_bag = ["剣", "弓", "薬草", "魔法の石", "ドラゴンのうろこ"]
[start:stop] を使い、インデックス1〜3を指定します。stopは含まれない点に注意。
item_bag = ["剣", "弓", "薬草", "魔法の石", "ドラゴンのうろこ"]
print(item_bag[1:4])
課題⑬ extendとinsertの違い
以下のコードを修正して、リストの先頭に「地図」、末尾に「銀の盾」「おやつ」を追加してください。
item_bag = ["剣", "弓"]
item_bag.extend("銀の盾", "おやつ")
item_bag.insert("地図")
print(item_bag)
extend() はリストを渡す必要があり、insert() は位置と値の2つの引数が必要です。
item_bag = ["剣", "弓"]
item_bag.insert(0, "地図")
item_bag.extend(["銀の盾", "おやつ"])
print(item_bag)
# 出力：['地図', '剣', '弓', '銀の盾', 'おやつ']
課題⑭ 条件付き内包表記
以下の仕様を満たすコードを完成させてください。
- 1〜10のうち、奇数だけを「奇数：x」という文字列に変換してリストに格納する
result = [f"奇数：{x}" for x in range(1, 11) if x % 2 != 0]
print(result)
課題⑮ sortとreverseの違い
以下のコードを修正して、リストを「昇順」と「逆順」でそれぞれ表示してください。
levels = [12, 5, 8, 20]
levels.sort(reverse=True)
levels.reverse()
print(levels)
sort() は並び替え、reverse() は順序を反転します。両方を使うと混乱しやすいので、目的に応じて使い分けましょう。
levels = [12, 5, 8, 20]
levels.sort() # 昇順：[5, 8, 12, 20]
print("昇順：", levels)
levels.reverse() # 逆順：[20, 12, 8, 5]
print("逆順：", levels)
課題⑯ ステータスの差を求めよう
以下のリストは、冒険者「ルカ」のステータスです。最大値と最小値の差（ステータスのばらつき）を求めてください。
luka_status = [120, 85, 95, 60, 100]
luka_status = [120, 85, 95, 60, 100]
diff = max(luka_status) - min(luka_status)
print("ステータス差：", diff)
課題⑰ 2次元リストから特定の職業を抽出しよう
以下のパーティーリストから、「僧侶」の名前だけを表示してください。
party = [
["勇者", "ぴこり"],
["僧侶", "みより"],
["盗賊", "あくび"]
]
方法①
for文で実装した例は以下のとおり。
party = [
["勇者", "ぴこり"],
["僧侶", "みより"],
["盗賊", "あくび"]
]
for member in party:
if member[0] == "魔法使い":
print("魔法使いの名前：", member[1])
方法②
インデックスを指定して表示させることもできます。
party = [
["勇者", "ぴこり"],
["僧侶", "みより"],
["盗賊", "あくび"]
]
print("魔法使いの名前：", party[1][1])
課題⑱ map関数でHPを回復
以下のHPリストに対して、全員のHPを30回復させた新しいリストを作成してください。
hp_list = [70, 45, 90, 60]
hp_list = [70, 45, 90, 60]
recovered = list(map(lambda x: x + 30, hp_list))
print("回復後のHP：", recovered)
課題⑲ filter関数で重いアイテムを除外
以下のアイテム重量リストから、重量が20以下の軽いアイテムだけを抽出してください。
# アイテム重量リスト
item_weights = [10, 25, 18, 30, 15]
item_weights = [10, 25, 18, 30, 15]
light_items = list(filter(lambda x: x <= 20, item_weights))
print("軽いアイテム：", light_items)
課題⑳ mapとfilterで魔法石の強化
以下の魔法石リストから、偶数の魔力値だけを抽出し、それを2倍に強化したリストを作成してください。
magic_stones = [11, 20, 17, 14, 9]
magic_stones = [11, 20, 17, 14, 9]
even_stones = filter(lambda x: x % 2 == 0, magic_stones)
enhanced = list(map(lambda x: x * 2, even_stones))
print("強化された魔法石：", enhanced)
関連ページ（もっと学びたい人へ）
Pythonの基礎から応用例まで、以下ページから学ぶことができます。