「辞書(dict)に値をまとめて追加したいのに、for文を書くとどうしても行数が増えてしまう」「他の人のコードで {key: value for ...} のような書き方を見かけたけど、意味がよく分からない」——そんな経験はありませんか。

この書き方は「辞書内包表記（dict comprehension）」と呼ばれるPythonの機能です。慣れないうちは読みにくく感じるかもしれませんが、使いこなせるようになると、for文を何行も書いていた処理をたった1行で表現できるようになります。この記事では、辞書内包表記の基本的な書き方から、条件分岐を使った応用、実践的な活用例までを初心者向けに丁寧に解説します。

辞書内包表記とは？

辞書内包表記とは、for文とif文を1行にまとめて書くことで、新しい辞書（dict）を簡潔に作成できるPythonの構文です。リストを作る「リスト内包表記」の辞書版だとイメージすると分かりやすいでしょう。リスト内包表記について詳しく知りたい方は、以下の記事もあわせてご覧ください。

【Python】リスト内包表記の使い方を徹底解説！for文との違いや書き方を初心者向けに紹介！

辞書そのものの基本的な使い方に不安がある方は、先に以下の記事で作り方やループ処理をおさらいしておくとスムーズです。

【Python】辞書(dict)の使い方を初心者向けに徹底解説！作り方からループ処理まで完全網羅！

基本的な書き方

基本構文

辞書内包表記の基本構文は次のとおりです。

{key: value for 変数 in イテラブル}

実際に、数値のリストから「数値をキー、その2乗を値」とする辞書を作ってみましょう。

numbers = [1, 2, 3, 4, 5]
squares = {n: n ** 2 for n in numbers}
print(squares)
# 実行結果: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

for文で書いた場合との比較

同じ処理をfor文で書くと、次のようになります。

numbers = [1, 2, 3, 4, 5]
squares = {}
for n in numbers:
    squares[n] = n ** 2
print(squares)
# 実行結果: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

4行かかっていた処理が、辞書内包表記を使うとたった1行にまとまります。for文の書き方に自信がない方は、以下の記事も参考にしてください。

Pythonのfor文・range関数を攻略！これを知れば基本的な処理ができる使い方9選！

条件分岐（if）を使う書き方

辞書内包表記では、末尾に if 条件を付け加えることで、特定の条件を満たす要素だけを辞書に含めることができます。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares = {n: n ** 2 for n in numbers if n % 2 == 0}
print(even_squares)
# 実行結果: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

「偶数だけを対象にしたい」といったフィルタリング処理も、条件式を1つ足すだけで実現できるのが辞書内包表記の便利なところです。

実践的な活用例

2つのリストを辞書にまとめる

名前のリストと点数のリストのように、対応関係にある2つのリストを1つの辞書にまとめたい場面はよくあります。そのようなときは zip() 関数と組み合わせると簡単です。

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
score_dict = {name: score for name, score in zip(names, scores)}
print(score_dict)
# 実行結果: {'Alice': 85, 'Bob': 92, 'Charlie': 78}

このように、ちょっとしたデータ整形を自分の書いたコードでサクサクこなせるようになると、Python学習がぐっと楽しくなってきます。ただ、独学だとどうしても「この書き方で本当に合っているのか」「もっと効率よく学べる方法はないのか」と一人で悩んで伸び悩んでしまうことも少なくありません。そんなときは、プロに直接教えてもらえるプログラミングスクールを検討してみるのも一つの手です。以下の記事でスクールの選び方やおすすめをまとめていますので、独学に限界を感じたら参考にしてください。

【全スクール無料体験あり！】プログラミングを学びたい人におすすめのスクール5選！

既存の辞書の値を加工する

すでにある辞書の値だけを一括で加工したい場合は、.items() を使って辞書内包表記を組み立てます。たとえば、商品の価格一覧に消費税を加算するケースを見てみましょう。

prices = {"apple": 100, "banana": 150, "orange": 120}
tax_included = {item: int(price * 1.1) for item, price in prices.items()}
print(tax_included)
# 実行結果: {'apple': 110, 'banana': 165, 'orange': 132}

このように、既存のデータを一括変換するようなケースでも辞書内包表記は非常に役立ちます。集計処理をよく行う方は、以下の記事で紹介している collections モジュールもあわせて活用すると、さらに効率的にデータを扱えるようになります。

【Python】collectionsモジュールの使い方を初心者向けに徹底解説！Counter・defaultdictで集計を簡単に

辞書内包表記を使うときの注意点

便利な辞書内包表記ですが、使う際にはいくつか注意しておきたいポイントがあります。

• 同じキーが複数回出てくる場合、後から処理された値で上書きされてしまう（キーの重複に注意）
• 条件分岐やネストが増えて1行が長くなりすぎると、かえって読みにくくなる
• 複雑な処理になりそうなときは、無理に1行にまとめず、通常のfor文に戻したほうが可読性が高くなる場合もある

「短く書けるかどうか」よりも「後で読んだときに分かりやすいかどうか」を基準に、辞書内包表記とfor文を使い分けていくとよいでしょう。

※本記事には広告（アフィリエイトリンク）を含みます。

もっと効率的にPythonを学びたい人へ

辞書内包表記のような「書き方のコツ」は、独学で書籍やネット記事だけを読んでいると、なかなか身につくまでに時間がかかるものです。もし「我流の書き方で本当に合っているのか不安」「効率よく実践的なコードの書き方を身につけたい」と感じているなら、マンツーマンで指導してもらえるスクールを利用するのも近道です。未経験からのPython習得や転職サポートも含めて、無料カウンセリングで相談できるサービスもあります。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回は、Pythonの辞書内包表記について解説しました。最後に要点を振り返っておきましょう。

• 辞書内包表記は {key: value for 変数 in イテラブル} の形で、for文を使わずに1行で辞書を作成できる構文
• 末尾に if 条件を加えることで、特定の条件を満たす要素だけを抽出できる
• zip() と組み合わせれば2つのリストを1つの辞書にまとめられる
• .items() を使えば既存の辞書の値だけを一括で加工できる
• 読みにくくなるほど複雑な場合は、無理に1行にまとめずfor文に戻すのも選択肢

辞書内包表記を使いこなせるようになると、データの整形や集計処理をぐっとスマートに書けるようになります。ぜひ日々のコーディングで積極的に使ってみてください。

「Python3エンジニア認定基礎試験を受けようと思っているけど、参考書が多すぎてどれを選べばいいか分からない」「せっかく買った本が試験範囲と合っていなかったらどうしよう」——そんな不安を抱えている方は多いのではないでしょうか。筆者は都内で現役SEとして働きながら、独学でPython資格の勉強を進めてきました。この記事では、これから資格取得を目指す方に向けて、参考書・問題集を選ぶときの比較軸と、タイプ別のおすすめ教材を整理してご紹介します。

参考書選びで失敗しないための3つの比較軸

Python3エンジニア認定基礎試験は、公式サイトで「出題範囲」が公開されている試験です。参考書を選ぶときは、なんとなく人気だからという理由ではなく、以下の3つの軸で比較することをおすすめします。

① 出題範囲との一致度

この試験の出題範囲は、書籍『Pythonチュートリアル』（オライリージャパン）の目次にほぼ準拠しています。そのため「試験範囲を漏れなくカバーしているか」は最優先でチェックしたいポイントです。試験対策と謳っていても、実際には範囲外の内容（データ分析やWeb開発など）に紙面を割いている本も少なくないので注意しましょう。

② 独学のしやすさ（解説の分かりやすさ）

プログラミング未経験から挑戦する方と、業務でPythonに触れたことがある方とでは、必要な解説の粒度が変わります。図解が多いか、専門用語に説明が添えられているかは、購入前に目次や試し読みで確認しておくと失敗が減ります。

③ 問題演習量

資格試験は知識のインプットだけでなく、選択式問題への慣れも合否を左右します。模擬問題の収録数や、Web上で受けられる模擬試験の有無も比較しておきたいポイントです。

おすすめ参考書・教材の比較

比較軸を踏まえて、代表的な教材の特徴を整理しました。

• Pythonチュートリアル（オライリージャパン）：試験の出題範囲そのものになっている公式的な位置づけの書籍。網羅性は最も高いが、初心者にはやや硬い文章で、独学の1冊目には不向きな場合もある。
• スッキリわかるPython入門（インプレス）：キャラクターとの対話形式で進む入門書。図解が多く、プログラミング未経験者が最初の1冊として読み進めやすい。試験範囲そのものではないため、基礎固め用として使うのがおすすめ。
• Python 1年生（翔泳社）：会話形式でとにかく易しく書かれた入門書。挫折しやすい人がまず「楽しく続ける」ための1冊として向いている。
• 徹底攻略Python3エンジニア認定基礎試験問題集（インプレス）：試験主催団体の監修が入った公式問題集。出題範囲との一致度が高く、模擬問題も豊富なため、仕上げの1冊として定番。
• Web上の無料模擬試験サイト（PRIME STUDY・DIVE INTO EXAMなど）：書籍ではないが、隙間時間にスマホで問題演習ができる。書籍と組み合わせて使うと定着度が上がる。

基礎固めのために読んでいたPythonの標準ライブラリの知識があいまいな方は、先に collectionsモジュールの解説記事 や JSONの扱い方の解説記事 で復習しておくと、参考書の内容がスムーズに頭に入ってきます。特に例外処理は出題範囲の中でもつまずきやすい分野なので、例外処理（try-except）の解説記事もあわせて読んでおくことをおすすめします。

タイプ別おすすめの選び方

プログラミング未経験からいきなり挑戦する人

まずは『スッキリわかるPython入門』や『Python 1年生』など、図解や会話形式で書かれた入門書で全体像をつかむのがおすすめです。いきなり『Pythonチュートリアル』から入ると、専門用語の多さに挫折しやすい傾向があります。

とはいえ、独学だとどうしても分からない箇所でつまずいて時間を溶かしてしまうこともあります。「一人で進める自信がない」「最短ルートで基礎を身につけたい」という方は、マンツーマンで学べるスクールを比較検討してみるのも一つの手です。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

