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

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

Pythonで文字列を扱っていると、「余分な空白を消したい」「一部の文字を別の文字に置き換えたい」「特定の文字が含まれているか調べたい」といった場面によく出会います。こうした処理は、実はPythonが最初から用意している文字列メソッドを使えば、たった1行で書けてしまいます。

この記事では、初心者の方がまず覚えておきたい文字列メソッドを、大文字・小文字の変換、空白の除去、置換、検索、判定という目的別に整理して解説します。どれも実務でも頻繁に使う基本ばかりなので、サンプルコードを手元で動かしながら読み進めてみてください。

文字列メソッドとは？

メソッドとは、ある値に対して「.（ドット）」をつけて呼び出せる、その値専用の関数のことです。文字列（str型）に対して使えるメソッドが文字列メソッドで、文字列.メソッド名()という形で書きます。

たとえば "hello".upper() と書くと、「hello という文字列を大文字にする」という意味になり、結果として "HELLO" が返ってきます。とてもシンプルですね。まずは代表的なものから見ていきましょう。

大文字・小文字を変換する（upper / lower / capitalize / title）

英字の大文字・小文字をそろえたいときに使うメソッドです。ユーザーが入力した文字列を比較する前に、小文字にそろえておく、といった用途でよく使います。

text = "Hello, Python"

print(text.upper())        # HELLO, PYTHON
print(text.lower())        # hello, python
print(text.capitalize())   # Hello, python（先頭だけ大文字）
print("python is fun".title())  # Python Is Fun（単語ごとに先頭大文字）

upper()はすべて大文字に、lower()はすべて小文字に変換します。capitalize()は文の先頭だけを大文字に、title()は単語ごとの先頭を大文字にします。目的に合わせて使い分けましょう。

余分な空白を取り除く（strip / lstrip / rstrip）

フォームから受け取った文字列などには、前後に余分な空白が含まれていることがあります。そのまま比較すると意図せず不一致になってしまうため、strip()で除去しておくのが定番です。

s = "   こんにちは   "

print(s.strip())    # こんにちは（前後の空白を除去）
print(s.lstrip())   # 左側の空白だけ除去
print(s.rstrip())   # 右側の空白だけ除去

# 引数を渡すと、指定した文字を端から取り除ける
url = "https://example.com/"
print(url.rstrip("/"))   # https://example.com

引数を渡さなければ空白や改行が対象になりますが、rstrip("/")のように文字を指定すると、その文字を端から取り除けます。URLの末尾スラッシュを消したいときなどに便利です。

文字列を置換する（replace）

文字列の一部を別の文字に置き換えるにはreplace()を使います。第1引数に「置き換え前」、第2引数に「置き換え後」を渡すだけです。カンマや単位を取り除いて数値に変換したいときにも活躍します。

text = "Python は たのしい"
print(text.replace("たのしい", "おもしろい"))
# Python は おもしろい

# カンマや単位を消して数値に変換する
price = "1,000,000円"
num = price.replace(",", "").replace("円", "")
print(int(num) + 500)   # 1000500

replace()は該当する箇所をすべて置き換えます。上の例のように.replace(...).replace(...)とつなげて書くこともできます。文字列を区切り文字で分割・結合したい場合は、splitとjoinを使う方法もあわせて覚えておくと便利です。

文字列を検索する（find / count / in）

特定の文字が「どこにあるか」「いくつあるか」「含まれているか」を調べるメソッドです。

text = "banana"

print(text.find("a"))    # 1（最初に見つかった位置＝インデックス）
print(text.find("z"))    # -1（見つからないと -1 を返す）
print(text.count("a"))   # 3（出現回数）
print("ana" in text)     # True（含まれているかは in が手軽）

find()は最初に見つかった位置を返し、見つからなければ-1を返します。単に「含まれているかどうか」を知りたいだけなら、in演算子を使うほうが直感的で読みやすいです。

文字列を判定する（startswith / endswith / isdigit）

