forループを卒業したいPython初学者のための内包表記入門！可読性と処理速度を上げる実践テクニック

Pythonでリストや辞書を扱うとき、多くの初学者はまずforループでの実装を覚えます。
しかし、実務でコードを書き続けていくと、forループには「行数が増えやすい」「本質的な処理が読み取りにくい」という課題が見えてきます。

# forループの例
squares = []
for i in range(10):
    squares.append(i ** 2)

このコードは決して悪くはありませんが、内包表記を使うことで、同じ処理を1行で、しかもより意図が伝わる形で書くことができます。

内包表記が持つ利点は、可読性だけではありません。
CPythonの内部実装では、内包表記はループとappend処理を繰り返すよりも効率的にバイトコードへ変換されるため、多くのケースで処理速度の向上にもつながります。
これは単なる書き方の好みの問題ではなく、コンピューターサイエンスの観点から見ても合理的な選択なのです。

本記事では、以下の内容を順を追って解説していきます。

リスト内包表記の基本構文と考え方
辞書内包表記・集合内包表記への応用
条件分岐を組み込んだ実践的な書き方
forループとの処理速度の比較

「内包表記は難しそう」と感じている方でも、ロジックの組み立て方を理解すれば、自然と使いこなせるようになります。
この記事を通じて、forループへの依存から一歩抜け出し、より洗練されたPythonコードを書けるようになりましょう。

なぜPython初学者は内包表記でつまずくのか?forループとの違いを解説
1. forループで書く一般的なコード例
2. 内包表記が難しく見える理由
【基本】リスト内包表記の書き方をforループと比較して理解する
条件式を使った内包表記の実践テクニック(if文の書き方)
辞書内包表記・集合内包表記への応用方法
ネストした内包表記で多重forループを置き換えるテクニック
1. 二重forループを1行で書く方法
2. ネストが深くなる際の可読性の注意点
内包表記とforループの処理速度を比較検証してみた
1. timeitモジュールを使った速度計測方法
2. 検証結果からわかること
可読性を損なわない内包表記の使い分けとアンチパターン
1. 内包表記を使うべきでないケース
2. ジェネレータ式との使い分け
内包表記をマスターするための練習問題とおすすめの学習法
1. 初心者向け練習問題
2. 参考になる公式ドキュメント
まとめ:内包表記を使いこなしてPythonコードの質を高めよう

なぜPython初学者は内包表記でつまずくのか?forループとの違いを解説

forループのコードと内包表記のコードを見比べて戸惑うPython初学者のイメージ

Pythonを学び始めた方の多くは、まずforループを使ってリストや辞書を操作する方法を身につけます。
これは非常に自然な流れです。
forループは処理の流れが上から下へと明確に読み取れるため、初学者にとって理解しやすい構文だからです。

しかし、コードを書く経験を積んでいくと、次第に内包表記という別の書き方に出会います。
同じ処理をより短く書けるこの構文に対して、多くの初学者が「読みにくい」「覚えることが多そうだ」という印象を持ち、結果として敬遠してしまう傾向があります。

このつまずきの背景には、構文そのものの違いだけでなく、思考の順序が根本的に異なるという事情があります。
以下で具体的に見ていきましょう。

forループで書く一般的なコード例

まずは、Python初学者が最初に習得する典型的なforループの実装例を確認します。

# 1から10までの数値のうち、偶数の2乗を取得する
even_squares = []
for i in range(1, 11):
    if i % 2 == 0:
        even_squares.append(i ** 2)

このコードは、以下のような順序で処理が進みます。

空のリストを用意する
rangeで生成される数値を1つずつ取り出す
条件式で偶数かどうかを判定する
条件を満たした値を加工してリストに追加する

処理の流れが上から下へと素直に並んでいるため、初学者でも一行ずつ丁寧に追えば理解できる構造になっています。

内包表記が難しく見える理由

一方、同じ処理を内包表記で書くと、次のようになります。

even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]

この1行には、先ほどのforループ4行分の処理がすべて凝縮されています。
ここで初学者が戸惑う最大の理由は、情報の記述順序が逆転していることにあります。

forループでは「繰り返す→判定する→加工する→格納する」という時系列に沿って処理を書きますが、内包表記では「格納する値の形」を最初に書き、そのあとに「どこから」「どんな条件で」取り出すかを続けます。
人間の思考が持つ時系列的な処理順序と構文上の記述順序が一致しないため、初見では読み解きにくく感じてしまうのです。