一冊で効率よく合格ラインまで持っていきたい人

ある程度Pythonの文法を触ったことがある方は、公式監修の『徹底攻略Python3エンジニア認定基礎試験問題集』から始めても問題ありません。出題範囲との一致度が高く、演習量も十分なため、最短距離で合格ラインの実力をつけやすい教材です。

問題演習を最優先したい人

書籍の問題集に加えて、PRIME STUDYなどの無料模擬試験サイトを併用しましょう。通勤時間やちょっとした隙間時間にスマホで解けるので、直前期の総仕上げに向いています。

よくある質問

Q. 参考書は1冊だけで合格できますか？

A. プログラミング経験がある方であれば、公式監修の問題集1冊でも合格を狙えます。ただし未経験の方は、入門書で基礎を固めてから問題集に進むほうが、結果的に近道になることが多いです。

Q. どのくらいの勉強期間を見ておけばいいですか？

A. Pythonの学習経験によって大きく異なります。目安となる勉強時間については、別記事「Pythonエンジニア認定基礎試験に合格するために必要な勉強時間は？」で詳しく解説しているので、あわせて参考にしてください。

Q. 中古や古い版の参考書でも大丈夫ですか？

A. Pythonのバージョンによって仕様が変わっている場合があるため、できるだけ新しい版を選ぶことをおすすめします。特にライブラリの仕様変更には注意しましょう。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

• 参考書は「出題範囲との一致度」「独学のしやすさ」「問題演習量」の3軸で比較する
• 未経験者はまず図解の多い入門書で全体像をつかむのがおすすめ
• ある程度経験があるなら公式監修の問題集から始めても良い
• Web上の無料模擬試験サイトを併用すると問題演習量を補える
• 独学に不安があるならスクールでの学習も選択肢に入れてみる

自分に合った教材を選んで、Python3エンジニア認定基礎試験の合格を目指しましょう。

「リストの中に同じ値が何回出てくるか数えたい」「辞書でカウントしようとしたら KeyError が出てしまった」――Pythonを学び始めると、こんな場面に一度は出会いますよね。私も現場でログやCSVを集計するとき、最初は if 文だらけの長いコードを書いていました。

実はこうした「数える」「グループ分けする」処理は、Python標準ライブラリの collectionsモジュール を使うと驚くほどシンプルに書けます。この記事では、特に使用頻度の高い Counter と defaultdict の使い方を、初心者の方にも分かるように実行結果つきで解説します。

collectionsモジュールとは？

collectionsは、Pythonに最初から入っている標準ライブラリで、リストや辞書をさらに便利にした「特殊なデータ型」がまとめられています。インストールは不要で、import するだけで使えます。

• Counter：要素の出現回数を数える辞書
• defaultdict：存在しないキーにも初期値を自動で用意してくれる辞書
• その他：deque（両端キュー）、namedtuple（名前付きタプル）、OrderedDict など

どちらも辞書の仲間なので、辞書の基本を押さえておくと理解がスムーズです。不安な方は先に 辞書(dict)の使い方を解説した記事 を読んでおくのがおすすめです。

Counterの基本的な使い方

辞書で数える場合との比較

まずはCounterを使わずに、普通の辞書で果物の個数を数えてみます。

fruits = ["apple", "banana", "apple", "orange", "banana", "apple"]

counts = {}
for f in fruits:
    if f in counts:
        counts[f] += 1
    else:
        counts[f] = 1

print(counts)
# 実行結果: {'apple': 3, 'banana': 2, 'orange': 1}

キーがあるかどうかで分岐が必要なので、少し長くなってしまいます。これをCounterで書くと、たった1行です。

Counterで出現回数を数える

from collections import Counter

fruits = ["apple", "banana", "apple", "orange", "banana", "apple"]
c = Counter(fruits)

print(c)
# 実行結果: Counter({'apple': 3, 'banana': 2, 'orange': 1})

print(c["apple"])
# 実行結果: 3

print(c["grape"])  # 存在しないキー
# 実行結果: 0

ポイントは、存在しないキーを指定しても KeyError にならず 0 が返る ことです。通常の辞書ではエラーになるので、この違いは覚えておきましょう。なお、1つの値だけを数えたいならリストの count() でも十分です。count() については count関数の使い方を解説した記事 で詳しく紹介しています。

ちなみに、こうした「標準ライブラリで楽に書く」発想は、独学だとなかなか気づけないポイントでもあります。独学で伸び悩んでいると感じたら、現役SEの視点でまとめた プログラミングを学びたい人におすすめのスクール5選 も参考にしてみてください。無料体験で「質問できる環境」を試してみるだけでも、学習効率が大きく変わりますよ。

most_common()でランキングを作る

Counterの一番便利なメソッドが most_common() です。出現回数の多い順に (要素, 回数) のタプルのリストを返してくれます。

print(c.most_common(2))
# 実行結果: [('apple', 3), ('banana', 2)]

引数を省略すると、すべての要素を多い順に返します。自分で並び替える方法が気になる方は sortとsortedの違いを解説した記事 もあわせてどうぞ。

文字列や単語を数える

Counterにはリストだけでなく、文字列も渡せます。文字列を渡すと1文字ずつ数えてくれます。

from collections import Counter

# 文字ごとに数える
print(Counter("hello world").most_common(3))
# 実行結果: [('l', 3), ('o', 2), ('h', 1)]

# 単語ごとに数える（split()でリストにしてから渡す）
sentence = "python is fun and python is easy"
print(Counter(sentence.split()).most_common(2))
# 実行結果: [('python', 2), ('is', 2)]

update()と足し算・引き算

Counter同士は足し算・引き算ができ、update()で後から要素を追加することもできます。引き算で0以下になった要素は自動的に消えます。

from collections import Counter

c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)

print(c1 + c2)
# 実行結果: Counter({'a': 4, 'b': 3})

print(c1 - c2)
# 実行結果: Counter({'a': 2})

c1.update(["b", "c"])
print(c1)
# 実行結果: Counter({'a': 3, 'b': 2, 'c': 1})

合計数を知りたいときは sum(c.values()) と書けばOKです。

defaultdictの基本的な使い方

通常の辞書で起きるKeyError

通常の辞書では、存在しないキーに対していきなり += 1 をするとエラーになります。

d = {}
d["x"] += 1
# 実行結果: KeyError: 'x'

defaultdict(int)で自動的に0から始める

defaultdictは、作成時に「初期値を作る関数」を渡しておくと、存在しないキーにアクセスしたときに自動でその初期値を用意してくれます。int を渡すと初期値は 0 になります。

from collections import defaultdict

dd = defaultdict(int)
dd["x"] += 1

print(dd)
# 実行結果: defaultdict(<class 'int'>, {'x': 1})

print(dict(dd))  # 普通の辞書に変換
# 実行結果: {'x': 1}

defaultdict(list)でグループ分けする

実務で特に便利なのが list を渡すパターンです。「クラスごとに生徒をまとめる」といったグループ分けが簡単に書けます。

from collections import defaultdict

students = [("A組", "田中"), ("B組", "佐藤"), ("A組", "鈴木"),
            ("B組", "高橋"), ("C組", "伊藤")]

groups = defaultdict(list)
for cls, name in students:
    groups[cls].append(name)

print(dict(groups))
# 実行結果: {'A組': ['田中', '鈴木'], 'B組': ['佐藤', '高橋'], 'C組': ['伊藤']}

通常の辞書なら「キーがなければ空のリストを作る」という分岐が必要ですが、defaultdictならその処理が不要になります。

注意点：参照しただけでキーが作られる

defaultdictは「存在しないキーを参照しただけ」でもキーが追加されてしまいます。存在チェックをしたいときは in を使いましょう。

from collections import defaultdict

d2 = defaultdict(int)
print(d2["y"])
# 実行結果: 0

print(len(d2))  # 参照しただけで "y" が追加されている
# 実行結果: 1

print("z" in d2, len(d2))  # in ならキーは増えない
# 実行結果: False 1

実践例：ログのレベル別件数を集計する

最後に、私が現場でもよく使う「ログの集計」をCounterで書いてみます。f文字列と組み合わせると、見やすいレポートがすぐに作れます。

from collections import Counter

logs = ["ERROR", "INFO", "WARN", "INFO", "ERROR", "INFO"]

for level, n in Counter(logs).most_common():
    print(f"{level}: {n}件")

# 実行結果:
# INFO: 3件
# ERROR: 2件
# WARN: 1件

リストを作る段階で条件を絞りたい場合は、リスト内包表記 と組み合わせると、さらにスッキリ書けます。

Counterとdefaultdictの使い分け

• 出現回数を数えたい・ランキングを出したい → Counter
• キーごとにリストや合計をまとめたい → defaultdict(list) / defaultdict(int)
• 1つの値の個数だけ知りたい → リストの count() で十分

もっと効率的にPythonを学びたい人へ

collectionsのような便利な標準ライブラリは、知っているかどうかでコードの量も品質も大きく変わります。ただ、独学だと「そもそもこういう書き方がある」と気づくのが難しいのも事実です。

「未経験からPythonを確実に身につけたい」「分からないところをすぐ質問したい」という方は、マンツーマン指導のスクールを検討してみるのも一つの手です。講師に直接質問できるので、つまずいた箇所をその場で解消でき、転職を見据えたサポートも受けられます。まずは無料カウンセリングで、自分に合うか確かめてみてください。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

スクール選びで迷っている方は、おすすめのプログラミングスクール比較記事 で選び方のポイントもチェックしてみてください。

まとめ

• collectionsはインストール不要の標準ライブラリで、from collections import Counter, defaultdict で使える
• Counterは要素の出現回数を1行で数えられ、存在しないキーは 0 を返す
• most_common(n) で出現回数ランキングを簡単に作れる
• Counter同士は足し算・引き算、update()での追加ができる
• defaultdict(int) でカウント、defaultdict(list) でグループ分けが KeyError なしで書ける
• defaultdictは参照しただけでキーが追加されるので、存在チェックは in を使う

「数える」「まとめる」処理はデータ分析でも業務システムでも頻繁に登場します。ぜひ手を動かして、Counterとdefaultdictを使いこなしてみてください！