文字列が特定の条件を満たすかどうかを、True／Falseで返してくれるメソッドです。ファイルの拡張子チェックや、入力が数字だけかどうかの確認などに使えます。

print("image.png".endswith(".png"))     # True
print("https://example.com".startswith("https"))  # True
print("12345".isdigit())     # True（数字だけかどうか）
print("Hello".isalpha())     # True（英字だけかどうか）

入力された文字列が数字だけかどうかをisdigit()で確認し、そのうえで整数に変換する、といった使い方が定番です。文字列を数値に変える方法は型変換（キャスト）の記事で詳しく解説しています。

実践：文字列メソッドを組み合わせてみよう

ここまでのメソッドは、組み合わせることで一気に実用的になります。前後の空白を消し、カンマで分割し、必要な部分を大文字にする、という一連の処理を書いてみましょう。

raw = "  Taro,Yamada,Tokyo  "

parts = raw.strip().split(",")   # 空白を消してから分割
print(parts)                     # ['Taro', 'Yamada', 'Tokyo']

name = parts[0].upper()
print(f"氏名: {name}")           # 氏名: TARO

このように、メソッドは「.」でつないで次々と処理を重ねられます。結果を表示するときに使ったf"氏名: {name}"のような書き方については、f文字列（f-string）の使い方で詳しくまとめていますので、あわせてご覧ください。

文字列メソッドを使うときの注意点

文字列メソッドで一番つまずきやすいのが、「メソッドを呼んでも元の文字列は変わらない」という点です。Pythonの文字列はイミュータブル（変更できない）なので、メソッドは新しい文字列を返すだけで、元の変数はそのまま残ります。

text = "python"

text.upper()
print(text)      # python（元の文字列は変わっていない！）

text = text.upper()
print(text)      # PYTHON（代入して初めて反映される）

「変換したはずなのに変わらない」という場合は、この代入を忘れていることがほとんどです。メソッドの戻り値をしっかり変数に受け取るクセをつけておきましょう。

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

文字列メソッドのように、Pythonには覚えると便利な機能がたくさんあります。独学でも十分に学べますが、「エラーの原因が分からず先に進めない」「体系立てて最短で身につけたい」と感じたら、プロに教わるのも有力な選択肢です。

マンツーマン指導のスクールなら、未経験からのPython習得はもちろん、つまずいたその場で質問して解決できるのが強みです。転職サポートが用意されているところも多く、まずは無料カウンセリングで学習プランや費用感を相談してみるとよいでしょう。

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

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

まとめ

今回は、Pythonの基本となる文字列メソッドを目的別に解説しました。最後に要点を振り返っておきましょう。

• upper() / lower()で大文字・小文字を変換できる
• strip()で前後の余分な空白を取り除ける
• replace()で該当箇所をすべて置換できる
• find()やinで文字列を検索・判定できる
• startswith() / endswith() / isdigit()で条件をTrue/Falseで判定できる
• 文字列はイミュータブルなので、メソッドの戻り値は代入して受け取る

文字列メソッドは、データの整形やチェックであらゆる場面に登場する必須スキルです。まずはこの記事のサンプルを実際に動かして、少しずつ手になじませていきましょう。

「input関数で受け取った数値を計算しようとしたらエラーになった…」「数値と文字列をつなげようとしたら怒られた…」Pythonを学び始めた方なら、一度はこんな経験があるのではないでしょうか。

その原因の多くは「データ型の違い」にあります。そして、その解決策となるのが今回のテーマである型変換（キャスト）です。

この記事では、Pythonの型変換の基本であるint・float・str・boolの使い方を、実際に動くコードと実行結果つきで初心者向けに徹底解説します。この記事を読めば、型に関するエラーに自信を持って対処できるようになりますよ。

型変換（キャスト）とは？

型変換（キャスト）とは、あるデータ型の値を別のデータ型に変換することです。たとえば、文字列の”100″を数値の100に変換したり、数値の25を文字列の”25″に変換したりする操作を指します。

Pythonでは、変換したい型の名前をそのまま関数のように使うことで型変換ができます。主に使うのは次の4つです。