つまり、内包表記が難しいのではなく、読み解くための視点の切り替えがまだできていないだけとも言えます。
次の章から、この視点の切り替え方を段階的に解説していきます。

【基本】リスト内包表記の書き方をforループと比較して理解する

前章で触れたとおり、内包表記が読みにくく感じる原因は、記述順序がforループと異なる点にあります。
この章では、その構文構造を分解しながら、forループとの対応関係を1つずつ丁寧に確認していきます。
仕組みを理解してしまえば、内包表記は決して特殊な構文ではないことがわかるはずです。

リスト内包表記の基本構文

リスト内包表記は、以下のような構文で構成されています。

[式 for 変数 in イテラブル]

具体例で確認してみましょう。
文字列のリストから、それぞれの要素の文字数を取得する処理です。

words = ["python", "java", "go"]
lengths = [len(word) for word in words]
# 結果: [6, 4, 2]

構文は大きく分けて3つの要素で成り立っています。

要素	役割	上記コードでの該当箇所
式	格納する値の形を定義する	`len(word)`
変数	イテラブルから取り出す要素の名前	`word`
イテラブル	繰り返し対象のデータ	`words`

この3要素の並び順を意識するだけで、内包表記の可読性は大きく向上します。

forループとの処理の対応関係

内包表記が行っている処理は、forループと完全に同じです。
違いは記述する順序だけです。

lengths = []
for word in words:
    lengths.append(len(word))

このコードと先ほどの内包表記を見比べると、以下のような対応関係があることがわかります。

for word in wordsという繰り返しの部分は、そのまま内包表記の後半に移動する
lengths.append(...)の中身、つまり格納する値の式が、内包表記の先頭に移動する
空リストを用意する処理とappendを呼び出す処理は、内包表記側では不要になる

このように、式を先頭に、繰り返し部分をそのあとに書くというルールさえ覚えてしまえば、forループのコードを内包表記に機械的に変換できるようになります。

よくある書き方のパターン

実務でよく登場するパターンをいくつか押さえておくと、内包表記への理解がさらに深まります。

# 既存のリストの値をそのまま加工する
prices_with_tax = [price * 1.1 for price in prices]

# 文字列のリストを大文字に変換する
upper_words = [word.upper() for word in words]

# 別の関数を適用した結果を集める
formatted = [str(n).zfill(3) for n in numbers]

これらの例に共通しているのは、いずれも「既存のデータを1件ずつ取り出し、何らかの加工を施して、新しいリストに集める」という単純な構造である点です。
内包表記が向いているのは、まさにこうした単純な変換処理です。
複雑な条件分岐や複数の処理を1行に詰め込みすぎると、かえって可読性を損なう場合もあるため、その見極め方については後の章で改めて解説します。

条件式を使った内包表記の実践テクニック(if文の書き方)

内包表記の真価は、単純な変換処理だけでなく、条件式と組み合わせたときに発揮されます。
Pythonの内包表記では、if文を2つの異なる位置に書くことができ、それぞれ役割がまったく異なります。
この違いを正確に理解しないまま使うと、意図しない結果を招くこともあるため、この章でしっかりと整理しておきましょう。

後置if(フィルタリング)の使い方

内包表記の末尾にif文を置く書き方は、条件を満たす要素だけを絞り込むフィルタリング処理に使われます。

scores = [55, 72, 88, 40, 95, 63]
passed = [score for score in scores if score >= 60]
# 結果: [72, 88, 95, 63]

この構文の特徴は、if文が「格納するかどうか」だけを判定している点にあります。
条件式が偽になった要素は、単純に結果のリストから除外されます。
式の部分には手が加えられていないため、値そのものは変化しません。

構文としては以下のように整理できます。

[式 for 変数 in イテラブル if 条件]

この位置のifは、forループにおける以下のコードと完全に対応しています。

passed = []
for score in scores:
    if score >= 60:
        passed.append(score)

三項演算子を使った条件分岐

一方、式の部分にif文を組み込む書き方は、条件によって格納する値そのものを変える場合に使います。
これはPythonの三項演算子(条件式)を利用した書き方です。

scores = [55, 72, 88, 40, 95, 63]
results = ["合格" if score >= 60 else "不合格" for score in scores]
# 結果: ['不合格', '合格', '合格', '不合格', '合格', '合格']