「サイコロのようにランダムな数字を出したい」「リストの中からランダムに1つ選びたい」――Pythonでちょっとしたゲームやツールを作ろうとすると、こんな場面に必ず出会いますよね。

そんなときに使うのが、Python標準ライブラリのrandomモジュールです。インストール不要で、importするだけですぐに乱数を扱えます。

この記事では、現役SEの筆者が random()・randint()・choice()・sample()・shuffle() などのよく使う関数を、実行例つきで初心者向けにやさしく解説します。最後にはミニゲームも作ってみましょう。

randomモジュールとは？

randomモジュールは、疑似乱数（コンピュータが計算で作る「ランダムっぽい」数）を生成するための標準モジュールです。使う前に、ファイルの先頭で次のようにimportします。

import random

なお、この記事のコード例の実行結果は一例です。乱数なので、実行するたびに結果が変わります。

ランダムな数値を作る関数

random()：0以上1未満の小数

random.random() は、0.0以上1.0未満の小数（float）をランダムに返します。

import random

print(random.random())
# 実行結果（例）：0.6394267984578837

randint(a, b)：a以上b以下の整数

いちばんよく使うのが randint() です。a以上b以下の整数を返します。b自身も含まれる点がポイントです。サイコロなら次のように書けます。

import random

dice = random.randint(1, 6)
print(dice)
# 実行結果（例）：4

randrange(start, stop, step)：rangeと同じ感覚で選ぶ

randrange() は range() と同じ指定方法で、その範囲から1つ選びます。こちらはstopを含まないので注意しましょう。rangeの考え方はfor文・range関数の使い方の記事で詳しく解説しています。

import random

# 0, 2, 4, 6, 8 の中から1つ（偶数だけ）
print(random.randrange(0, 10, 2))
# 実行結果（例）：6

uniform(a, b)：範囲を指定した小数

import random

print(random.uniform(1.0, 5.0))
# 実行結果（例）：3.9662019990393316

小数点以下が長すぎる場合は、round(値, 2) で丸めるか、f文字列（f-string）で f"{値:.2f}" のように表示桁数を指定すると見やすくなります。

リストからランダムに選ぶ・並び替える関数

choice()：1つだけ選ぶ

import random

fruits = ["りんご", "バナナ", "みかん", "ぶどう"]
print(random.choice(fruits))
# 実行結果（例）：バナナ

sample()：重複なしで複数選ぶ

sample(リスト, k) は、重複なしでk個を選んで新しいリストを返します。抽選やくじ引きに便利です。

import random

fruits = ["りんご", "バナナ", "みかん", "ぶどう"]
print(random.sample(fruits, 2))
# 実行結果（例）：['バナナ', 'みかん']

choices()：重複ありで複数選ぶ・重み付けもできる

choices() は同じ要素が何度選ばれてもよい選び方です。weights で「当たりやすさ」を指定できるので、ガチャのような確率付きの抽選も簡単に作れます。

import random

fruits = ["りんご", "バナナ", "みかん", "ぶどう"]
print(random.choices(fruits, k=3))
# 実行結果（例）：['りんご', 'みかん', 'みかん']

# 当たり1：はずれ9 の確率で5回引く
print(random.choices(["当たり", "はずれ"], weights=[1, 9], k=5))
# 実行結果（例）：['はずれ', 'はずれ', '当たり', 'はずれ', 'はずれ']

shuffle()：リストそのものを並び替える

shuffle() はリストの順番をランダムに入れ替えます。注意点は、元のリスト自体を書き換え、戻り値はNoneになることです。sort() と sorted() の関係に似ていますね（sortとsortedの違いはこちら）。

import random

nums = [1, 2, 3, 4, 5]
random.shuffle(nums)
print(nums)
# 実行結果（例）：[2, 3, 1, 4, 5]

# よくある間違い
result = random.shuffle(nums)
print(result)
# 実行結果：None

# 元のリストを残したいなら sample で全件を選ぶ
original = [1, 2, 3, 4, 5]
shuffled = random.sample(original, len(original))
print(original)  # [1, 2, 3, 4, 5]
print(shuffled)  # 実行結果（例）：[4, 1, 5, 3, 2]

ここまでで、randomモジュールの主要な関数はひと通り使えるようになりました。「こうした基礎を独学で進めるのが不安」「質問できる環境がほしい」と感じたら、プログラミングスクールのおすすめ比較記事も参考にしてみてください。無料体験で自分に合う学び方を探すのもひとつの手です。

seed()で乱数を再現する

テストやデバッグのときに「毎回同じ乱数が出てほしい」ことがあります。そんなときは random.seed() でシード値を固定します。同じシードなら、同じ順番で同じ乱数が出ます。

import random

random.seed(42)
a = [random.randint(1, 100) for _ in range(3)]

random.seed(42)
b = [random.randint(1, 100) for _ in range(3)]

print(a)  # [82, 15, 4]
print(b)  # [82, 15, 4]  ← 同じ結果になる

上のコードで使っている [... for _ in range(3)] の書き方はリスト内包表記です。

実践：じゃんけんゲームを作ってみよう

choice() を使えば、コンピュータの手をランダムに決めるじゃんけんゲームが数行で作れます。

import random

hands = ["グー", "チョキ", "パー"]
win = {"グー": "チョキ", "チョキ": "パー", "パー": "グー"}

player = input("グー・チョキ・パーのどれを出す？：")
computer = random.choice(hands)
print(f"コンピュータ：{computer}")

if player not in hands:
    print("入力が正しくありません")
elif player == computer:
    print("あいこです")
elif win[player] == computer:
    print("あなたの勝ち！")
else:
    print("あなたの負け…")

# 実行結果（例）
# グー・チョキ・パーのどれを出す？：グー
# コンピュータ：チョキ
# あなたの勝ち！

「どの手がどの手に勝つか」を辞書で持たせることで、if文の分岐をすっきり書けています。

注意：パスワードなどのセキュリティ用途には使わない

randomモジュールの乱数は予測可能な疑似乱数なので、パスワードや認証トークンの生成には向きません。セキュリティ用途では標準ライブラリの secrets モジュールを使いましょう。使い方はsecretsモジュールでパスワードを作成する記事で紹介しています。

もっと効率的にPythonを学びたい人へ

randomモジュールのように、Pythonは「知っていればすぐ書ける」便利な機能がたくさんあります。ただ、独学だと「何から学べばいいか分からない」「エラーで何時間も止まってしまう」ということも多いですよね。

未経験からPythonを確実に身につけたい方には、講師に直接質問できるマンツーマン指導のスクールがおすすめです。自分のペースで基礎から実践まで学べ、転職を見据えたサポートを受けられるところもあります。まずは無料カウンセリングで、学習の進め方を相談してみてはいかがでしょうか。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回はPythonのrandomモジュールの使い方を解説しました。ポイントを振り返りましょう。

• import random だけで使える標準モジュール
• random() は0以上1未満の小数、randint(a, b) はb自身も含む整数
• randrange() はrangeと同じくstopを含まない
• choice() で1つ、sample() で重複なし、choices() で重複あり・重み付きで選べる
• shuffle() は元のリストを書き換え、戻り値はNone
• seed() で乱数を再現できる
• パスワードなどセキュリティ用途には secrets モジュールを使う

乱数を使えると、ゲームやシミュレーションなど作れるものの幅がぐっと広がります。ぜひ手を動かして試してみてください！

プログラムを書いていると、「実行した瞬間にエラーが出て止まってしまった」という経験は誰にでもあります。特にユーザーの入力やファイルの読み込みを扱うプログラムでは、想定外の値が来るだけで処理が止まってしまいます。そんなときに役立つのが 例外処理（try-except） です。

この記事では、Pythonの例外処理について、基本の try-except 構文から、else・finally、複数例外の処理、raise による例外の発生まで、初心者の方にも分かりやすく解説します。実際に動くコードと実行結果を見ながら、エラーに強いプログラムの書き方を身につけていきましょう。

例外処理とは？エラーでプログラムが止まる問題

Pythonでは、プログラムの実行中に問題が起きると「例外（Exception）」が発生します。例外が発生したまま何もしないでいると、プログラムはその場で強制終了してしまいます。

例えば、次のように文字列を数値に変換しようとすると ValueError という例外が発生します。

# 数字ではない文字列を数値に変換しようとすると…
number = int("abc")
# ここでValueErrorが発生し、プログラムが止まってしまう

このとき実際には ValueError: invalid literal for int() with base 10 のようなメッセージが表示されます。

このように、途中でプログラムが止まってしまうと、その後の処理がすべて実行されなくなります。例外処理を使うと、エラーが起きてもプログラムを止めずに、代わりの処理を実行することができます。

try-exceptの基本構文

例外処理の基本は try と except です。try ブロックに「エラーが起きるかもしれない処理」を書き、except ブロックに「エラーが起きたときの処理」を書きます。

try:
    number = int(input("数字を入力してください: "))
    print(number * 2)
except ValueError:
    print("数字ではない値が入力されました")

この例では、ユーザーが「5」と入力すれば 10 が表示されますが、「abc」のように数字でない値を入力しても、プログラムは止まらずに「数字ではない値が入力されました」と表示されます。エラーで落ちる代わりに、丁寧なメッセージを返せるわけです。

例外の種類を指定してキャッチする

例外にはたくさんの種類があります。よく出会うものをいくつか挙げてみましょう。

• ValueError：値が不適切なとき（例：int(“abc”)）
• ZeroDivisionError：0で割り算をしたとき
• TypeError：型が合わない演算をしたとき
• FileNotFoundError：指定したファイルが存在しないとき
• KeyError：辞書に存在しないキーを指定したとき

例えば、0での割り算は ZeroDivisionError になります。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("0で割ることはできません")
# 出力: 0で割ることはできません

なお、int() などの型変換でエラーが起きやすいポイントについては、Pythonの型変換（キャスト）の使い方を解説した記事もあわせて読むと理解が深まります。どんなときに ValueError が出るのかがイメージしやすくなりますよ。