• int()：整数に変換する
• float()：小数（浮動小数点数）に変換する
• str()：文字列に変換する
• bool()：真偽値（True / False）に変換する

それでは、1つずつ具体的に見ていきましょう。

数値への変換：int()とfloat()

int()で整数に変換する

int()を使うと、文字列や小数を整数に変換できます。

print(int("100"))   # 100（文字列 → 整数）
print(int(3.9))     # 3（小数点以下は切り捨て）
print(int(-3.9))    # -3（0に近づく方向に切り捨て）

注意したいのは、小数をint()に渡したときの挙動です。四捨五入ではなく小数点以下の切り捨てになるため、3.9は4ではなく3になります。

float()で小数に変換する

float()を使うと、文字列や整数を小数に変換できます。

print(float("3.14"))  # 3.14（文字列 → 小数）
print(float(5))       # 5.0（整数 → 小数）

整数の5をfloat()に渡すと、値としては同じでも「5.0」という小数型のデータになります。

数値に変換できない文字列はエラーになる

int()やfloat()に数値として解釈できない文字列を渡すと、ValueErrorという例外が発生します。

print(int("abc"))
# ValueError: invalid literal for int() with base 10: 'abc'

ユーザーの入力など「何が来るか分からない」データを変換するときは、try-exceptでエラーに備えておくと安全です。

text = "abc"
try:
    num = int(text)
    print(num)
except ValueError:
    print("数値に変換できません")

# 実行結果: 数値に変換できません

try-exceptの詳しい書き方については、例外処理の基本を解説した記事で紹介しているので、あわせて読んでみてください。

文字列への変換：str()

str()を使うと、数値などを文字列に変換できます。よく使うのは、数値と文字列を連結したい場面です。まずは、型変換をしないとどうなるか見てみましょう。

age = 25
print("私は" + age + "歳です")
# TypeError: can only concatenate str (not "int") to str

Pythonでは文字列と数値をそのまま+で連結できないため、TypeErrorが発生します。str()で数値を文字列に変換すれば、正しく連結できます。

age = 25
print("私は" + str(age) + "歳です")
# 実行結果: 私は25歳です

なお、変数の埋め込みが多い場合は、str()を使うよりもf文字列を使ったほうがスッキリ書けます。f文字列（f-string）の使い方を解説した記事も参考にしてみてください。

bool()による真偽値への変換

bool()を使うと、さまざまな値をTrue / Falseの真偽値に変換できます。

print(bool(1))      # True
print(bool(0))      # False
print(bool(""))     # False（空の文字列）
print(bool("abc"))  # True
print(bool([]))     # False（空のリスト）

ポイントは、「空っぽ」や「ゼロ」を表す値はFalse、それ以外はTrueになるというルールです。このルールはif文の条件式でもそのまま使われるので、覚えておくとコードを読む力がグッと上がります。

input関数と型変換の組み合わせ

型変換が最も活躍するのが、input関数と組み合わせる場面です。input関数の戻り値は必ず文字列（str型）になるため、数値として計算したい場合はint()やfloat()での変換が必須です。

num = int(input("数値を入力してください: "))
print(num * 2)

# 入力例: 10
# 実行結果: 20

もしint()を付けずにnum * 2とすると、文字列の繰り返しになってしまい「1010」と表示されてしまいます。これはPython初心者が非常によくつまずくポイントです。input関数の基本については、input関数でキーボード入力を取得する方法の記事で詳しく解説しています。

型を確認するtype関数

「今この変数はどの型なんだろう？」と迷ったら、type関数で確認できます。デバッグの強い味方なので、ぜひ覚えておきましょう。

print(type("100"))       # <class 'str'>
print(type(int("100")))  # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type(True))        # <class 'bool'>

型に関するエラーが出たときは、まずtype関数で変数の型を確認するのが解決への近道です。

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

型変換のような基礎文法は独学でも学べますが、「エラーの原因が自分では分からない」「学習の順番が合っているか不安」と感じる方も多いのではないでしょうか。