この場合、要素数は元のリストと変わりません。
すべての要素が結果のリストに含まれ、条件に応じて格納される値だけが切り替わります。

後置ifと三項演算子は見た目が似ているため混同しやすいですが、以下の観点で使い分けるとよいでしょう。

書き方	ifの位置	主な用途	結果の要素数
後置if	末尾	条件を満たす要素の絞り込み	元のリスト以下になる
三項演算子	式の中	条件によって値を変換する	元のリストと同じ

複数条件を組み合わせる方法

実務では、複数の条件を同時に満たす要素を抽出したい場面も多くあります。
その場合は、論理演算子のandやorを使って条件式を組み立てます。

numbers = range(1, 31)
targets = [n for n in numbers if n % 2 == 0 and n % 3 == 0]
# 結果: [6, 12, 18, 24, 30]

さらに、後置ifと三項演算子を同時に使うことも可能です。
以下は、偶数のみを対象にしつつ、値の大小によって表示形式を変えるコード例です。

labels = ["大" if n >= 20 else "小" for n in numbers if n % 2 == 0]

このように条件を重ねていくと表現力は高まりますが、同時に可読性が低下しやすくなる点には注意が必要です。
1行に詰め込む条件が2つを超えるようであれば、無理に内包表記に収めず、通常のforループへ書き戻すという判断も、コンピューターサイエンスの観点からは合理的な選択と言えます。

辞書内包表記・集合内包表記への応用方法

ここまではリストを対象とした内包表記を見てきましたが、内包表記の考え方はリストに限定されるものではありません。
Pythonでは、辞書型や集合型に対しても同じ発想で内包表記を書くことができます。
括弧の種類が変わるだけで、基本的な文法構造はリスト内包表記とほとんど同じです。
この章では、辞書内包表記と集合内包表記の書き方を確認したうえで、実務でよく使われる応用テクニックを紹介します。

辞書内包表記の基本構文

辞書内包表記は、角括弧の代わりに波括弧を使い、式の部分にキー: 値の形を書きます。

{キー: 値 for 変数 in イテラブル}

具体例として、単語のリストから、単語をキーに、その文字数を値とする辞書を作成してみます。

words = ["python", "java", "go"]
word_lengths = {word: len(word) for word in words}
# 結果: {'python': 6, 'java': 4, 'go': 2}

リスト内包表記との違いは、格納する式が「値1つ」ではなく「キーと値のペア」になっている点だけです。
それ以外のfor部分やif条件の書き方は、リスト内包表記とまったく同じルールが適用されます。

集合内包表記の基本構文

集合内包表記も同様に、波括弧を使いますが、こちらはキー: 値ではなく、リスト内包表記と同じ単一の式を書きます。

{式 for 変数 in イテラブル}

集合はデータの重複を許さないという性質を持つため、重複を自動的に除去したいときに有効です。

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_squares = {n ** 2 for n in numbers}
# 結果: {1, 4, 9, 16, 25}

角括弧[]を波括弧{}に変えるだけで、forループで重複除去用のコードを別途書く手間が省けます。
似た記法を整理すると、以下のようになります。

種類	括弧	式の形	主な用途
リスト内包表記	`[]`	式	順序を保持した値の集まりを作る
辞書内包表記	`{}`	キー: 値	対応関係のあるデータを作る
集合内包表記	`{}`	式	重複のない値の集まりを作る

キーと値を入れ替えるテクニック

辞書内包表記が特に役立つ場面の1つが、既存の辞書のキーと値を入れ替える処理です。
通常であればforループとタプルの操作が必要になりますが、辞書内包表記を使えば1行で完結します。

fruit_colors = {"apple": "red", "banana": "yellow", "grape": "purple"}
color_fruits = {value: key for key, value in fruit_colors.items()}
# 結果: {'red': 'apple', 'yellow': 'banana', 'purple': 'grape'}

ここではitems()メソッドを使ってキーと値を同時に取り出し、式の部分でvalue: keyという順序に入れ替えているだけです。
非常にシンプルな構造ですが、実務でのデータ変換処理では頻繁に登場するパターンです。

なお、この方法を使う際には、元の辞書の値に重複がないことを事前に確認しておく必要があります。
値が重複していると、キーへ変換する過程で情報が上書きされ、一部のデータが失われてしまう点には注意しましょう。

ネストした内包表記で多重forループを置き換えるテクニック