例外処理を意識してコードを書けるようになると、一気に「実務で通用するコード」に近づきます。とはいえ、独学だと「なぜエラーになるのか」「どう直せばいいのか」で手が止まってしまいがちですよね。もし独学で伸び悩みを感じているなら、現役エンジニアに質問できる環境を用意するのも一つの手です。マンツーマンで学べるスクールについては、TechAcademyの評判を辛口レビューも含めて徹底解説した記事で詳しくまとめているので、独学の次の一歩として参考にしてみてください。

elseとfinallyの使い方

try-except には、else と finally を追加できます。else は「例外が起きなかったとき」に実行され、finally は「例外の有無にかかわらず必ず」実行されます。

try:
    f = open("data.txt", "r", encoding="utf-8")
except FileNotFoundError:
    print("ファイルが見つかりません")
else:
    print("ファイルを正常に開けました")
    f.close()
finally:
    print("処理を終了します")

finally は、ファイルを閉じたり後片づけをしたりする処理を書くのに便利です。ただし、ファイル操作については with 構文を使うと自動でクローズしてくれるので、より安全でスマートに書けます。詳しくは with構文の使い方を解説した記事を参考にしてください。

複数の例外をまとめて処理する

複数の種類の例外を同じように処理したい場合は、except にタプルで例外を並べて指定できます。また as を使うと、エラーメッセージの内容を受け取れます。

try:
    value = int("abc")
except (ValueError, TypeError) as e:
    print(f"エラーが発生しました: {e}")
# 出力: エラーが発生しました: invalid literal for int() with base 10: 'abc'

as e で受け取った例外オブジェクトを print すると、具体的なエラー内容が確認できます。デバッグのときにとても役立ちます。

raiseで自分から例外を発生させる

自分で意図的に例外を発生させたいときは raise を使います。関数に不正な値が渡されたときに、あえてエラーを出して呼び出し側に知らせる、といった使い方をします。

def set_age(age):
    if age < 0:
        raise ValueError("年齢に負の数は指定できません")
    return age

try:
    set_age(-5)
except ValueError as e:
    print(e)
# 出力: 年齢に負の数は指定できません

このように raise を使うと、「想定外の値はここではじく」という防御的なプログラムが書けるようになります。

例外処理を使うときの注意点

• try ブロックはできるだけ小さく保ち、エラーが起きうる処理だけを囲むようにしましょう。
• 例外の種類を指定せず except: だけで書くと、想定外のエラーまで握りつぶしてしまい、バグの発見が遅れます。
• エラーを except で受け取ったのに何もしない（pass だけ）のは避けましょう。最低限ログやメッセージを残すのがおすすめです。
• 例外処理は「起こりうるエラーへの備え」です。本来直すべきバグを隠すために使わないよう注意しましょう。

もっと効率的にPythonを学びたい人へ

※本記事には広告（アフィリエイトリンク）を含みます。

例外処理のように「実務で本当に必要な書き方」は、独学だけだと後回しになりがちです。未経験からPythonを最短で身につけたい、エラーで詰まったときにすぐ質問できる環境がほしいという方は、マンツーマン指導のスクールを検討してみるのも良い選択です。無料カウンセリングで学習プランや転職サポートの相談だけしてみる、という使い方もできます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回はPythonの例外処理（try-except）について解説しました。ポイントを振り返っておきましょう。

• try-except を使うと、エラーが起きてもプログラムを止めずに処理を続けられる
• except には ValueError や ZeroDivisionError など、キャッチしたい例外の種類を指定する
• else は例外が起きなかったとき、finally は必ず実行される
• 複数の例外はタプルでまとめて指定でき、as でエラー内容を受け取れる
• raise を使えば、自分から意図的に例外を発生させられる
• try ブロックは小さく、例外は種類を指定して受け取るのが安全

例外処理を使いこなせるようになると、ユーザーの入力ミスや予期しないデータにも動じない、丈夫なプログラムが書けるようになります。ぜひ実際に手を動かして試してみてください。

APIからデータを取得したり、設定ファイルを保存したりするとき、必ずと言っていいほど登場するのが「JSON（ジェイソン）」というデータ形式です。「なんとなく見たことはあるけれど、Pythonでどう読み書きすればいいのか分からない」という方も多いのではないでしょうか。

この記事では、Python標準のjsonモジュールを使って、辞書とJSONを相互に変換する方法や、JSONファイルの読み書き、日本語が文字化けしないための設定まで、初心者の方にも分かりやすく徹底解説します。コードはすべて実際に動く内容なので、手を動かしながら読み進めてみてください。

JSONとは？Pythonでよく使われる理由

JSON（JavaScript Object Notation）は、データを「キーと値」のペアで表現する軽量なデータ形式です。もともとはJavaScript由来ですが、今では言語を問わずデータのやり取りに使われる共通フォーマットになっています。

たとえば、次のような文字列がJSONです。Pythonの辞書（dict）にそっくりな見た目をしていることに気づくと思います。

{
  "name": "田中",
  "age": 28,
  "skills": ["Python", "SQL"]
}

PythonでJSONがよく使われるのは、Webアプリのデータ通信（REST API）、設定ファイル、ログの保存など、実務のあらゆる場面で登場するからです。JSONを扱えるようになると、外部サービスとのデータ連携が一気に身近になります。

jsonモジュールの基本（4つの関数を覚えよう）

Pythonでは標準ライブラリのjsonモジュールをimportするだけでJSONを扱えます。追加インストールは不要です。まずは覚えるべき4つの関数を整理しましょう。

• json.dumps()：Pythonのオブジェクト → JSON文字列に変換
• json.loads()：JSON文字列 → Pythonのオブジェクトに変換
• json.dump()：Pythonのオブジェクト → JSONファイルに書き込み
• json.load()：JSONファイル → Pythonのオブジェクトに読み込み

末尾にsが付く（dumps / loads）と「文字列（string）」を相手にする、付かない（dump / load）と「ファイル」を相手にする、と覚えると混乱しません。

辞書 → JSON文字列（json.dumps）

Pythonの辞書をJSON形式の文字列に変換するにはjson.dumps()を使います。

import json

# Pythonの辞書
user = {"name": "田中", "age": 28, "skills": ["Python", "SQL"]}

# 辞書 → JSON文字列
json_str = json.dumps(user)
print(json_str)
# {"name": "\u7530\u4e2d", "age": 28, "skills": ["Python", "SQL"]}

print(type(json_str))
# <class 'str'>

変換結果はstr型（文字列）になります。日本語が\u7530\u4e2dのように表示されていますが、これは後ほど解説する設定で読みやすくできるので安心してください。

JSON文字列 → 辞書（json.loads）

逆に、JSON形式の文字列をPythonの辞書に戻すにはjson.loads()を使います。APIから返ってきた文字列を扱うときの定番です。

import json

json_str = '{"name": "田中", "age": 28, "skills": ["Python", "SQL"]}'

# JSON文字列 → 辞書
data = json.loads(json_str)

print(data["name"])   # 田中
print(data["age"])    # 28
print(type(data))     # <class 'dict'>

json.loads()で辞書に戻せば、あとは辞書の基本操作と同じようにキーを指定して値を取り出せます。数値は数値、リストはリストとして正しく復元される点もポイントです。

ここまでで「PythonでJSONを読み書きする感覚」がつかめてきたのではないでしょうか。こうした基礎が身についてくると、次は「APIを叩いて実際のWebサービスとデータをやりとりするアプリをPythonで作りたい」という気持ちが湧いてくるはずです。独学でそこから先に伸び悩んだときは、Pythonを実践的に学べるテックジムのようなプログラミングスクールの評判・料金をまとめた記事も参考にしてみてください。学習の進め方の選択肢が広がります。

JSONファイルの読み書き（dump / load）

実務では、JSONを文字列としてではなく「ファイル」として保存・読み込みする場面が多くあります。ここではwith構文と組み合わせて、ファイルを安全に扱う方法を見ていきましょう。

ファイルへ書き込む（json.dump）

import json

data = {"title": "ナノトイラボ", "tags": ["Python", "初心者"]}

# data.json というファイルに書き込む
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# data.json が作成され、整形された状態で保存される

with open(...)を使うと、処理が終わったあとファイルを自動で閉じてくれます。ファイル操作の基本なので、まだ不安な方はwith構文の解説記事もあわせて確認しておくと安心です。

ファイルから読み込む（json.load）

import json

with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)

print(data["title"])    # ナノトイラボ
print(data["tags"][0])  # Python

json.load()で読み込むと、ファイルの中身がそのままPythonの辞書として手に入ります。あとは通常の辞書と同じように扱えます。

日本語の文字化けを防ぐ（ensure_ascii=False）

先ほどjson.dumps()で日本語が\u7530\u4e2dのように表示されたのを覚えているでしょうか。これは初期設定で日本語がエスケープされるためです。ensure_ascii=Falseを指定すると、日本語をそのまま出力できます。

import json

user = {"name": "田中", "age": 28}

# そのまま（日本語がエスケープされる）
print(json.dumps(user))
# {"name": "\u7530\u4e2d", "age": 28}

# ensure_ascii=False で日本語をそのまま表示
print(json.dumps(user, ensure_ascii=False))
# {"name": "田中", "age": 28}

見やすく整形する（indent）

indentに数値を指定すると、その分だけインデント（字下げ）して見やすく整形できます。設定ファイルなど、人間が読むJSONを出力するときに便利です。

import json

user = {"name": "田中", "age": 28, "skills": ["Python", "SQL"]}

print(json.dumps(user, ensure_ascii=False, indent=2))
# {
#   "name": "田中",
#   "age": 28,
#   "skills": [
#     "Python",
#     "SQL"
#   ]
# }

よくあるエラーと対処法

JSONを扱うときによく遭遇するのがJSONDecodeErrorです。これはJSONの書式が正しくないときに発生します。

import json

# 末尾に余分なカンマがある不正なJSON
broken = '{"name": "田中",}'

data = json.loads(broken)
# json.decoder.JSONDecodeError: Expecting property name
# enclosed in double quotes ...

JSONでは、末尾の余分なカンマや、シングルクォートでの囲みは認められていません。文字列は必ずダブルクォートで囲む必要があります。また、数値が文字列になっているといった型の食い違いにも注意しましょう。型の扱いに不安がある方は型変換（キャスト）の解説記事も参考になります。