そんな方には、マンツーマンで質問しながら学べるプログラミングスクールという選択肢もあります。未経験からのPython習得カリキュラムや転職サポートが用意されており、無料カウンセリングで学習の悩みを相談するだけでも学習計画の参考になりますよ。

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

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

まとめ

今回は、Pythonの型変換（キャスト）について解説しました。要点をまとめます。

• 型変換（キャスト）は、int()・float()・str()・bool()で行う
• int()に小数を渡すと四捨五入ではなく切り捨てになる
• 数値に変換できない文字列を渡すとValueErrorが発生する（try-exceptで対策）
• 数値と文字列を+で連結するときはstr()で文字列に変換する
• input関数の戻り値は必ずstr型なので、計算にはint()やfloat()が必須
• 型に迷ったらtype関数で確認する

型変換はPythonのあらゆる場面で登場する基礎中の基礎です。この記事のコードを実際に手元で動かして、しっかり身につけていきましょう！

リストの中身をまとめて加工したり、条件に合う要素だけを取り出したりする処理は、Pythonのプログラミングで本当によく登場します。そんなとき「for文でループを回して、新しいリストに追加して…」と書くと、どうしてもコードが長くなりがちですよね。

そこで役立つのが map関数 と filter関数 です。この2つを使いこなせると、「全要素を変換する」「条件で絞り込む」といった処理を、たった1行でスッキリ書けるようになります。

この記事では、Python初心者の方に向けて、map関数とfilter関数の基本的な使い方から、2つを組み合わせるテクニック、リスト内包表記との使い分け、そしてつまずきやすい注意点までを、実際に動くコードと実行結果を示しながら丁寧に解説していきます。

map関数とは？

map関数は、リストなどの各要素すべてに、同じ処理（関数）をまとめて適用するための組み込み関数です。「map（マップ）＝対応づける」という名前のとおり、元の要素を一つひとつ別の値へ変換していくイメージですね。

基本の書き方は次のとおりです。

map(適用したい関数, 対象のリストなど)

第1引数に「各要素へ行いたい処理」を関数として渡し、第2引数に「処理したいリスト」を渡します。ここで渡す関数は、名前のない使い捨ての関数であるラムダ式（lambda）で書くことが多いので、あわせて覚えておくと理解がスムーズになります。

map関数の基本的な使い方

リストの各要素を2倍にする

まずはシンプルに、リストのすべての要素を2倍にしてみましょう。

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

# 各要素を2倍にする
result = map(lambda x: x * 2, numbers)

print(list(result))
# 実行結果: [2, 4, 6, 8, 10]

ここで1つ大切なポイントがあります。map関数が返すのはリストそのものではなく「map オブジェクト」と呼ばれるものです。そのため、中身を確認したり普通のリストとして使いたいときは、上のように list() で囲んでリストに変換してあげる必要があります。

自作の関数を渡す

ラムダ式だけでなく、def で定義した自分の関数を渡すこともできます。処理が複雑なときは、こちらのほうが読みやすくなります。

def to_celsius(f):
    return (f - 32) * 5 / 9

fahrenheit = [32, 68, 104]

# 華氏を摂氏に変換する
celsius = map(to_celsius, fahrenheit)

print(list(celsius))
# 実行結果: [0.0, 20.0, 40.0]

華氏の温度が入ったリストを、まとめて摂氏に変換できました。for文を書かずに、リスト全体へ一気に関数を適用できるのがmap関数の魅力です。

複数のリストを同時に処理する

map関数には、リストを複数渡すこともできます。その場合は、それぞれのリストから同じ位置の要素を取り出して関数に渡してくれます。複数のリストを同時に扱うという意味ではzip関数と似ていますが、mapは同時に変換までしてくれるのが特徴です。

a = [1, 2, 3]
b = [10, 20, 30]

# 2つのリストの要素を足し合わせる
result = map(lambda x, y: x + y, a, b)

print(list(result))
# 実行結果: [11, 22, 33]

filter関数とは？