これまで扱ってきた内包表記は、いずれもforループが1階層のみのケースでした。
しかし実務では、二次元配列の展開や座標の組み合わせ生成など、多重のforループが必要になる場面も少なくありません。
内包表記は、こうしたネストしたループに対しても対応できます。
ただし、その分だけ可読性への配慮がより重要になります。
この章では、ネストした内包表記の書き方と、注意すべきポイントを解説します。

二重forループを1行で書く方法

まずは、通常のforループを使った二重ループの例を確認します。
二次元のリストを、要素がすべて並んだ1つのリストに展開する処理です。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flattened = []
for row in matrix:
    for value in row:
        flattened.append(value)

このコードを内包表記で書き直すと、以下のようになります。

flattened = [value for row in matrix for value in row]
# 結果: [1, 2, 3, 4, 5, 6, 7, 8, 9]

ポイントは、for節を外側のループから順番に、そのまま並べて記述するという点です。
for row in matrixが外側のループ、for value in rowが内側のループに対応しており、記述順序もforループのネスト順と一致します。
式の部分には、最も内側のループで得られる値であるvalueを書きます。

また、2つの独立したイテラブルからすべての組み合わせを作りたい場合にも、同じ書き方が応用できます。

colors = ["red", "blue"]
sizes = ["S", "M", "L"]

combinations = [(color, size) for color in colors for size in sizes]
# 結果: [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

このように、for節を横に並べていくだけで、多重ループと同等の処理を1行で表現できます。

ネストが深くなる際の可読性の注意点

ネストした内包表記は便利な一方で、書きすぎると本来のメリットであるはずの可読性を大きく損なうリスクがあります。
特に、以下のようなケースでは注意が必要です。

for節が3つ以上連なる場合
各for節にif条件が複数付随する場合
式の部分が複雑な関数呼び出しや条件分岐を含む場合

これらの条件に当てはまるコードは、1行の情報量が多くなりすぎて、後から読み返す際の負担が大きくなります。
以下のようなコードは、その典型例です。

result = [f(x, y) for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]

一見すると簡潔に見えますが、外側と内側のどちらのループにどの条件が対応しているのかを、視線を何度も往復させながら読み解く必要があります。
こうした場合は、無理に1行へ詰め込まず、forループへ書き戻すか、内包表記を複数行に分けて記述するほうが、チーム開発における保守性の観点からも望ましい選択です。

コードは書く瞬間よりも、読み返される時間のほうがはるかに長いという原則を踏まえると、ネストの深さは2階層程度にとどめておくのが実践的な目安と言えるでしょう。

内包表記とforループの処理速度を比較検証してみた

内包表記が推奨される理由として、可読性の高さだけでなく、処理速度の面でも有利になりやすいという点がよく挙げられます。
しかし、これを感覚だけで語ってしまうのは、コンピューターサイエンスを学んだ者としては避けたいところです。
この章では、実際にPython標準の計測モジュールを使い、両者の処理速度を定量的に比較してみます。

timeitモジュールを使った速度計測方法

Pythonには、コードの実行時間を正確に計測するためのtimeitモジュールが標準で用意されています。
単純にtimeモジュールで開始と終了の時刻差を取るよりも、timeitは同じ処理を複数回実行して平均を取るため、計測誤差の影響を受けにくいという特徴があります。

以下は、1万件の数値に対して2乗を計算する処理を、forループと内包表記のそれぞれで計測するコード例です。

import timeit

setup_code = "numbers = range(10000)"

for_loop_code = """
squares = []
for n in numbers:
    squares.append(n ** 2)
"""

comprehension_code = "squares = [n ** 2 for n in numbers]"

for_time = timeit.timeit(for_loop_code, setup=setup_code, number=1000)
comp_time = timeit.timeit(comprehension_code, setup=setup_code, number=1000)

print(f"forループ: {for_time:.4f}秒")
print(f"内包表記: {comp_time:.4f}秒")

timeit.timeitのnumber引数には、処理を繰り返す回数を指定します。
回数を増やすほど計測結果は安定しますが、その分だけ実行時間もかかるため、対象の処理内容に応じて適切な値を設定する必要があります。

検証結果からわかること

このコードを手元の環境で実行すると、多くの場合、内包表記のほうがforループよりも短い時間で処理を終える傾向が確認できます。
傾向として整理すると、以下のようになります。

処理方式	特徴	傾向
forループ	ループごとにappendメソッドを呼び出す	関数呼び出しのオーバーヘッドが発生しやすい
内包表記	専用のバイトコード命令で処理される	ループ本体の処理がより高速に実行されやすい