もっと効率的にPythonを学びたい人へ

JSONの読み書きができるようになると、API連携やデータ処理など「実際に動くもの」を作れる範囲がぐっと広がります。一方で、独学だとエラーの原因が分からず何時間も止まってしまう、体系的な学習の順番が分からない、といった壁にぶつかりがちです。

「未経験からPythonを本気で習得したい」「できれば転職やキャリアにつなげたい」という方は、マンツーマン指導で学べるスクールを検討するのも一つの手です。プロ講師に直接質問できる環境は、独学でのつまずきを一気に解消してくれます。まずは無料カウンセリングで、自分に合った学習プランを相談してみてはいかがでしょうか。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回は、Pythonのjsonモジュールを使ったJSONの扱い方を解説しました。最後に要点を振り返っておきましょう。

• JSONは「キーと値」でデータを表す共通フォーマットで、Pythonの辞書とよく似ている
• json.dumps()で辞書→JSON文字列、json.loads()でJSON文字列→辞書に変換できる
• ファイルはjson.dump()で書き込み、json.load()で読み込む（with構文と併用が基本）
• 日本語の文字化けはensure_ascii=False、整形はindentで解決できる
• 書式ミスがあるとJSONDecodeErrorが出るので、カンマやクォートに注意する

JSONはWeb開発やデータ処理の基礎となる大切なスキルです。ぜひ手を動かして、自分のコードに取り入れてみてください。

「ログの中からエラー行だけを抜き出したい」「入力されたメールアドレスの形式をチェックしたい」「電話番号をまとめてマスキングしたい」——プログラミングを続けていると、こうした文字列のパターン検索に必ずぶつかります。

ひとつずつ if 文で条件を書いていくと、コードはあっという間に読めないほど長くなってしまいます。そんなときに絶大な威力を発揮するのが正規表現（regular expression）と、Python標準の re モジュールです。

正規表現は「記号だらけで難しそう」と敬遠されがちですが、実際によく使うのはほんの一握りのパターンと4つの関数だけです。この記事では、現役SEの視点から、re.search・re.match・re.findall・re.sub の使い方を、実際に動くコードと実行結果を示しながら初心者向けに徹底解説します。読み終えるころには、実務で使うレベルの文字列処理が書けるようになりますよ。

正規表現とは？何ができるのか

正規表現とは、「文字列のパターンを、記号を使って表現するための書き方（ルール）」のことです。「数字が3つ並んで、ハイフンがあって、また数字が4つ並ぶ」といったあいまいな条件を、たった一行で表現できます。

たとえば「電話番号らしき文字列」は、正規表現ではこう書けます。

\d{2,4}-\d{4}-\d{4}

これだけで「2〜4桁の数字 – 4桁の数字 – 4桁の数字」という意味になります。if 文で同じことを書こうとしたら何十行にもなるところが、1行で済んでしまうわけです。

正規表現が活躍する代表的な場面は次のとおりです。

• 検索：大量のログから ERROR 行だけを抜き出す
• 検証（バリデーション）：メールアドレスや郵便番号の形式チェック
• 抽出：文章の中から日付・URL・金額だけを取り出す
• 置換：個人情報をマスキングする、表記ゆれを統一する
• 分割：区切り文字が複数種類ある文字列をきれいに分ける

なお、単純な「この文字が含まれるか」「この文字で始まるか」程度の判定であれば、正規表現を持ち出さなくても標準の文字列メソッドで十分です。基本の使い分けについてはPythonの文字列メソッドの使い方を徹底解説した記事もあわせて読んでみてください。「文字列メソッドで書けるなら、まずはそちらを使う」のが読みやすいコードの鉄則です。

reモジュールの基本｜importとraw文字列

Pythonで正規表現を使うには、標準ライブラリの re モジュールを import するだけです。追加インストールは一切不要なので、Pythonさえ入っていればすぐに試せます。

import re

text = "お問い合わせ先は support@example.com です"

# パターンにマッチする部分を探す
result = re.search(r"[\w.-]+@[\w.-]+", text)
print(result.group())
# 実行結果: support@example.com

たった3行で、文章の中からメールアドレスを取り出せました。

パターンの前には必ず r を付ける（raw文字列）

先ほどのコードで、パターンが r"..." という形になっていたことに気づきましたか？ この r はraw文字列（ロー文字列）を表すもので、正規表現を書くときのお約束です。

Pythonの文字列では \n が改行、\t がタブというように、バックスラッシュに特別な意味があります。一方、正規表現でも \d（数字）や \w（英数字）のようにバックスラッシュを多用します。この2つが衝突すると、バックスラッシュを二重に書く羽目になり、とても読みにくくなります。

import re

# raw文字列を使わない書き方（バックスラッシュが増えて読みにくい）
pattern_ng = "\\d{3}-\\d{4}"

# raw文字列を使った書き方（見たままでOK・こちらが推奨）
pattern_ok = r"\d{3}-\d{4}"

print(re.search(pattern_ok, "郵便番号は 100-0001 です").group())
# 実行結果: 100-0001

正規表現のパターンは、何も考えず先頭に r を付けると覚えてしまいましょう。これだけでハマりどころを1つ回避できます。

まず覚えるべき4つの関数

re モジュールにはたくさんの関数がありますが、実務でよく使うのは次の4つに集約されます。まずはこれだけ押さえれば十分です。

• re.search()…文字列全体からパターンを探す（最初の1件）
• re.match()…文字列の先頭がパターンと一致するか調べる
• re.findall()…マッチする箇所をすべてリストで取得する
• re.sub()…マッチした部分を置換する

re.search()｜どこかに含まれるか探す

もっとも出番が多いのが re.search() です。文字列全体を走査して、最初に見つかった箇所をマッチオブジェクトとして返します。見つからなかった場合は None を返します。

import re

text = "注文番号: A-2026-0717 を確認しました"

m = re.search(r"[A-Z]-\d{4}-\d{4}", text)

if m:
    print("見つかりました:", m.group())   # マッチした文字列
    print("開始位置:", m.start())         # 開始インデックス
    print("終了位置:", m.end())           # 終了インデックス
else:
    print("見つかりませんでした")

# 実行結果:
# 見つかりました: A-2026-0717
# 開始位置: 6
# 終了位置: 17

ポイントは必ず if m: でマッチしたか確認してから .group() を呼ぶことです。マッチしなかったときは None が返るため、いきなり .group() を呼ぶと AttributeError になってしまいます。ここは初心者が最初につまずく定番ポイントです。

re.match()｜先頭だけを調べる

re.match() は名前から「一致するか調べる関数」と誤解されやすいのですが、実際は文字列の先頭からマッチするかだけを見ます。途中にあってもマッチしません。

import re

text = "Python3 is fun"

print(re.match(r"Python", text))   # 先頭にあるのでマッチする
print(re.match(r"is", text))       # 先頭ではないのでマッチしない
print(re.search(r"is", text))      # searchなら途中でも見つかる

# 実行結果:
# <re.Match object; span=(0, 6), match='Python'>
# None
# <re.Match object; span=(8, 10), match='is'>

迷ったら re.search() を使えば間違いありません。re.match() は「入力値が指定した形式で始まっているか」を検証したいときに使う、と覚えておきましょう。

re.findall()｜該当する箇所をすべて集める

マッチする箇所をまとめてリストで欲しいときは re.findall() です。戻り値がそのままリストなので、そのまま for 文で回せて便利です。

import re

text = "本社は 03-1234-5678、大阪支社は 06-2222-3333、携帯は 090-8765-4321 です"

numbers = re.findall(r"\d{2,4}-\d{4}-\d{4}", text)
print(numbers)
# 実行結果: ['03-1234-5678', '06-2222-3333', '090-8765-4321']

for i, num in enumerate(numbers, 1):
    print(f"{i}件目: {num}")

# 実行結果:
# 1件目: 03-1234-5678
# 2件目: 06-2222-3333
# 3件目: 090-8765-4321

マッチが1件もなければ、空のリスト [] が返ります。None ではないので、if numbers: でそのまま判定できるのが findall() の気楽なところです。

re.sub()｜パターンにマッチした部分を置換する

個人情報のマスキングや表記ゆれの統一で大活躍するのが re.sub() です。str.replace() は決まった文字列しか置換できませんが、re.sub() ならパターンで置換できます。

import re

text = "連絡先: 090-1234-5678 / 080-9999-0000"

# 電話番号をまとめてマスキングする
masked = re.sub(r"\d{3}-\d{4}-\d{4}", "***-****-****", text)
print(masked)
# 実行結果: 連絡先: ***-****-**** / ***-****-****

# 連続する空白を1つにまとめる（テキスト整形の定番）
messy = "Python    は  とても     便利です"
clean = re.sub(r"\s+", " ", messy)
print(clean)
# 実行結果: Python は とても 便利です

2つ目の「連続する空白を1つにまとめる」は、スクレイピングやCSV処理で拾ってきた汚いテキストを整形するときに本当によく使うテクニックです。ぜひ覚えておいてください。

re.split()｜複数の区切り文字で分割する

おまけとして re.split() も紹介します。区切り文字が1種類だけなら標準の split() で十分ですが、「カンマでも、セミコロンでも、空白でも区切りたい」という場合は正規表現の出番です。

import re

text = "りんご, みかん;ぶどう  バナナ"

fruits = re.split(r"[,;\s]+", text)
print(fruits)
# 実行結果: ['りんご', 'みかん', 'ぶどう', 'バナナ']

区切り文字が1種類の場合の基本的な分割・結合については、Pythonで文字列を分割・結合する方法（split・join）の解説記事で詳しく扱っています。取り出した後の一部分だけを切り出したいときはスライスの使い方を解説した記事も参考になりますよ。

ここまでで基本の4関数はマスターできました。ただ、正規表現は「読んで分かる」と「自分で書ける」の間に、それなりの壁があるのも事実です。独学で手が止まってしまう、質問できる相手がいなくて時間だけが過ぎていく——そんな状態が続くようなら、学習環境そのものを見直すのも立派な選択肢です。プログラミングスクール5選を比較した記事では、無料体験のあるスクールを実際に体験したうえで比較しているので、独学と併用する判断材料としてのぞいてみてください。