filter関数は、リストなどの要素の中から、条件に合うものだけを取り出す（絞り込む）ための組み込み関数です。「filter（フィルター）＝ろ過する」という名前のとおり、条件というフィルターを通して、必要な要素だけを残すイメージです。

基本の書き方は次のとおりです。

filter(条件を判定する関数, 対象のリストなど)

第1引数には、要素を1つ受け取って True か False を返す関数を渡します。判定の結果が True になった要素だけが残る、というのがfilterの仕組みです。

filter関数の基本的な使い方

偶数だけを取り出す

リストの中から偶数だけを取り出してみましょう。2で割った余りが0なら偶数、という条件で判定します。

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

# 偶数（2で割り切れる数）だけを取り出す
result = filter(lambda x: x % 2 == 0, numbers)

print(list(result))
# 実行結果: [2, 4, 6]

map関数と同じく、filter関数が返すのも「filter オブジェクト」です。中身を確認するときは list() でリストに変換しましょう。

空文字や0を取り除く（第1引数に None）

filter関数の第1引数に、関数ではなく None を渡すと、「それ自体が偽（False扱い）となる要素」を自動的に取り除いてくれます。空文字や0、空のリストなどを一気に掃除したいときに便利です。

words = ["apple", "", "banana", "", "cherry"]

# 空文字を取り除く
result = filter(None, words)

print(list(result))
# 実行結果: ['apple', 'banana', 'cherry']

map関数とfilter関数を組み合わせる

map関数とfilter関数は、組み合わせて使うこともできます。たとえば「偶数だけを取り出して、さらにそれを2乗する」という処理は、次のように書けます。

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

# 偶数だけを取り出して（filter）、それぞれを2乗する（map）
result = map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers))

print(list(result))
# 実行結果: [4, 16, 36, 64, 100]

内側の filter で偶数（2, 4, 6, 8, 10）に絞り込み、その結果を外側の map で2乗しています。ネスト（入れ子）になっていて少し読みにくいので、実際のコードでは処理ごとに変数に分けて書くと、より分かりやすくなります。

リスト内包表記との使い分け

ここまで読んで「あれ、これってリスト内包表記でも同じことができるのでは？」と気づいた方もいるかもしれません。そのとおりで、map関数とfilter関数の処理は、リスト内包表記でも書けます。

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

# map / filter を使った書き方
result1 = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numbers)))

# リスト内包表記を使った書き方
result2 = [x * 2 for x in numbers if x % 2 == 0]

print(result1)  # [4, 8, 12]
print(result2)  # [4, 8, 12]

どちらを使っても結果は同じです。一般的に、Pythonでは「シンプルで読みやすい」という理由から、リスト内包表記のほうが好まれる場面が多くなっています。一方で、すでに定義済みの関数をそのまま適用したいときは、map関数を使うとスッキリ書けることもあります。まずは両方の書き方を知っておき、状況に応じて読みやすいほうを選べるようにしておくと安心です。

map・filterを使うときの注意点

最後に、初心者の方がつまずきやすいポイントを1つ紹介します。map関数やfilter関数が返すオブジェクトは「イテレータ」と呼ばれるもので、一度中身を取り出すと、2回目は空になってしまうという性質があります。

numbers = [1, 2, 3]
result = map(lambda x: x * 2, numbers)

print(list(result))  # [2, 4, 6]
print(list(result))  # [] ← 2回目は空になる！

このように、同じ result を2回 list() で取り出すと、2回目は空のリストになってしまいます。結果を何度も使い回したいときは、最初に list() でリストへ変換して変数に入れておくのがおすすめです。

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

map関数やfilter関数のように、Pythonには「知っていると一気に世界が広がる」便利な機能がたくさんあります。とはいえ、独学だけで進めていると「この書き方で合っているのかな？」「もっと良いやり方があるのでは？」と、つまずいたり不安になったりすることも多いですよね。