この差が生まれる主な理由は、CPythonの内部実装にあります。
forループでは、繰り返しのたびにsquares.appendというメソッド呼び出しが発生します。
メソッド呼び出しには、属性の検索や関数フレームの生成といった一定のコストが伴います。

一方、内包表記はコンパイル時に専用のバイトコードへ変換され、リストへの要素追加もインタプリタレベルでより効率的に処理されます。
そのため、繰り返し回数が多くなるほど、両者の処理時間の差は顕著になっていく傾向があります。

ただし、この差は処理内容やデータ量、実行環境によって変動します。
処理速度は内包表記を選ぶ絶対的な根拠にはなりますが、それ以上に、コードの意図が読み取りやすくなるという可読性の向上こそが、内包表記を使う最大の価値であるという点は忘れないようにしたいところです。

可読性を損なわない内包表記の使い分けとアンチパターン

内包表記は強力な武器ですが、あらゆる場面で万能というわけではありません。
ここまで解説してきた基本構文や応用テクニックを踏まえたうえで、あえて内包表記を使わないほうがよいケースについても整理しておく必要があります。
優れたエンジニアは、便利な構文を知っているだけでなく、使わない判断ができるかどうかで差がつくものです。
この章では、内包表記を避けるべき場面と、似た構文であるジェネレータ式との使い分けについて解説します。

内包表記を使うべきでないケース

内包表記が不向きになる典型的なパターンを、以下に整理しました。

処理が複数のステップに分かれ、途中結果を変数に保持したい場合
例外処理を伴う場合
副作用(ファイル書き込みやログ出力など)を目的とした繰り返し処理の場合
1つの式に条件分岐やネストが2つ以上重なる場合

たとえば、以下のように例外処理が絡む場合、内包表記に無理やり詰め込むと可読性が大きく損なわれます。

# 内包表記に詰め込みにくい例
values = ["10", "20", "abc", "30"]
numbers = []
for value in values:
    try:
        numbers.append(int(value))
    except ValueError:
        continue

このような処理を内包表記だけで表現しようとすると、tryとexceptを関数として切り出す必要が生じ、かえってコードの見通しが悪くなります。
この場合は、素直にforループを使うほうが、コンピューターサイエンスの観点からも合理的です。
内包表記はあくまで「単純な変換とフィルタリング」に適した構文であり、複雑な制御フローを表現するための構文ではないという原則を押さえておくとよいでしょう。

ジェネレータ式との使い分け

内包表記とよく似た構文に、ジェネレータ式があります。
角括弧を丸括弧に変えるだけで書けるため、内包表記の延長として覚えている方も多いはずです。

gen = (n ** 2 for n in range(1000000))

両者の最大の違いは、メモリの使い方にあります。
リスト内包表記は、すべての要素を計算した状態でメモリ上に保持します。
一方、ジェネレータ式は要素を1つずつ必要なタイミングで生成する仕組みのため、大量のデータを扱う場合でもメモリ使用量を抑えられます。

観点	リスト内包表記	ジェネレータ式
括弧	`[]`	`()`
メモリ使用量	全要素を保持するため大きくなりやすい	要素を逐次生成するため小さく済む
再利用	何度でも参照可能	一度しか走査できない
適した用途	要素数が少ない、複数回参照する処理	大量データの一度限りの走査処理

たとえば、数百万件規模のデータに対して合計値を求めるだけであれば、すべての要素をリストとして保持する必要はありません。

total = sum(n ** 2 for n in range(1000000))

このように、結果を一度しか使わない集計処理では、ジェネレータ式を選ぶことでメモリ効率を大きく改善できます。
内包表記とジェネレータ式は見た目こそ似ていますが、データをすべて保持する必要があるかどうかという観点で使い分けることが、実践的な指針になります。

内包表記をマスターするための練習問題とおすすめの学習法

ここまで、内包表記の基本構文から応用テクニック、そして使うべきでないケースまで一通り解説してきました。
知識として理解することと、実際に手を動かして書けるようになることの間には、一定の距離があります。
この章では、理解を定着させるための練習問題と、さらに学習を深めたい方に向けた参考資料を紹介します。

初心者向け練習問題

以下に、これまで解説した内容を組み合わせた練習問題をいくつか用意しました。
まずはforループで書いてから、内包表記に変換するという手順を踏むと、記述順序の違いを体に染み込ませやすくなります。