グループ化｜必要な部分だけを取り出す

正規表現の真価はグループ化で発揮されます。パターンの一部を () で囲むと、その部分だけを個別に取り出せるようになります。ログ解析ではこれが必須テクニックです。

import re

log = "2026-07-17 09:00:00 ERROR ディスク容量が不足しています"

m = re.search(r"(\d{4})-(\d{2})-(\d{2}) (\d{2}:\d{2}:\d{2}) (\w+)", log)

print(m.group(0))   # パターン全体
print(m.group(1))   # 1つ目の()
print(m.group(5))   # 5つ目の()
print(m.groups())   # すべてのグループをタプルで取得

# 実行結果:
# 2026-07-17 09:00:00 ERROR
# 2026
# ERROR
# ('2026', '07', '17', '09:00:00', 'ERROR')

group(0) がマッチ全体、group(1) 以降が左のカッコから順番に対応します。0始まりではなく1始まりである点に注意してください。

名前付きグループでコードを読みやすくする

group(3) のような番号指定は、パターンを修正した瞬間に番号がずれてバグの温床になります。実務では (?P<名前>...) という名前付きグループを使うのがおすすめです。

import re

log = "2026-07-17 09:00:00 ERROR ディスク容量が不足しています"

pattern = r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) (?P<level>\w+) (?P<message>.+)"
m = re.search(pattern, log)

print(m.group("date"))
print(m.group("level"))
print(m.group("message"))
print(m.groupdict())

# 実行結果:
# 2026-07-17
# ERROR
# ディスク容量が不足しています
# {'date': '2026-07-17', 'time': '09:00:00', 'level': 'ERROR', 'message': 'ディスク容量が不足しています'}

groupdict() を使えば、結果をそのまま辞書として受け取れます。辞書の扱い方に不安がある方は、辞書(dict)の使い方を徹底解説した記事もあわせてどうぞ。数か月後の自分がコードを読み返したときに感謝するのは、間違いなく名前付きグループのほうです。

最低限おさえたいメタ文字チートシート

正規表現の記号（メタ文字）は膨大にありますが、実務で使うのは以下でほぼ足ります。丸暗記せず、必要になったら見返す程度で十分です。

• .…任意の1文字（改行以外）
• \d…数字1文字（[0-9] と同じ）
• \w…英数字とアンダースコア1文字
• \s…空白文字（スペース・タブ・改行）
• [abc]…a か b か c のいずれか1文字
• [^abc]…a・b・c以外の1文字
• [a-z]…a〜zの範囲の1文字
• *…直前のパターンの0回以上の繰り返し
• +…直前のパターンの1回以上の繰り返し
• ?…直前のパターンが0回か1回（＝省略可能）
• {3}…ちょうど3回、{2,4}…2〜4回の繰り返し
• ^…文字列の先頭、$…文字列の末尾
• |…OR条件（猫|犬 なら「猫」か「犬」）
• ()…グループ化

なお \d を大文字にした \D は「数字以外」というように、大文字にすると意味が反転します（\W・\S も同様）。この法則を知っておくと覚える量が半分になりますよ。

re.compile()｜同じパターンを何度も使うとき

同じパターンをループ内で何度も使う場合は、re.compile() であらかじめパターンをコンパイル（コンパイル済みオブジェクト化）しておくと、コードが読みやすくなり、実行速度の面でも有利です。

import re

# メールアドレスの形式チェック用パターンを1回だけ用意する
pattern = re.compile(r"^[\w.+-]+@[\w-]+\.[\w.-]+$")

emails = ["taro@example.com", "hanako@@example", "jiro@sub.example.co.jp"]

for e in emails:
    if pattern.match(e):
        print(f"{e} は有効な形式です")
    else:
        print(f"{e} は無効な形式です")

# 実行結果:
# taro@example.com は有効な形式です
# hanako@@example は無効な形式です
# jiro@sub.example.co.jp は有効な形式です

コンパイル済みオブジェクトからは、pattern.search()・pattern.findall()・pattern.sub() のように、これまで紹介した関数を同じ名前で呼び出せます。第1引数のパターンを渡さなくてよくなる、と理解しておけばOKです。

フラグで挙動を変える

各関数の引数にフラグを渡すと、マッチのルールを変更できます。もっとも使うのは大文字小文字を区別しない re.IGNORECASE です。

import re

text = "Python python PYTHON"

print(re.findall(r"python", text))
# 実行結果: ['python']

print(re.findall(r"python", text, re.IGNORECASE))
# 実行結果: ['Python', 'python', 'PYTHON']

ほかにも re.MULTILINE（^ と $ を行単位で判定する）、re.DOTALL（. が改行にもマッチする）などがあります。複数行のログを1行ずつ判定したいときは re.MULTILINE が便利です。

初心者がハマりやすい注意点3つ

1. 「欲張りマッチ」で余計な部分まで取れてしまう

* や + は、デフォルトでできるだけ長くマッチしようとする性質（貪欲マッチ）を持っています。これが意図しない結果を生む最大の原因です。

import re

html = "<b>太字</b>と<i>斜体</i>"

# 貪欲マッチ：最初の<から最後の>まで丸ごと取れてしまう
print(re.findall(r"<.+>", html))
# 実行結果: ['<b>太字</b>と<i>斜体</i>']

# 非貪欲マッチ：?を付けると最短でマッチする
print(re.findall(r"<.+?>", html))
# 実行結果: ['<b>', '</b>', '<i>', '</i>']

「なぜか想定より長く取れてしまう」と感じたら、+? や *? のように? を付けて最短マッチにする——これを覚えておくだけで解決することがほとんどです。

2. マッチしなかったときのNoneを忘れる

繰り返しになりますが、これが一番多いエラーです。re.search() と re.match() は、マッチしなければ None を返します。

import re

text = "数字が含まれていない文章です"

# NG例：マッチしないとAttributeErrorで落ちる
# print(re.search(r"\d+", text).group())
# AttributeError: 'NoneType' object has no attribute 'group'

# OK例：必ずNoneチェックをしてから使う
m = re.search(r"\d+", text)
if m:
    print("見つかった数字:", m.group())
else:
    print("数字は含まれていませんでした")

# 実行結果: 数字は含まれていませんでした

「マッチしないこともある」という前提でコードを書くクセをつけましょう。実務のデータは、こちらの想定どおりの形では絶対に届きません。

3. なんでもかんでも正規表現で解こうとする

正規表現は強力ですが、複雑になるほど誰も読めない呪文と化します。半年後の自分が解読できないコードは、それだけで技術的負債です。

import re

text = "Pythonは楽しい"

# 冗長：正規表現を使うまでもない
print(bool(re.search(r"Python", text)))   # True

# シンプル：こちらのほうが速いし読みやすい
print("Python" in text)                   # True
print(text.startswith("Python"))          # True

「文字列メソッドで書けるなら文字列メソッド、無理なら正規表現」。この判断ができるようになれば、正規表現とは良い付き合いができます。また、複雑なパターンを書いたときは、必ず # 郵便番号(3桁-4桁)にマッチ のようなコメントを1行添えておきましょう。将来の自分とチームメンバーへの、何よりの贈り物になります。

正規表現を「使いこなす」段階へ進みたい人へ

正規表現は、記事を読んで理解した気になっても、いざ実務のデータを前にすると手が止まりがちな分野です。パターンの書き方そのものより、「この処理は正規表現で書くべきか」という設計判断のほうが難しく、ここは経験者にレビューしてもらうのが一番の近道でもあります。

独学で行き詰まりを感じているなら、マンツーマンで質問できる環境を検討してみるのも手です。Winスクールの「Python Winner」は、未経験からのPython習得を前提としたマンツーマンレッスンで、転職サポートまで用意されています。無料カウンセリングだけでも受けてみると、自分に足りないものがはっきりしますよ。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回は、Pythonの正規表現（re モジュール）の使い方を初心者向けに解説しました。要点を整理しておきます。

• 正規表現は「文字列のパターン」を記号で表現する書き方で、Pythonでは標準の re モジュールを import するだけで使える
• パターンの先頭には必ず r を付けてraw文字列にする
• re.search() は文字列全体から探す。迷ったらこれを使う
• re.match() は先頭のみを判定する。形式チェック向き
• re.findall() はマッチした箇所をすべてリストで返す
• re.sub() はパターンで置換できる。マスキングや整形の定番
• () でグループ化すれば必要な部分だけ取り出せる。実務では (?P<名前>...) の名前付きグループが読みやすくおすすめ
• re.search()・re.match() はマッチしないと None を返すので、必ずNoneチェックしてから .group() を呼ぶ
• + や * は貪欲マッチ。長く取れすぎるときは +? で最短マッチにする
• 文字列メソッドで書けるなら、まずはそちらを使う

正規表現は、一度書けるようになるとログ解析・データ整形・入力チェックなど、あらゆる場面で一生使える武器になります。まずは re.search() と re.findall() の2つを、手元のコードで試すところから始めてみてください。実際に手を動かして「取れた！」という感覚をつかむのが、一番の近道です。

最後までお読みいただき、ありがとうございました。

Pythonでfor文やwhile文を書いていると、「ある条件になったらループを止めたい」「特定のときだけ処理を飛ばしたい」と思うことはありませんか？そんなときに活躍するのがbreak文とcontinue文です。

この2つを使いこなせるようになると、ループ処理を自分の思いどおりにコントロールできるようになり、コードがぐっと読みやすく効率的になります。この記事では、break文とcontinue文の違いから実践的な使い方まで、初心者の方にも分かるように具体的なコードとあわせて丁寧に解説していきます。

break文とcontinue文とは？

break文とcontinue文は、どちらもfor文やwhile文などのループ処理の流れを制御するための命令です。名前は似ていますが、動きはまったく異なります。まずはそれぞれの役割をざっくりイメージでつかんでおきましょう。