そんなときは、プロの講師にマンツーマンで教えてもらえるプログラミングスクールを活用するのも一つの手です。未経験からPythonを習得したい方や、エンジニアへの転職を目指す方に向けて、転職サポートまで用意されているスクールもあります。まずは無料カウンセリングで、自分に合った学び方を相談してみるとイメージがつかみやすいですよ。

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

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

まとめ

今回は、Pythonのmap関数とfilter関数について解説しました。最後に要点を振り返っておきましょう。

• map関数は、リストなどの各要素すべてに同じ処理をまとめて適用する関数
• filter関数は、条件に合う要素だけを取り出して絞り込む関数
• どちらも返り値はリストではないので、list() でリストに変換して使う
• map と filter は組み合わせて「絞り込み＋変換」もできる
• 同じ処理はリスト内包表記でも書けるので、読みやすいほうを選ぶとよい
• 返り値のイテレータは一度取り出すと空になるため、使い回すときは先にリスト化しておく

map関数とfilter関数を使いこなせると、ループ処理をより短く、読みやすく書けるようになります。ぜひ手元のコードで実際に動かして、感覚をつかんでみてくださいね。

Pythonでプログラムを書いていると、「今日の日付を取得したい」「2つの日付の差を計算したい」「日付を見やすい形に整えたい」といった場面によく出くわします。こうした日付・時刻の処理をまとめて引き受けてくれるのが、標準ライブラリのdatetimeモジュールです。

この記事では、datetimeモジュールの基本的な使い方を、初心者の方にも分かりやすいように一つずつ丁寧に解説していきます。現在時刻の取得から、文字列との相互変換、日付の計算まで、実際に動くコードと実行結果を見ながら学んでいきましょう。

datetimeモジュールとは？

datetimeは、日付や時刻を扱うためにPythonに標準で用意されているモジュールです。追加のインストールは不要で、importするだけですぐに使えます。よく使うのは次の4つのクラスです。

• datetime：日付と時刻の両方を扱う
• date：日付（年・月・日）だけを扱う
• time：時刻（時・分・秒）だけを扱う
• timedelta：日数や時間の「差」を扱う

名前が少しややこしいですが、「モジュール名のdatetime」の中に「クラス名のdatetime」がある、という点だけ最初に押さえておくと混乱しません。それでは実際に使っていきましょう。

現在の日付・時刻を取得する

まずは一番よく使う「今この瞬間」の取得です。日付と時刻の両方が欲しいときはdatetime.now()、日付だけで十分なときはdate.today()を使います。

from datetime import datetime, date

now = datetime.now()
print(now)          # 2026-06-29 10:30:45.123456
print(now.year)     # 2026
print(now.month)    # 6
print(now.hour)     # 10

today = date.today()
print(today)        # 2026-06-29

取得したdatetimeオブジェクトは、.yearや.month、.hourのように属性へアクセスするだけで、年・月・日・時・分・秒をそれぞれ取り出せます。とてもシンプルですね。

好きな日付・時刻を自分で作る

「特定の日付」を表すオブジェクトを作りたいときは、年・月・日などを直接指定します。引数は左から年、月、日、時、分、秒の順で、時刻部分を省略すると0時0分0秒になります。

from datetime import datetime, date

dt = datetime(2026, 12, 25, 18, 30, 0)
print(dt)            # 2026-12-25 18:30:00

d = date(2026, 1, 1)
print(d)             # 2026-01-01
print(d.weekday())   # 3  （0=月曜, 6=日曜なので木曜日）

weekday()メソッドを使うと曜日を数字で取得できます。月曜日が0、日曜日が6です。「その日が何曜日か」を判定したいときに便利なので覚えておきましょう。

日付を見やすい文字列に変換する（strftime）

datetimeオブジェクトをそのままprintすると「2026-06-29 10:30:45.123456」のような形式になります。これを「2026年6月29日」のように好きな形へ整えるのがstrftime()メソッドです。書式コード（%Yなど）を組み合わせて指定します。

from datetime import datetime