1から20までの数値のうち、3の倍数だけを集めたリストを作成してください
文字列のリストから、文字数が5文字以上の単語だけを大文字に変換したリストを作成してください
1から100までの数値について、偶数には「偶数」、奇数には「奇数」というラベルを付けたリストを作成してください
2つの辞書がある場合に、片方の辞書のキーをもう片方の辞書の値に置き換えた新しい辞書を作成してください
二次元リストの中から、合計値が10を超える行だけを抽出したリストを作成してください

これらの問題は、単純な変換、フィルタリング、条件分岐、辞書内包表記、ネストした内包表記という、この記事で扱ったすべての要素を含んでいます。
解答例を見る前に、まずは自分の手でforループと内包表記の両方を書き比べてみることをおすすめします。
同じ結果が得られるかどうかを確認する過程そのものが、構文の理解を深める最も効果的な方法です。

参考になる公式ドキュメント

内包表記についてさらに深く学びたい場合は、書籍やブログ記事だけでなく、Python公式ドキュメントにあたることを強くおすすめします。
公式ドキュメントには、以下のような情報が体系的にまとめられています。

参照先	主な内容
公式チュートリアルのデータ構造の章	リスト内包表記の基本的な考え方と例
内包表記に関する文法リファレンス	内包表記の正式な文法定義
PEPドキュメント	内包表記が導入された経緯や設計思想

特に公式チュートリアルは、初学者が段階的に理解を積み上げられるよう構成されており、この記事で解説した内容の多くと重なります。
日本語版も提供されているため、英語に不安がある方でも安心して読み進められます。

公式ドキュメントを直接読む習慣を身につけておくと、内包表記に限らず、今後新しい構文やライブラリを学ぶ際にも、正確な一次情報にあたる力が身につきます。
ブログ記事やSNSでの断片的な情報だけに頼らず、公式情報を確認する姿勢を大切にしていただければと思います。

まとめ:内包表記を使いこなしてPythonコードの質を高めよう

ここまで、forループと内包表記の違いから始まり、基本構文、条件式を使った実践テクニック、辞書内包表記や集合内包表記への応用、ネストした書き方、処理速度の比較検証、そして使うべきでないケースまで、幅広く解説してきました。
最後に、この記事全体で押さえておいていただきたい要点を改めて整理します。

内包表記を理解するうえで最も重要なのは、構文の丸暗記ではなく、forループとの対応関係を論理的に把握することです。
内包表記は、格納する値の形を先頭に書き、そのあとに繰り返しの対象と条件を続けるという、時系列とは逆順の記述構造を持っています。
この構造さえ理解してしまえば、複雑に見える内包表記も、既存のforループを機械的に変換したものにすぎないとわかるはずです。

この記事で扱った内容を、改めて表に整理します。

テーマ	押さえるべきポイント
基本構文	式・変数・イテラブルの3要素で構成される
条件式	後置ifはフィルタリング、式中のifは値の変換に使う
辞書・集合内包表記	括弧の種類が変わるだけで基本ルールは共通する
ネスト構造	forループの順序をそのまま横に並べて記述する
処理速度	メソッド呼び出しが減る分、内包表記のほうが高速になりやすい
使い分けの判断	複雑な処理は無理に詰め込まず、forループへ戻す判断も重要

内包表記を使う最大のメリットは、処理速度の向上以上に、コードの意図が一目で伝わるようになるという点にあります。
forループで4行かけて書いていた処理が、1行で「何を」「どこから」「どんな条件で」集めているのかを表現できるようになれば、コードレビューの効率も、後から読み返す自分自身の負担も、大きく軽減されます。

一方で、内包表記は万能な構文ではないという点も、繰り返しお伝えしておきたいところです。
例外処理を伴う場合や、副作用を目的とした繰り返し処理、条件分岐が複雑に絡み合う場合には、無理に1行へ詰め込むべきではありません。
優れたコードとは、短く書けることを競うものではなく、書き手の意図が最短経路で読み手に伝わることを目指すものです。
この判断軸を持てるようになることこそが、単なる構文の暗記を超えた、実践的なスキルと言えるでしょう。

学習の進め方としては、まず日頃書いているforループのコードを見返し、内包表記に置き換えられそうな箇所を探してみることをおすすめします。
以下のような手順で進めると、無理なく習慣化できます。