• break文：ループそのものを途中で完全に抜ける（それ以降は繰り返さない）
• continue文：その回の処理だけをスキップして、次の繰り返しに進む

「break＝ループを終わらせる」「continue＝今回だけ飛ばす」と覚えておくと混乱しにくいです。ループの基本であるfor文やwhile文がまだあいまいな方は、先にwhile文の基礎を解説した記事やfor文・range関数の使い方をまとめた記事に目を通しておくと、この記事の内容がよりスムーズに理解できます。

break文の使い方：ループを途中で抜ける

break文は、条件を満たしたときにループを終了させたい場面で使います。たとえば1から順番に数えていって、5になったらそこでやめる、という処理は次のように書けます。

for i in range(1, 11):
    if i == 5:
        break
    print(i)

# 実行結果
# 1
# 2
# 3
# 4

iが5になった瞬間にbreakが実行され、print(i)にたどり着く前にループ全体が終了します。そのため画面には1から4までしか表示されません。「目的のものが見つかったら、それ以上探す必要はない」といったケースでとても便利です。

continue文の使い方：処理をスキップして次へ

continue文は、条件を満たしたときにその回の処理だけを飛ばして、ループ自体は続けたい場面で使います。次のコードは、1から10までのうち偶数を飛ばして奇数だけを表示する例です。

for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)

# 実行結果
# 1
# 3
# 5
# 7
# 9

iが偶数（2で割った余りが0）のときはcontinueが実行され、print(i)を飛ばして次のループに進みます。breakと違ってループは最後まで続く点が大きな違いです。「特定のデータだけ除外して処理したい」ときの定番テクニックです。

実践例：リストの中から目的のデータを探す

break文がよく使われるのが、リストの中から特定の要素を探すケースです。見つかった時点でループを抜ければ、無駄な繰り返しを省けます。ここではfor文とセットで使えるfor-else構文もあわせて紹介します。

fruits = ["りんご", "ばなな", "みかん", "ぶどう"]
target = "みかん"

for fruit in fruits:
    if fruit == target:
        print(target + "が見つかりました！")
        break
else:
    print(target + "は見つかりませんでした")

# 実行結果
# みかんが見つかりました！

for文のelseは、ループがbreakされずに最後まで回りきったときだけ実行される少し特殊な仕組みです。今回は「みかん」が見つかってbreakされたので、elseのメッセージは表示されません。リストを扱う処理に慣れてきたら、for文で合計を求める方法の記事もあわせて読むと、ループの応用力がさらに高まります。

while文でのbreak：無限ループを安全に止める

break文はwhile文と組み合わせるとさらに真価を発揮します。「while True」と書くと本来は永遠に終わらない無限ループになりますが、breakを使えば好きなタイミングで抜け出せます。

count = 0
while True:
    count += 1
    if count > 3:
        break
    print("処理" + str(count) + "回目")

# 実行結果
# 処理1回目
# 処理2回目
# 処理3回目

countが3を超えた時点でbreakが実行され、ループが終了します。ユーザーの入力を受け付け続けて「終了」と入力されたら止める、といった処理でよく使われるパターンです。

breakとcontinueを組み合わせる

2つを同時に使うこともできます。次のコードは「偶数はスキップし（continue）、15を超えたら終了する（break）」という条件で奇数を表示する例です。

for num in range(1, 21):
    if num % 2 == 0:
        continue
    if num > 15:
        break
    print(num)

# 実行結果
# 1
# 3
# 5
# 7
# 9
# 11
# 13
# 15

偶数のときはcontinueで飛ばし、奇数でも15を超えたらbreakで終了しています。このように条件を組み合わせることで、複雑なループ制御もシンプルに書けるようになります。

よくある間違いと注意点

• break・continueはループの中でしか使えない：for文やwhile文の外で使うとエラーになります。
• ネストしたループでは内側のループにだけ効く：二重ループの内側でbreakしても、外側のループは止まりません。
• continueの多用は読みにくさにつながることも：条件が複雑になりすぎたら、if文で書き換えられないか検討してみましょう。

とくにネスト（入れ子）したループでの挙動は初心者がつまずきやすいポイントです。「どのループを抜けているのか」を常に意識すると、バグを防ぎやすくなります。

もっと効率的にPythonを学びたい人へ

break文やcontinue文のようなループ制御は、独学でも理解できますが、「実際のプログラムでどう組み合わせるのか」までを身につけようとすると、独学ではなかなか手応えをつかみにくいものです。分からないところをその場で質問できる環境があると、学習スピードは大きく変わります。

もし本気でPythonを習得して仕事につなげたいなら、マンツーマン指導で未経験からPythonを学べるプログラミングスクールを検討してみるのもおすすめです。プロの講師に質問しながら進められるうえ、転職サポートが用意されているスクールも多く、まずは無料カウンセリングで学習プランを相談してみると自分に合うかどうかが見えてきます。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回はPythonのbreak文とcontinue文について解説しました。最後に要点を振り返っておきましょう。

• break文はループを途中で完全に抜けるための命令
• continue文はその回の処理だけを飛ばして次の繰り返しに進む命令
• リストからの検索や「while True」の無限ループ制御でbreakが活躍する
• 特定のデータを除外したいときはcontinueが便利
• break・continueはループの中でのみ使え、ネストでは内側のループにだけ効く

break文とcontinue文を使いこなせるようになると、ループ処理の表現力が一気に広がります。まずは今回のコードを実際に書き換えて動かしてみて、それぞれの動きの違いを体で覚えていきましょう。

「リストの最初の3つだけ取り出したい」「文字列の後ろ2文字だけ欲しい」——Pythonを勉強していると、こんな場面によく出会いますよね。そんなときに大活躍するのがスライス（slice）です。

スライスを覚えると、for文でわざわざ数えながら取り出さなくても、たった1行でリストや文字列の一部をスッと取り出せるようになります。最初は「コロンの数字の意味がよく分からない…」とつまずきやすいところですが、ルールはとてもシンプルです。

この記事では、Pythonのスライスの基本の書き方から、ステップ指定・マイナス指定・逆順といった応用テクニックまで、初心者の方にも分かりやすく徹底解説します。この記事を読み終わるころには、スライスを自在に使いこなせるようになっているはずです。

スライスとは？基本の書き方

スライスとは、リストや文字列などの連続したデータの一部を切り出すための機能です。基本の書き方は次のとおりで、角括弧の中にコロン（:）で区切った数字を書きます。

シーケンス[start:stop]

startが取り出しを開始する位置、stopが終了する位置です。ここで大切なルールは、startは含み、stopは含まないという点です。実際にリストで試してみましょう。

numbers = [10, 20, 30, 40, 50]

print(numbers[1:4])
# 結果: [20, 30, 40]

インデックス（番号）は0から始まることを思い出してください。numbers[1:4]は「インデックス1から、インデックス4の手前まで」という意味なので、20・30・40の3つが取り出されます。インデックス4の50は含まれない点に注意しましょう。

なお、スライスで取り出したデータは元のリストとは別の新しいリストになります。リスト操作の基本についてはPythonでリストに要素を追加する方法の記事もあわせて読むと理解が深まります。

startとstopは省略できる

スライスでは、startやstopを省略することができます。省略した場合は「先頭から」「末尾まで」という意味になります。

numbers = [10, 20, 30, 40, 50]

print(numbers[:3])   # 先頭から3つ -> [10, 20, 30]
print(numbers[2:])   # インデックス2から末尾まで -> [30, 40, 50]
print(numbers[:])    # 全部（コピー） -> [10, 20, 30, 40, 50]

numbers[:]のように両方省略すると、リスト全体をコピーできます。これは元のリストを壊さずに扱いたいときに便利なテクニックです。

ステップ（step）で飛ばしながら取り出す

スライスには3つ目の数字としてステップ（step）を指定できます。書き方は次のとおりです。

シーケンス[start:stop:step]

stepは「何個おきに取り出すか」を表します。たとえば2を指定すると、1つ飛ばしで取り出せます。

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

print(numbers[::2])    # 偶数番目 -> [0, 2, 4, 6, 8]
print(numbers[1::2])   # 奇数番目 -> [1, 3, 5, 7, 9]

numbers[::2]は「先頭から末尾まで2個おき」という意味になり、偶数番目の要素だけを取り出せます。

マイナスのインデックスで後ろから取り出す

Pythonでは、インデックスにマイナスの数字を使うと後ろから数えた位置を指定できます。一番後ろが-1、その手前が-2です。スライスでもこのマイナス指定が使えます。

word = ['P', 'y', 't', 'h', 'o', 'n']

print(word[-2:])    # 後ろ2つ -> ['o', 'n']
print(word[:-2])    # 後ろ2つを除く -> ['P', 'y', 't', 'h']

「末尾のいくつかだけ欲しい」「末尾のいくつかを取り除きたい」といった処理が、マイナス指定を使うととてもスッキリ書けます。

stepにマイナスを指定すると逆順になる

stepにマイナスの値を指定すると、後ろから前に向かって取り出すことになり、結果として並びが逆順になります。[::-1]はリストや文字列を反転させる定番のテクニックです。

numbers = [1, 2, 3, 4, 5]

print(numbers[::-1])
# 結果: [5, 4, 3, 2, 1]

文字列でもスライスは使える

スライスはリストだけでなく文字列でも同じように使えます。文字列を1文字ずつのシーケンスとして扱えるので、一部分を取り出すのが簡単です。

text = 'Python'

print(text[0:3])   # 先頭3文字 -> Pyt
print(text[-2:])   # 後ろ2文字 -> on
print(text[::-1])  # 逆順 -> nohtyP

文字列の切り出しや加工では、スライスと文字列メソッドを組み合わせると、より柔軟な処理ができるようになります。あわせて覚えておくと便利です。

タプルでもスライスは使える

スライスは、リストや文字列と同じ「シーケンス型」であるタプル(tuple)でも利用できます。ただしタプルは変更できない（イミュータブル）ため、スライスで取り出した結果も新しいタプルになります。

colors = ('赤', '青', '緑', '黄')

print(colors[1:3])
# 結果: ('青', '緑')

スライスでリストの一部を書き換える