now = datetime(2026, 6, 29, 9, 5, 30)
print(now.strftime('%Y/%m/%d'))        # 2026/06/29
print(now.strftime('%Y年%m月%d日'))     # 2026年06月29日
print(now.strftime('%H:%M:%S'))        # 09:05:30
print(now.strftime('%Y-%m-%d %H:%M'))  # 2026-06-29 09:05

よく使う書式コードを下にまとめました。

• %Y：西暦4桁（例: 2026）
• %m：月の2桁（例: 06）
• %d：日の2桁（例: 29）
• %H：24時間表記の時（例: 09）
• %M：分（例: 05）
• %S：秒（例: 30）

なお、同じ書式指定はf文字列の中でも使えます。f'{now:%Y/%m/%d}'のように書くと、よりすっきりとした記述になります。f文字列そのものの使い方は【Python】f文字列（f-string）の使い方を初心者向けに徹底解説！で詳しく紹介していますので、あわせて読んでみてください。

文字列を日付に変換する（strptime）

逆に、「2026-06-29」のような文字列をdatetimeオブジェクトに変換したいこともあります。たとえばCSVファイルやフォームから受け取った日付は最初は文字列です。これを変換するのがstrptime()です。元の文字列がどんな形式かを書式コードで教えてあげるのがポイントです。

from datetime import datetime

text = '2026-06-29 09:05:30'
dt = datetime.strptime(text, '%Y-%m-%d %H:%M:%S')
print(dt)          # 2026-06-29 09:05:30
print(dt.month)    # 6
print(type(dt))    # <class 'datetime.datetime'>

文字列のままでは日付の計算ができませんが、strptime()でdatetimeに変換しておけば、このあと紹介する日付の足し算・引き算ができるようになります。strftime（出力用）とstrptime（入力用）は名前が似ているので、「p = parse（読み取り）」と覚えると区別しやすいですよ。

日付の差・加算・減算（timedelta）

「3日後の日付は？」「2つの日付は何日離れている？」といった計算にはtimedeltaを使います。datetime同士を引き算するとtimedeltaが返り、.daysで日数を取り出せます。

from datetime import datetime, timedelta

now = datetime(2026, 6, 29)
print(now + timedelta(days=7))    # 2026-07-06 00:00:00
print(now - timedelta(days=30))   # 2026-05-30 00:00:00

start = datetime(2026, 1, 1)
end = datetime(2026, 6, 29)
diff = end - start
print(diff.days)   # 179

timedeltaにはdaysのほかhoursやminutes、weeksも指定できます。たとえばtimedelta(weeks=2)で2週間後を求められます。日付を1日ずつずらしながら処理したいときは、for文・range関数と組み合わせると便利です。繰り返し処理に不安がある方はPythonのfor文・range関数を攻略！これを知れば基本的な処理ができる使い方9選！を先に読んでおくとスムーズです。

また、計算した日付を一覧として持っておきたい場合は、結果をリストにためていくと扱いやすくなります。リストへの追加方法はPythonでリストに要素を追加する方法【append, extend, insert】（スライス）で解説していますので参考にしてください。

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

ここまでdatetimeの使い方を見てきましたが、「独学だとつまずいたときに質問できる相手がいない」「実務で使えるレベルまで体系的に学びたい」と感じる方も多いのではないでしょうか。そんなときは、マンツーマン指導が受けられるプログラミングスクールを活用するのも一つの手です。未経験からのPython習得や転職サポートに対応したスクールも多く、まずは無料カウンセリングで学習プランを相談してみると、自分に合った進め方が見えてきます。

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

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

まとめ

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

• 現在の日時はdatetime.now()、今日の日付はdate.today()で取得できる
• 年・月・日などは.yearのような属性で取り出せる
• strftime()で日付を好きな文字列の書式に変換できる
• strptime()で文字列をdatetimeに変換できる（p=parseと覚える）
• timedeltaで日付の加算・減算や差の計算ができる

datetimeは、ログの記録や期限の計算、データ集計など実務でも頻繁に登場する重要なモジュールです。まずは現在時刻の取得とstrftimeでの書式変換から、ぜひ手を動かして試してみてくださいね。