リストの場合は、スライスで指定した範囲にまとめて代入することもできます。複数の要素を一気に置き換えられるので便利です。

numbers = [1, 2, 3, 4, 5]
numbers[1:3] = [20, 30]
print(numbers)
# 結果: [1, 20, 30, 4, 5]

この書き換えは、要素の数が違っても動作します。たとえば2つの範囲に3つの要素を代入すれば、リスト全体の長さも変わります。なお、取り出した要素をまとめて加工したいときはリスト内包表記と組み合わせると、さらに短く書けます。

スライスでよくある間違いと注意点

最後に、初心者の方がつまずきやすいポイントを確認しておきましょう。

• stopの位置は含まれない：[1:4]はインデックス4を含みません。「終わりの手前まで」と覚えましょう。
• 範囲外を指定してもエラーにならない：numbers[1:100]のように大きすぎる数字を書いても、エラーではなく「あるところまで」を返してくれます。
• スライスは新しいオブジェクトを作る：元のデータは書き換わりません（代入する場合を除く）。

numbers = [10, 20, 30]
print(numbers[1:100])   # エラーにならない -> [20, 30]
print(numbers[5:10])    # 範囲外 -> [] （空のリスト）

もっと効率的にPythonを学びたい人へ

スライスのように「知っていると一気にコードが短くなる」テクニックは、Pythonにはまだまだたくさんあります。独学でも学べますが、「つまずいたときにすぐ質問できる環境が欲しい」「未経験から効率よくPythonを身につけたい」という方には、プログラミングスクールという選択肢もおすすめです。

マンツーマン指導で自分のペースに合わせて学べるスクールなら、エラーで長時間悩む時間を減らし、転職サポートまで受けられます。多くのスクールが無料カウンセリングを用意しているので、まずは気軽に相談してみるとよいでしょう。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回は、Pythonのスライスの使い方について解説しました。最後に要点を整理しておきましょう。

• スライスは[start:stop]で、リストや文字列の一部を切り出せる
• startは含み、stopは含まないのが基本ルール
• startやstopは省略でき、[:]で全体のコピーができる
• [start:stop:step]のstepで飛ばし読みができ、[::-1]で逆順になる
• マイナスのインデックスで後ろから取り出せる
• リストならスライスへの代入で一部をまとめて書き換えられる

スライスは、Pythonを書くうえで毎日のように使う超基本テクニックです。ぜひ実際に手を動かして、いろいろな数字を試しながら感覚をつかんでみてくださいね。

関数を作っていると、「引数の数を決めうちにしたくない」「あとから引数を増やしたい」と感じる場面がありますよね。たとえば「渡された数値をぜんぶ合計する関数」を作りたいとき、引数を固定してしまうと不便です。そんなときに活躍するのが、Pythonの可変長引数である *args と **kwargs です。

この記事では、可変長引数の基本から、*args（位置引数をまとめて受け取る）と **kwargs（キーワード引数をまとめて受け取る）の違い、引数を書く順番、呼び出し側でのアンパックまで、実際に動くコードを交えながら初心者向けに丁寧に解説します。読み終えるころには、柔軟で再利用しやすい関数が書けるようになりますよ。

可変長引数とは？

可変長引数とは、その名のとおり「個数が決まっていない引数」を受け取るしくみのことです。通常の関数は def add(a, b): のように引数の数が固定ですが、可変長引数を使うと、0個でも100個でも同じ関数で受け取れるようになります。

可変長引数には2種類あります。位置引数（順番で渡す引数）をまとめて受け取る *args と、キーワード引数（名前付きで渡す引数）をまとめて受け取る **kwargs です。それぞれ順番に見ていきましょう。なお、関数の基本的な書き方があいまいな方は、先に関数の基礎を解説した記事を読んでおくと理解がスムーズです。

*args の使い方（位置引数をまとめて受け取る）

仮引数の前にアスタリスク（*）を1つ付けると、渡された位置引数をすべてまとめて受け取れます。慣例として名前は args がよく使われますが、名前自体は自由です（大切なのは先頭の * です）。まずは「渡された数値を合計する関数」を作ってみましょう。

def add(*args):
    total = 0
    for n in args:
        total += n
    return total

print(add(1, 2, 3))        # 6
print(add(10, 20, 30, 40)) # 100
print(add())               # 0

引数を3個渡しても4個渡しても、さらには1個も渡さなくても、同じ関数で処理できています。これが可変長引数の便利なところです。

args の正体はタプル

*args で受け取った値は、タプルとしてまとめられます。実際に型を確認してみましょう。

def show(*args):
    print(type(args))
    print(args)

show(1, 2, 3)
# <class 'tuple'>
# (1, 2, 3)

このように args はタプルなので、for でループしたり、args[0] のようにインデックスでアクセスしたりできます。タプルそのものの性質についてはタプル(tuple)の使い方を解説した記事もあわせて読むと理解が深まります。

**kwargs の使い方（キーワード引数をまとめて受け取る）

仮引数の前にアスタリスクを2つ（**）付けると、name="佐藤" のような「名前付きの引数（キーワード引数）」をまとめて受け取れます。こちらも慣例で kwargs（keyword arguments の略）という名前がよく使われます。

def profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

profile(name="佐藤", age=25, job="SE")
# name: 佐藤
# age: 25
# job: SE

渡したキーワード引数が、そのままキーと値のペアとして扱われているのが分かりますね。

kwargs の正体は辞書

**kwargs で受け取った値は、辞書（dict）としてまとめられます。

def show(**kwargs):
    print(type(kwargs))
    print(kwargs)

show(a=1, b=2)
# <class 'dict'>
# {'a': 1, 'b': 2}

辞書なので、kwargs.items() でループしたり、kwargs.get("age") で値を取り出したりできます。辞書の操作に不安がある方は辞書(dict)の使い方を解説した記事も参考にしてみてください。

通常の引数と組み合わせる（引数を書く順番）

可変長引数は、通常の引数といっしょに使うこともできます。ただし、書く順番には決まりがあります。「通常の引数 → *args → **kwargs」の順に並べる必要があり、これを守らないとエラーになります。

def func(a, b, *args, **kwargs):
    print("a =", a)
    print("b =", b)
    print("args =", args)
    print("kwargs =", kwargs)

func(1, 2, 3, 4, x=10, y=20)
# a = 1
# b = 2
# args = (3, 4)
# kwargs = {'x': 10, 'y': 20}

最初の2つ（1, 2）が a・b に入り、残りの位置引数（3, 4）が args に、名前付きの引数（x, y）が kwargs に振り分けられました。役割ごとにきれいに分かれるのがポイントです。

呼び出し側の * と **（アンパック）

ここまでは関数を「定義する側」の話でしたが、* と ** は関数を「呼び出す側」でも使えます。リストやタプルの前に * を付けると、要素がバラバラの位置引数として展開（アンパック）され、辞書の前に ** を付けると、キーワード引数として展開されます。

numbers = [1, 2, 3]
print(add(*numbers))   # 6

user = {"name": "田中", "age": 30, "job": "SE"}
profile(**user)
# name: 田中
# age: 30
# job: SE

リストや辞書に入っているデータを、そのまま関数の引数として渡せるのでとても便利です。この「アンパック」という考え方についてはリストのアンパックを解説した記事でも詳しく紹介しています。

実用例：柔軟な関数を作る

*args と **kwargs を組み合わせると、状況に応じて引数の数が変わるような、柔軟な関数を作れます。たとえば、メイン料理・サイド料理（複数）・オプション（名前付き）を受け取る注文関数はこう書けます。

def order(main, *sides, **options):
    print(f"メイン: {main}")
    if sides:
        print("サイド:", ", ".join(sides))
    for key, value in options.items():
        print(f"{key} → {value}")

order("ハンバーグ", "サラダ", "スープ", drink="コーヒー", size="大盛り")
# メイン: ハンバーグ
# サイド: サラダ, スープ
# drink → コーヒー
# size → 大盛り

サイドが何品でも、オプションが何個でも、1つの関数で受け止められます。ライブラリの関数がさまざまなオプションを受け取れるのは、まさにこのしくみが使われているからです。

よくあるエラーと注意点

可変長引数でつまずきやすいポイントをまとめておきます。まず、引数の順番を間違えて def func(**kwargs, a): のように書くと SyntaxError になります。必ず「通常の引数 → *args → **kwargs」の順を守りましょう。

また、*args はタプル、**kwargs は辞書である点を忘れると、存在しないメソッドを呼んでエラーになりがちです。args に対して .items() を呼んだり、kwargs に対して append() を呼んだりしないよう注意してください。名前は args・kwargs でなくても動きますが、他の人が読んだときに分かりやすいので、特別な理由がなければ慣例に従うのがおすすめです。

もっと効率的にPythonを学びたい人へ

可変長引数のように、Pythonには「知っていると一気に便利になる」文法がたくさんあります。独学でも学べますが、つまずいたときにすぐ質問できる環境があると、挫折せずに一気に上達できます。

未経験からPythonを本格的に習得して、エンジニア転職まで目指したい方には、マンツーマン指導が受けられるプログラミングスクールという選択肢もあります。プロ講師にコードを直接見てもらえるので、独学では気づきにくい「書き方のクセ」も早い段階で直せます。まずは無料カウンセリングで、自分に合う学び方を相談してみるのも良いですよ。

※本記事には広告（アフィリエイトリンク）を含みます。

Pythonプログラミング｜マンツーマンレッスンで初めてをプロに育てる【Python Winner】

まとめ

今回は、Pythonの可変長引数 *args と **kwargs について解説しました。最後に要点を振り返っておきましょう。

• *args：任意の個数の位置引数をまとめて受け取り、タプルになる
• **kwargs：任意の個数のキーワード引数をまとめて受け取り、辞書になる
• 引数を書く順番は「通常の引数 → *args → **kwargs」を守る
• 呼び出し側でも *リスト・**辞書 でアンパックして渡せる
• 名前は自由だが、慣例の args・kwargs を使うと読みやすい

可変長引数を使いこなせると、柔軟で再利用しやすい関数が書けるようになります。ぜひ実際に手を動かして、いろいろな引数を渡して試してみてくださいね。