リストの中身をまとめて加工したり、条件に合う要素だけを取り出したりする処理は、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での書式変換から、ぜひ手を動かして試してみてくださいね。

「ファイルを開いたあとにclose()を書き忘れてしまった」「サンプルコードに出てくるwithって結局なに？」——Pythonを学び始めると、こんな疑問にぶつかる方は多いのではないでしょうか。実はこのwith構文（withステートメント）を使うと、ファイルの後始末を自動でやってくれて、コードもぐっと読みやすくなります。

この記事では、Pythonのwith構文について、基本的な書き方からファイルの読み書き、withを使わない場合との違い、そして裏側で動いている「コンテキストマネージャ」の仕組みまで、初心者の方にも分かりやすく解説していきます。

with構文（withステートメント）とは？

with構文とは、「開始」と「終了」がセットになっている処理を、安全に・自動的に後始末してくれる仕組みです。もっとも代表的な使いどころがファイル操作です。ファイルは「開いたら必ず閉じる」必要がありますが、withを使うとブロックを抜けるときに自動でファイルが閉じられます。

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

with open("sample.txt", "r", encoding="utf-8") as f:
    data = f.read()
    print(data)

# ここに来た時点で、ファイルfは自動的に閉じられている

withのうしろに「開始する処理」（ここではopen()）を書き、asのうしろにその結果を受け取る変数（ここではf）を書きます。インデントされたブロックの中だけファイルが開いていて、ブロックを抜けると自動的に閉じられる、というのがポイントです。

ファイルを読み込んでみよう

それでは実際にファイルを読み込んでみましょう。open()の第2引数"r"は「読み込みモード（read）」を表します。1行ずつ処理したい場合は、for文でファイルオブジェクトをそのままループできます。

# sample.txt の中身を1行ずつ表示する
with open("sample.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # strip()で行末の改行を除去

# 実行結果（sample.txtの中身が出力される）
# Python
# with構文
# 便利です

ファイルを1行ずつ読み込んでfor文で回す処理は、Pythonの基本中の基本です。for文の使い方そのものに不安がある方は、Pythonのfor文・range関数の使い方もあわせて読んでみてください。また、CSVファイルからデータを読み込む実践例はPythonでWebページの見出しを抽出する方法（CSVファイルの扱いも解説）で紹介しています。

ファイルに書き込んでみよう

書き込みたいときは、モードを"w"（write）にします。"w"は既存の内容を上書きするモード、"a"（append）は末尾に追記するモードです。

# sample.txt に書き込む（既存の内容は上書きされる）
with open("sample.txt", "w", encoding="utf-8") as f:
    f.write("1行目のテキスト
")
    f.write("2行目のテキスト
")

# 末尾に追記したい場合はモードを "a" にする
with open("sample.txt", "a", encoding="utf-8") as f:
    f.write("追記された行
")

書き込む文字列に変数の値を埋め込みたいときは、f文字列を使うと便利です。f文字列の詳しい使い方はf文字列（f-string）の使い方で解説していますので、あわせてチェックしてみてください。

with構文を使わない場合との違い

withを使わずに同じことを書くと、次のようになります。自分でclose()を呼ばなければならない点に注目してください。

# withを使わない書き方（おすすめしません）
f = open("sample.txt", "r", encoding="utf-8")
data = f.read()
f.close()  # 閉じ忘れに注意！

この書き方には弱点があります。もしf.read()の途中でエラーが発生すると、f.close()が実行されず、ファイルが開きっぱなしになってしまうのです。これを防ぐには本来try〜finallyでしっかり閉じる必要があります。

# try〜finallyで確実に閉じる書き方
f = open("sample.txt", "r", encoding="utf-8")
try:
    data = f.read()
finally:
    f.close()  # エラーが起きても必ず閉じられる

with構文は、このtry〜finallyと同じ「必ず後始末する」働きを、たった1行でやってくれているわけです。エラー処理そのものについて詳しく知りたい方は、Pythonの例外処理（try-except）の使い方もぜひ読んでみてください。

複数のファイルを同時に開く

1つのwithで複数のファイルを同時に開くこともできます。カンマで区切って並べるだけです。あるファイルを読み込んで、別のファイルに書き出す、といった処理がすっきり書けます。

# input.txtを読み込んでoutput.txtにコピーする
with open("input.txt", "r", encoding="utf-8") as fr, \
     open("output.txt", "w", encoding="utf-8") as fw:
    for line in fr:
        fw.write(line)

# どちらのファイルもブロックを抜けると自動で閉じられる

with構文が動く仕組み（コンテキストマネージャ）

少し発展的な話になりますが、withが使えるオブジェクトには「コンテキストマネージャ」という共通のルールがあります。具体的には、__enter__（開始時の処理）と__exit__（終了時の処理）という2つのメソッドを持っているオブジェクトです。

withブロックに入るときに__enter__が、ブロックを抜けるときに__exit__が自動的に呼ばれます。ファイルのclose()は、この__exit__の中で実行されているのです。自分でクラスを作って__enter__と__exit__を定義すれば、独自のwith対応オブジェクトを作ることもできます。

class Timer:
    def __enter__(self):
        print("処理を開始します")
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        print("処理を終了します")

with Timer():
    print("メインの処理")

# 実行結果:
# 処理を開始します
# メインの処理
# 処理を終了します

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

ここまでwith構文を解説してきましたが、「独学だとつまずいたときに質問できる相手がいなくて不安…」という方も多いと思います。そんなときは、プロの講師にマンツーマンで教えてもらえるプログラミングスクールを活用するのも一つの方法です。未経験からのPython習得や転職サポート、無料カウンセリングを用意しているスクールも多く、自分の理解度に合わせて効率よく学べます。まずは無料カウンセリングで学習プランだけ相談してみるのもおすすめです。

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

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

まとめ

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

• with構文は「開始」と「終了」がセットの処理を安全に扱える仕組みで、ファイル操作で特によく使う
• with open(...) as f: と書くと、ブロックを抜けるときに自動でファイルが閉じられる
• モードは読み込み"r"・上書き"w"・追記"a" を使い分ける
• withはtry〜finallyと同じ「必ず後始末する」働きを1行で実現してくれる
• カンマで区切れば複数ファイルを同時に開ける
• 裏側では__enter__と__exit__を持つ「コンテキストマネージャ」が動いている

with構文を使いこなせるようになると、ファイル操作のコードが安全で読みやすくなります。ぜひ実際に手を動かして、ファイルの読み書きを試してみてくださいね。

Pythonでプログラムを書いていると、「条件によって変数に入れる値を変えたい」という場面がよくありますよね。そんなときにif文を使うと、たった1つの値を出し分けるだけなのに4行も書くことになり、「ちょっと面倒だな…」と感じたことはありませんか？

そんなときに便利なのが三項演算子（条件式）です。三項演算子を使うと、if-else文を1行でスッキリ書くことができます。この記事では、三項演算子の基本構文から、ネストのさせ方、リスト内包表記やf文字列と組み合わせる実用テクニック、そして使うときの注意点までを、初心者の方にも分かりやすく丁寧に解説していきます。

三項演算子（条件式）とは？

三項演算子とは、条件によって2つの値のうちどちらかを返す書き方のことです。Pythonの公式ドキュメントでは「条件式（conditional expression）」と呼ばれています。多くのプログラミング言語には 条件 ? 値1 : 値2 という記号を使った三項演算子がありますが、Pythonでは if と else という英単語を使って書くのが特徴です。読み下すように自然に書けるので、慣れるととても便利ですよ。

三項演算子の基本の書き方

Pythonの三項演算子は、次のような構文で書きます。「条件が真のときは値1を、そうでなければ値2を返す」という意味です。

# 三項演算子の基本構文
# 値1 if 条件 else 値2

score = 80
result = "合格" if score >= 60 else "不合格"
print(result)
# 実行結果: 合格

左から「"合格"（条件が真のときの値）」「if score >= 60（条件）」「else "不合格"（条件が偽のときの値）」という順番です。英語の文章のように「合格、ただし60点以上ならね、そうでなければ不合格」と読むとイメージしやすいかもしれません。

if-else文との違いを比較してみよう

同じ処理を通常のif-else文で書いた場合と比べてみましょう。三項演算子を使うと、4行の処理が1行にまとまることが分かります。

score = 50

# 通常のif-else文（4行）
if score >= 60:
    result = "合格"
else:
    result = "不合格"

# 三項演算子（1行）
result = "合格" if score >= 60 else "不合格"
print(result)
# 実行結果: 不合格

このように、「条件に応じて変数へ代入する値を切り替えるだけ」のシンプルな処理であれば、三項演算子のほうがコードが短く読みやすくなります。条件分岐そのものの基本をおさらいしたい方は、if文と演算子（not, in）の使い方を解説した記事もあわせて読んでみてください。

数値の大小を比較して使ってみる

三項演算子は、2つの数値のうち大きいほう（または小さいほう）を取り出すといった処理にも使えます。

a = 10
b = 25
big = a if a > b else b
print(big)
# 実行結果: 25

a > b が偽（10は25より大きくない）なので、else 側の b が代入されます。組み込みの max() 関数でも同じことができますが、条件を自由に書けるのが三項演算子の強みです。

三項演算子をネストして使う（elif相当）

三項演算子は入れ子（ネスト）にすることもできます。これによって、if-elif-else のような3つ以上の分岐を1行で表現できます。

score = 75
grade = "A" if score >= 80 else "B" if score >= 60 else "C"
print(grade)
# 実行結果: B

左から順に条件が判定され、最初に真になった値が返されます。ただし、ネストを深くしすぎるとかえって読みにくくなるので、2段までを目安にするのがおすすめです。

三項演算子の実用的な使い方

リスト内包表記と組み合わせる

三項演算子はリスト内包表記の中でもよく使われます。リストの各要素を条件によって変換したいときにとても便利です。

nums = [1, 2, 3, 4, 5]
labels = ["偶数" if n % 2 == 0 else "奇数" for n in nums]
print(labels)
# 実行結果: ['奇数', '偶数', '奇数', '偶数', '奇数']

リスト内包表記そのものの書き方を詳しく知りたい方は、リスト内包表記の使い方を解説した記事を参考にしてください。内包表記と三項演算子を組み合わせられるようになると、データ処理のコードがぐっと短く書けるようになりますよ。

f文字列の中で使う

三項演算子はf文字列（f-string）の波括弧の中でも使えます。表示するメッセージを条件によって切り替えたいときに役立ちます。

count = 0
msg = f"通知が{count}件{'あります' if count > 0 else 'ありません'}"
print(msg)
# 実行結果: 通知が0件ありません

f文字列の中で三項演算子を使うときは、内側の文字列のクォートと外側のクォートが衝突しないように注意しましょう。f文字列の基本的な使い方については、f文字列（f-string）の使い方を徹底解説した記事で詳しく紹介しています。

三項演算子を使うときの注意点

便利な三項演算子ですが、使いどころを間違えるとかえってコードが読みにくくなります。次の点に気をつけましょう。

• 複雑な処理には使わない：条件や値が長くなる場合は、素直に通常のif-else文で書いたほうが読みやすくなります。
• ネストは深くしすぎない：三項演算子を何段も重ねると、どこで何を判定しているのか分かりにくくなります。
• あくまで「値を返す」ための構文：三項演算子は値を返す式なので、ループや関数呼び出しなどの「処理」を分岐させたい場合は通常のif文を使いましょう。

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

三項演算子のような細かい文法は、実際に手を動かしてコードを書きながら覚えるのが一番の近道です。とはいえ、独学だと「この書き方で合っているのかな？」「エラーの原因が分からない…」と手が止まってしまうこともありますよね。

もし本気でPythonを身につけて、未経験からエンジニア転職まで目指したいなら、マンツーマン指導が受けられるプログラミングスクールを活用するのも一つの手です。プロの講師に直接質問できる環境があると、つまずきをすぐに解消できて学習効率が大きく上がります。無料カウンセリングを実施しているスクールも多いので、まずは話を聞いてみて、自分に合うか確かめてみるとよいでしょう。

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

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

まとめ

今回は、Pythonの三項演算子（条件式）について解説しました。最後に要点を振り返っておきましょう。

• 三項演算子は 値1 if 条件 else 値2 の形で書き、if-else文を1行にまとめられる。
• 数値の大小比較や、条件によって変数の値を出し分ける処理に便利。
• ネストすれば elif 相当の3分岐も書けるが、深くしすぎないこと。
• リスト内包表記やf文字列の中でも活用でき、コードを短くスッキリ書ける。
• 複雑な処理には無理に使わず、通常のif文と使い分けるのがコツ。

三項演算子を使いこなせるようになると、Pythonのコードがぐっと洗練されます。ぜひ実際に手を動かして試してみてくださいね。

「名前のリストと点数のリスト、この2つを同時にループ処理したいんだけど、どう書けばいいんだろう？」Pythonを学び始めると、こんな場面に出会うことがありますよね。インデックス番号を使ってforループを回す方法もありますが、コードが少し読みにくくなりがちです。

そんなときに大活躍するのが、今回ご紹介するzip（ジップ）関数です。複数のリストをまるでジッパー（チャック）のようにかみ合わせて、1つにまとめてくれる便利な組み込み関数です。

この記事では、Pythonのzip関数について、基本的な使い方から、辞書への変換、要素数が異なる場合の挙動、そして元のリストに戻す「unzip」のテクニックまで、初心者の方にも分かりやすく丁寧に解説していきます。サンプルコードと実行結果を見ながら、一緒にマスターしていきましょう。

zip関数とは？複数のリストをまとめる組み込み関数

zip関数は、複数のリストやタプルなどから要素を先頭から順番に1つずつ取り出し、それらをペア（組）にしてまとめてくれる組み込み関数です。名前のとおり、ジッパーで2つの列をかみ合わせて1本にするイメージを持つと分かりやすいですね。

zip関数を使うと、複数のリストを同時にループ処理できるため、for文をとてもすっきりと書けるようになります。なお、zipが取り出すペアはタプル(tuple)という形式になっている点も、あわせて覚えておきましょう。

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

for 変数1, 変数2 in zip(リスト1, リスト2):
    # 処理

zip関数の基本的な使い方

2つのリストを同時にループする

まずは、名前のリストと点数のリストを同時にループしてみましょう。

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92, 78]

for name, score in zip(names, scores):
    print(f"{name}さんの点数は{score}点です")

# 実行結果
# 田中さんの点数は85点です
# 佐藤さんの点数は92点です
# 鈴木さんの点数は78点です

zip(names, scores)とすることで、namesとscoresから同じ位置の要素がペアになって取り出されます。1回目のループではnameに「田中」、scoreに85が入る、という具合ですね。とても直感的に書けるのが分かると思います。

インデックスを使う方法と比べてみよう

もしzipを使わずに同じ処理を書くと、次のようにインデックス番号を使うことになります。

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92, 78]

for i in range(len(names)):
    print(f"{names[i]}さんの点数は{scores[i]}点です")

この書き方でも動きますが、names[i]やscores[i]のように毎回インデックスを指定する必要があり、少し読みにくくなりますよね。zipを使えばインデックスを意識せずに済むため、コードがぐっとシンプルになります。range関数を使ったfor文の基本については、Pythonのfor文・range関数を攻略！の記事でくわしく解説しているので、あわせて読んでみてください。

3つ以上のリストもまとめられる

zip関数は2つだけでなく、3つ以上のリストを同時にまとめることもできます。

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92, 78]
subjects = ["数学", "英語", "国語"]

for name, subject, score in zip(names, subjects, scores):
    print(f"{name}さんの{subject}は{score}点です")

# 実行結果
# 田中さんの数学は85点です
# 佐藤さんの英語は92点です
# 鈴木さんの国語は78点です

リストの数だけ受け取る変数を増やせば、いくつでもまとめてループできます。とても柔軟ですね。

zip関数の結果をリストや辞書に変換する

zip関数が返すのは「zipオブジェクト」と呼ばれるイテレータで、そのままprintしても中身は表示されません。中身を確認したり再利用したりするには、list()やdict()で変換するのが基本です。

list()でリストに変換する

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92, 78]

pairs = list(zip(names, scores))
print(pairs)

# 実行結果
# [("田中", 85), ("佐藤", 92), ("鈴木", 78)]

list()で変換すると、ペアが1つずつタプルになったリストが得られます。こうしたペアのリストは、リスト内包表記と組み合わせて加工するのもおすすめです。

dict()で辞書を作る

名前をキー、点数を値にしたいときは、dict()を使うと一発で辞書が作れます。

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92, 78]

score_dict = dict(zip(names, scores))
print(score_dict)

# 実行結果
# {"田中": 85, "佐藤": 92, "鈴木": 78}

2つのリストから辞書を作りたい場面はとても多いので、この書き方は覚えておくと便利です。作った辞書の操作方法については辞書(dict)の使い方を徹底解説の記事も参考にしてください。

要素数が違うとどうなる？

zipに渡すリストの要素数がそろっていない場合は、一番短いリストに合わせてループが止まります。

names = ["田中", "佐藤", "鈴木"]
scores = [85, 92]  # 2つしかない

for name, score in zip(names, scores):
    print(name, score)

# 実行結果
# 田中 85
# 佐藤 92
# （鈴木は対応する点数がないため無視される）

「鈴木」さんは対応する点数がないため、ループの対象になりません。エラーにはならず静かに切り捨てられるので、要素数がずれていないか注意しましょう。なお、短い方に合わせず長い方に合わせたいときは、標準ライブラリのitertools.zip_longestを使う方法もあります。

zip(*)で元のリストに戻す（unzip）

ペアになったリストを、もう一度それぞれのリストに分解したいときは、アスタリスク(*)を付けてzip(*)とします。いわゆる「unzip（アンジップ）」です。

pairs = [("田中", 85), ("佐藤", 92), ("鈴木", 78)]

names, scores = zip(*pairs)
print(names)   # ("田中", "佐藤", "鈴木")
print(scores)  # (85, 92, 78)

zip(*pairs)とすることで、各ペアの1番目どうし・2番目どうしがまとめ直されます。返ってくるのはリストではなくタプルになる点に注意してください。リストにしたい場合はlist()で包んであげましょう。

zip関数を使うときの注意点

• zipオブジェクトはイテレータなので、一度for文で回すと中身が消費され、2回目は空になります。
• 繰り返し使いたいときは、list()でリストに変換してから保存しておきましょう。
• 要素数が異なるリストを渡すと、もっとも短いリストに合わせて切り捨てられます。
• 取り出されるペアはタプルなので、値を書き換えたい場合はリストに変換する必要があります。

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

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

zip関数のように、Pythonには知っているだけでコードがぐっと書きやすくなる機能がたくさんあります。とはいえ、独学だと「これで合っているのかな？」と不安になったり、エラーの原因が分からず手が止まってしまったりすることもありますよね。

そんなときは、プロの講師にマンツーマンで教えてもらえるプログラミングスクールを活用するのも一つの手です。下記の「Python Winner」は、未経験からのPython習得や転職サポートに対応しており、まずは無料カウンセリングで学習プランを相談できます。本気でエンジニアを目指したい方は、選択肢として検討してみてはいかがでしょうか。

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

まとめ

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

• zip関数は複数のリストの要素をペアにまとめ、同時にループ処理できる組み込み関数。
• for name, score in zip(names, scores): のように書くと、インデックスを使わずスッキリ書ける。
• 3つ以上のリストもまとめられる。
• list()でタプルのリストに、dict()で辞書に変換できる。
• 要素数が違う場合は、一番短いリストに合わせて切り捨てられる。
• zip(*pairs)で元のリストに分解（unzip）できる（返り値はタプル）。
• zipオブジェクトはイテレータなので、繰り返し使うならlist()で保存する。

zip関数を使いこなせると、複数のデータをまとめて扱う処理がとても書きやすくなります。ぜひ実際に手を動かして試してみてくださいね。最後までお読みいただき、ありがとうございました。

Pythonでリストの中身を「小さい順に並べたい」「点数の高い順にランキングを作りたい」と思ったことはありませんか？そんなときに使うのが sort と sorted です。名前がそっくりなので、初心者の方は「どっちを使えばいいの？」と迷いがちですよね。

この記事では、Pythonの sort メソッドと sorted 関数の違いから、基本的な使い方、降順での並び替え、key 引数を使った応用テクニックまで、初心者の方にも分かりやすく丁寧に解説します。読み終えるころには、リストの並び替えを自由自在に扱えるようになっているはずです。

sortとsortedの違いをまず押さえよう

どちらも「並び替え（ソート）」を行うものですが、いちばん大きな違いは元のデータを書き換えるかどうかです。

• list.sort()：リスト自身を並び替える（元のリストが変わる）。戻り値は None。
• sorted(リスト)：並び替えた新しいリストを返す（元のリストはそのまま）。

「元のデータを残しておきたいなら sorted」「元のリストをそのまま並び替えてしまってよいなら sort」と覚えておくと迷いません。それぞれ詳しく見ていきましょう。

list.sort()の使い方

基本：小さい順（昇順）に並び替える

sort() はリストが持つメソッドなので、リスト.sort() の形で呼び出します。引数を指定しなければ、数値は小さい順（昇順）に並び替えられます。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()
print(numbers)
# 実行結果: [1, 1, 2, 3, 4, 5, 6, 9]

ここで注意したいのが、sort() の戻り値は None だという点です。new = numbers.sort() のように書いても new には None が入ってしまうので、結果を変数に代入しないよう気をつけましょう。

降順（大きい順）に並び替える

大きい順に並べたいときは、reverse=True を指定します。

scores = [55, 90, 73, 12, 88]
scores.sort(reverse=True)
print(scores)
# 実行結果: [90, 88, 73, 55, 12]

sorted()の使い方

基本：元のリストを変えずに並び替える

sorted() は組み込み関数なので、sorted(リスト) の形で使います。並び替えた結果を新しいリストとして返し、元のリストはそのまま残るのが特徴です。

original = [3, 1, 2]
result = sorted(original)
print(result)    # [1, 2, 3]
print(original)  # [3, 1, 2] ← 元のリストはそのまま

元のデータを保持したまま、並び替えたバージョンも欲しい——そんな場面では sorted() がぴったりです。なお sorted() も reverse=True で降順にできます。

ちなみに、リストを加工して新しいリストを作る方法としてはリスト内包表記もよく使われます。並び替えと組み合わせると、より柔軟にデータを処理できるので、あわせて読んでみてください。

key引数で並び替えの基準を自由に決める

sort() も sorted() も、key 引数を指定することで「何を基準に並び替えるか」を自由に決められます。たとえば文字列を「長さ順」に並べたいときは、key=len と書きます。

words = ["banana", "apple", "fig", "cherry"]
sorted_words = sorted(words, key=len)
print(sorted_words)
# 実行結果: ['fig', 'apple', 'banana', 'cherry']

さらに key に無名関数（ラムダ式）を渡せば、もっと細かい基準を指定できます。次の例は、(名前, 点数) のタプルのリストを「点数の高い順」に並び替えています。

students = [("佐藤", 80), ("鈴木", 65), ("田中", 92)]
students.sort(key=lambda x: x[1], reverse=True)
print(students)
# 実行結果: [('田中', 92), ('佐藤', 80), ('鈴木', 65)]

lambda x: x[1] は「各要素の2番目（インデックス1）の値を基準にする」という意味です。ラムダ式そのものについてはラムダ式（無名関数）の解説記事でくわしく説明しているので、まだ自信がない方はこちらもチェックしてみてください。

辞書を並び替える

辞書（dict）そのものは順番を並び替えるというより、items() で取り出した「キーと値のペア」を sorted() で並び替えるのが定番です。次の例は、科目ごとの点数を「点数の高い順」にランキング化しています。

scores = {"math": 80, "english": 95, "science": 70}
ranking = sorted(scores.items(), key=lambda x: x[1], reverse=True)
print(ranking)
# 実行結果: [('english', 95), ('math', 80), ('science', 70)]

辞書の作り方やループ処理の基本をおさらいしたい方は、辞書(dict)の使い方を徹底解説した記事もあわせてどうぞ。items() の動きが分かると、上のコードがぐっと理解しやすくなります。

よくあるエラーと注意点

初心者がつまずきやすいのが、異なる型が混ざったリストを並び替えようとするケースです。数値と文字列が混在していると、比較できずにエラーになります。

mixed = [1, "2", 3]
mixed.sort()
# TypeError: '<' not supported between instances of 'str' and 'int'

このエラーが出たときは、リストの中身の型がそろっているかを確認しましょう。数値として並べたいなら int() で数値に変換する、といった前処理が必要です。

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

sort や sorted のように「使えると便利だけど、独学だと細かい使い分けでつまずきやすい」機能はたくさんあります。本やネットの情報だけで進めていると、エラーの原因が分からず時間だけが過ぎてしまう……というのは、未経験からPythonを学ぶ多くの人が経験する壁です。

もし「誰かに直接質問しながら、最短でPythonを身につけたい」と感じているなら、マンツーマン指導が受けられるプログラミングスクールを検討してみるのも一つの手です。未経験からのPython習得や転職サポートに対応しているスクールも多く、無料カウンセリングで自分に合うか相談できるので、まずは気軽に話を聞いてみるとよいでしょう。

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

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

まとめ

今回は、Pythonの sort と sorted の違いと使い方を解説しました。最後に要点を振り返っておきましょう。

• list.sort() は元のリストを直接並び替える（戻り値は None）。
• sorted(リスト) は元のリストを変えず、並び替えた新しいリストを返す。
• 降順にしたいときは、どちらも reverse=True を指定する。
• key 引数（特に lambda）を使えば、長さ順・点数順など好きな基準で並び替えられる。
• 異なる型が混ざったリストはソートできず TypeError になるので注意する。

並び替えはデータ処理の基本中の基本です。sort と sorted を使い分けられるようになると、Pythonでできることがぐっと広がります。ぜひ手を動かして試してみてくださいね。

プログラミングを学んでいると、「変数の値を文章の中に組み込んで表示したい」という場面が頻繁に出てきます。たとえば「名前」や「合計金額」を、決まった文章と一緒に出力したいときなどです。文字列を + で連結する方法もありますが、数値を毎回 str() で変換したり、+ をたくさん並べたりするのは少し面倒ですよね。

そんなときに役立つのが、Python 3.6から導入された f文字列（f-string） です。f文字列を使えば、変数や計算結果を文字列の中にスッキリ埋め込むことができ、コードがぐっと読みやすくなります。この記事では、f文字列の基本から、桁揃えやゼロ埋めといった便利な書式設定まで、初心者の方にも分かりやすく解説していきます。

f文字列（f-string）とは？

f文字列とは、文字列の先頭に f を付けて、その中の { }（波括弧）に変数や式を書くことで、値を埋め込める書き方です。「フォーマット済み文字列リテラル（formatted string literal）」の頭文字をとって「f-string」と呼ばれています。

言葉で説明するよりも、実際のコードを見たほうが早いので、さっそく基本的な使い方から見ていきましょう。

f文字列の基本的な使い方

使い方はとてもシンプルで、f"..." のように文字列の前に f を付け、埋め込みたい変数を {変数名} で囲むだけです。

name = "佐藤"
age = 25

# f文字列を使う場合
print(f"私の名前は{name}です。年齢は{age}歳です。")
# 実行結果: 私の名前は佐藤です。年齢は25歳です。

# 従来の + で連結する書き方と比較
print("私の名前は" + name + "です。年齢は" + str(age) + "歳です。")
# 実行結果: 私の名前は佐藤です。年齢は25歳です。

+ で連結する書き方と比べると、f文字列のほうが文章の見た目に近く、どんな出力になるか一目で分かりますね。さらに、数値の age をそのまま {age} と書けるのも大きなポイントです。+ 連結では str(age) のように文字列へ変換する必要がありましたが、f文字列では自動で文字列に変換してくれます。

波括弧の中には式も書ける

f文字列の { } の中には、変数だけでなく計算式やメソッドの呼び出しなど、Pythonの「式」を書くことができます。

price = 1200
count = 3

# 中括弧の中で計算もできる
print(f"合計金額は{price * count}円です。")
# 実行結果: 合計金額は3600円です。

# メソッドの呼び出しも可能
fruit = "apple"
print(f"大文字にすると{fruit.upper()}になります。")
# 実行結果: 大文字にするとAPPLEになります。

このように、わざわざ計算結果を別の変数に入れなくても、その場で処理を書けるのが便利です。文字列を分割したり結合したりする処理と組み合わせたい場合は、文字列を分割・結合する方法（split, join関数）の記事もあわせて読むと理解が深まります。

数値の書式設定（桁揃え・ゼロ埋め・小数点）

f文字列の本領が発揮されるのが、数値の書式設定です。{値:書式} のように、コロン : のあとに書式を指定することで、表示を細かく整えられます。

pi = 3.14159265

# 小数点以下2桁に丸める
print(f"円周率は約{pi:.2f}です。")
# 実行結果: 円周率は約3.14です。

# ゼロ埋め（5桁）
num = 42
print(f"番号は{num:05d}です。")
# 実行結果: 番号は00042です。

# 3桁区切り（カンマ）
money = 1234567
print(f"金額は{money:,}円です。")
# 実行結果: 金額は1,234,567円です。

:.2f は「小数点以下2桁の浮動小数点数」、:05d は「5桁になるよう0で埋めた整数」、:, は「3桁ごとにカンマ区切り」を表します。とくにゼロ埋めはログの連番やファイル名などでよく使う処理です。f文字列を使わずにゼロ埋めをしたい場合は、Pythonで文字列を0埋めする方法（ゼロパディング）で zfill などの方法も紹介していますので、参考にしてみてください。

文字列の桁揃え（左寄せ・中央寄せ・右寄せ）

数値だけでなく、文字列の表示位置もそろえられます。< で左寄せ、^ で中央寄せ、> で右寄せになり、そのあとの数字で全体の幅を指定します。

# 左寄せ・中央寄せ・右寄せ（幅10文字）
word = "Python"
print(f"|{word:<10}|")   # 左寄せ
print(f"|{word:^10}|")   # 中央寄せ
print(f"|{word:>10}|")   # 右寄せ
# 実行結果:
# |Python    |
# |  Python  |
# |    Python|

表のように複数の項目をきれいに整列させたいときに役立ちます。

辞書の値の埋め込みとデバッグ表示

f文字列の中では、辞書（dict）の値を取り出して埋め込むこともできます。その際、キーを囲むクォートは、外側の文字列と別の種類（外がダブルなら内はシングル）にするのがポイントです。

user = {"name": "鈴木", "score": 95}

# 辞書の値を埋め込む（キーはシングルクォートで指定）
print(f"{user['name']}さんの点数は{user['score']}点です。")
# 実行結果: 鈴木さんの点数は95点です。

# = を付けるとデバッグに便利（Python 3.8以降）
x = 10
y = 20
print(f"{x + y = }")
# 実行結果: x + y = 30

辞書そのものの作り方やループ処理についておさらいしたい方は、辞書(dict)の使い方を初心者向けに徹底解説の記事もチェックしてみてください。また、最後の {x + y = } のように = を付ける書き方はPython 3.8以降で使える便利な機能で、「変数名と値」をセットで表示してくれるため、デバッグ時に重宝します。

f文字列を使うときの注意点

便利なf文字列ですが、いくつか注意点もあります。まず、f文字列はPython 3.6以降で使える機能なので、それより古いバージョンでは使えません。また、文字列の中で { や } そのものを表示したいときは、{{、}} のように2つ重ねて書く必要があります。さらに、波括弧の中に複雑な処理を詰め込みすぎると、かえって読みにくくなることもあるため、長い処理は事前に変数へ入れておくのがおすすめです。

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

f文字列のように、Pythonには知っているだけでコードが一気に読みやすくなる便利な機能がたくさんあります。とはいえ、独学だと「何から学べばいいのか分からない」「エラーが解決できずに手が止まってしまう」と感じる場面も多いものです。

もし本気で未経験からPythonを身につけたい、あるいはエンジニアへの転職を目指したいなら、プロのマンツーマン指導が受けられるプログラミングスクールを活用するのも一つの方法です。とくに Winスクールの「Python Winner」 は、講師がマンツーマンで指導してくれるため、つまずいたところをその場で質問でき、未経験からでも着実にスキルを習得できます。就職・転職のサポートもあり、まずは無料カウンセリングで学習プランを相談できるので、気になる方は一度チェックしてみてはいかがでしょうか。

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

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

まとめ

今回は、Pythonのf文字列（f-string）の使い方について解説しました。最後に要点を振り返っておきましょう。

• f文字列は文字列の前に f を付け、{ } の中に変数や式を書くことで値を埋め込める
• 数値も自動で文字列に変換されるため、str() での変換が不要
• {値:.2f} や {値:05d}、{値:,} で小数・ゼロ埋め・カンマ区切りなどの書式設定ができる
• < ^ > で文字列の左寄せ・中央寄せ・右寄せができる
• 辞書の値の埋め込みや、{式 = } によるデバッグ表示（Python 3.8以降）も便利
• Python 3.6以降で使える機能で、{ 自体を表示したいときは {{ }} と2つ重ねる

f文字列を使いこなせるようになると、出力周りのコードが驚くほどスッキリします。ぜひ普段のコードに取り入れて、Pythonをもっと快適に書いていきましょう。

Pythonで「リストの中から重複を消したい」「2つのデータに共通する要素だけを取り出したい」と思ったことはありませんか？for文とif文を組み合わせて頑張って書くこともできますが、実はもっとシンプルに解決できる仕組みがPythonには用意されています。それが今回ご紹介する set（集合）型 です。

この記事では、set型の基本的な作り方から、要素の追加・削除、和集合・積集合といった集合演算、そして実務でよく使う「重複削除」のテクニックまで、初心者の方にも分かりやすく丁寧に解説していきます。読み終わるころには、setを使ってコードをスッキリ書けるようになっているはずです。

set（集合）型とは？

setとは、重複しない要素の集まりを表すPythonのデータ型です。数学で習った「集合」とほぼ同じイメージで、同じ値は1つしか持てず、要素には順序がないという特徴があります。

まずは実際に作って、その性質を見てみましょう。波カッコ {} の中に要素をカンマ区切りで書くと、set型になります。

fruits = {"apple", "banana", "orange"}
print(fruits)
# {'banana', 'orange', 'apple'}  （順序は保証されません）

print(type(fruits))
# <class 'set'>

注目してほしいのは、出力されたときの順序が書いた順番とは限らないという点です。setは要素の順序を管理しないため、表示順は実行環境によって変わることがあります。「順番を保ちたい」という場合はリストを使いましょう。リストについては、要素の追加方法などをまとめた記事も参考になります。

setの作り方（2つの方法）

① 波カッコ {} で直接作る

先ほどのように、波カッコの中に値を並べるだけでsetが作れます。同じ値を複数書いても、自動的に1つにまとめられます。

colors = {"red", "blue", "red", "blue"}
print(colors)
# {'red', 'blue'}  重複は自動で除かれる

② set() 関数でリストから作る

既存のリストやタプルを set() 関数に渡すと、重複を取り除いたsetに変換できます。これが「重複削除」で最もよく使うパターンです。

numbers = [1, 2, 2, 3, 3, 3]
unique = set(numbers)
print(unique)
# {1, 2, 3}

なお、リストと似た仲間であるタプル（tuple）からも同じようにsetを作れます。タプルとの違いを整理しておくと、データ型の使い分けがより理解しやすくなりますよ。

ひとつ注意点として、空のsetを作るときは {} ではなく set() と書きます。{} は空の辞書（dict）になってしまうためです。これは初心者がつまずきやすいポイントなので、覚えておきましょう。

empty_set = set()    # 空のset
empty_dict = {}      # これは空の辞書（dict）
print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

要素の追加と削除

setに後から要素を追加するには add()、削除するには discard() や remove() を使います。

colors = {"red", "blue"}

colors.add("green")
print(colors)   # {'red', 'blue', 'green'}

colors.discard("red")
print(colors)   # {'blue', 'green'}

# discard は存在しない要素を指定してもエラーにならない
colors.discard("yellow")
print(colors)   # {'blue', 'green'}

remove() も削除に使えますが、存在しない要素を指定するとエラー（KeyError）になります。エラーを出したくない場合は discard() を使うと安全です。

集合演算（和・積・差・対称差）

setの真骨頂が、この集合演算です。2つのsetを使って「共通する要素」「片方にしかない要素」などを、たった1行で求められます。

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)  # 和集合（どちらかに含まれる）   {1, 2, 3, 4, 5, 6}
print(a & b)  # 積集合（両方に含まれる）       {3, 4}
print(a - b)  # 差集合（aだけに含まれる）       {1, 2}
print(a ^ b)  # 対称差（どちらか一方だけ）     {1, 2, 5, 6}

「2つのリストに共通するユーザーを抽出する」「片方のデータにしか存在しない項目を探す」といった処理が、for文を何重にもネストすることなく書けてしまいます。コードが短くなるだけでなく、処理も高速になるのが嬉しいポイントです。

実用例：リストの重複を削除してユニーク数を数える

実務で本当によく使うのが、重複したデータの整理です。例えばメールアドレスのリストから、重複を除いた「実際の人数」を求めてみましょう。

emails = ["a@example.com", "b@example.com", "a@example.com", "c@example.com"]

unique_emails = set(emails)
print(unique_emails)        # {'a@example.com', 'b@example.com', 'c@example.com'}
print(len(unique_emails))   # 3  （ユニークなメール数）

set() で囲んで len() で数えるだけ。たった2行で「重複を除いた件数」が分かります。アンケートの回答集計や、データのクリーニングなどで大活躍するテクニックです。

set内包表記でスマートに作る

リストに「リスト内包表記」があるように、setにもset内包表記があります。波カッコの中に for を書くだけで、条件に合うsetを一気に生成できます。

# 0〜4の2乗をsetで作る
squares = {n ** 2 for n in range(5)}
print(squares)   # {0, 1, 4, 9, 16}

# 偶数だけを集める
evens = {n for n in range(10) if n % 2 == 0}
print(evens)     # {0, 2, 4, 6, 8}

書き方はリスト内包表記とほとんど同じで、外側を波カッコにするだけです。仕組みをしっかり理解したい方は、リスト内包表記の解説記事とあわせて読むと、内包表記の考え方が一気に身につきますよ。

setを使うときの注意点

便利なsetですが、いくつか気をつけたい性質があります。使う前に押さえておきましょう。

• 順序を持たないため、fruits[0] のようなインデックスでのアクセスはできません。
• 重複を持てないため、同じ値を追加しても要素数は増えません。
• 要素にできるのは数値・文字列・タプルなど変更できない（イミュータブルな）値だけで、リストや辞書はsetの要素にできません。
• 空のsetは {} ではなく set() で作ります（{} は空の辞書になります）。

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

ここまでset型の使い方を見てきましたが、独学で進めていると「この書き方で合っているのかな？」「もっと良い方法があるのでは？」と不安になる場面も多いものです。そんなときは、プロに直接質問できる環境があると学習スピードが一気に上がります。

マンツーマン指導でつまずきをその場で解消できるスクールなら、未経験からのPython習得や転職サポートまで一気通貫でサポートしてもらえます。まずは無料カウンセリングで、自分に合った学習プランを相談してみるのがおすすめです。

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

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

まとめ

今回はPythonのset（集合）型について解説しました。要点を振り返っておきましょう。

• setは重複しない・順序を持たない要素の集まり。
• 作り方は波カッコ {} か set() 関数。空のsetは set() で作る。
• add() で追加、discard() / remove() で削除。
• |（和）&（積）-（差）^（対称差）で集合演算ができる。
• リストを set() で囲めば重複削除が一発。len() でユニーク数も分かる。
• set内包表記を使えば、条件付きのsetもスマートに作れる。

リストや辞書、タプルとあわせてsetを使いこなせるようになると、Pythonのデータ処理がぐっと楽になります。ぜひ手を動かして試してみてくださいね。

Pythonを学び始めると、リストやタプルの次に必ず登場するのが「辞書（dict）」です。「キーと値ってなに？」「リストとはどう違うの？」と戸惑う方も多いのではないでしょうか。この記事では、Pythonの辞書（dict）の作り方から、値の取り出し方、要素の追加・更新・削除、ループ処理、便利なメソッド、そして辞書内包表記までを初心者向けにやさしく解説します。サンプルコードはすべて実際に動く内容なので、ぜひ手を動かしながら読み進めてみてください。

辞書（dict）とは？

辞書（dictionary、略してdict）は、「キー（key）」と「値（value）」をペアにして管理するデータ構造です。リストが 0, 1, 2 … という番号（インデックス）で要素を管理するのに対して、辞書は自分で決めた名前（キー）で値を取り出せるのが大きな特徴です。たとえば「国語」というキーに「80点」という値を結びつける、といったイメージですね。

リストやタプルとのデータ構造の違いを整理しておきたい方は、先にリストに要素を追加する方法やタプル(tuple)の使い方もあわせて読むと、それぞれの使い分けがより分かりやすくなります。

辞書の作り方

辞書は波かっこ {} の中に「キー: 値」をカンマ区切りで並べて作ります。空の辞書を作りたいときも {} でOKです。

scores = {"国語": 80, "数学": 95, "英語": 70}
print(scores)
# {'国語': 80, '数学': 95, '英語': 70}

empty = {}
print(type(empty))
# <class 'dict'>

値の取り出し方（[] と get）

キーを角かっこ [] で指定すると、対応する値を取り出せます。ただし存在しないキーを指定すると KeyError になってしまうため、エラーを避けたいときは get() メソッドが便利です。

scores = {"国語": 80, "数学": 95, "英語": 70}
print(scores["数学"])
# 95

# get() なら存在しなくてもエラーにならず None を返す
print(scores.get("理科"))
# None

# 第2引数で「無かったとき」の初期値を指定できる
print(scores.get("理科", 0))
# 0

要素の追加・更新・削除

辞書に新しいキーを指定して値を代入すると要素が追加されます。すでにあるキーに代入した場合は値が上書き（更新）されます。削除には del を使います。

scores = {"国語": 80, "数学": 95}

# 追加
scores["英語"] = 70
print(scores)
# {'国語': 80, '数学': 95, '英語': 70}

# 更新（既存のキーに代入すると上書きされる）
scores["国語"] = 100
print(scores)
# {'国語': 100, '数学': 95, '英語': 70}

# 削除
del scores["数学"]
print(scores)
# {'国語': 100, '英語': 70}

辞書をループ処理する

辞書を for 文で回すと、キーを1つずつ取り出せます。キーと値を同時に取り出したいときは items() メソッドを使うのが定番です。

scores = {"国語": 80, "数学": 95, "英語": 70}

# キーだけ取り出す
for key in scores.keys():
    print(key)
# 国語
# 数学
# 英語

# キーと値を同時に取り出す（items）
for key, value in scores.items():
    print(key, value)
# 国語 80
# 数学 95
# 英語 70

for文そのものの基本をもう一度おさらいしたい方は、Pythonのfor文・range関数を攻略の記事も参考にしてみてください。

よく使う便利なメソッド

辞書には覚えておくと便利なメソッドがいくつもあります。代表的なものをまとめました。

• keys()：キーの一覧を取得する
• values()：値の一覧を取得する
• items()：キーと値のペアを取得する
• get(キー, 初期値)：エラーを出さずに値を取得する
• update(辞書)：複数の要素をまとめて追加・更新する
• in 演算子：キーが存在するか確認する

scores = {"国語": 80, "数学": 95}

# 値の一覧をリストにする
print(list(scores.values()))
# [80, 95]

# 複数の要素をまとめて追加・更新
scores.update({"英語": 70, "理科": 60})
print(scores)
# {'国語': 80, '数学': 95, '英語': 70, '理科': 60}

# キーが存在するか確認
print("数学" in scores)
# True

辞書内包表記でスマートに作る

リスト内包表記と同じように、辞書も内包表記でコンパクトに作成できます。たとえば「1から5までの数とその2乗」を対応させた辞書は、次のように1行で書けます。

# 1から5の数とその2乗を辞書にする
squares = {n: n ** 2 for n in range(1, 6)}
print(squares)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

内包表記の基本的な書き方はリスト内包表記の使い方の記事で詳しく解説しています。考え方は辞書でもほぼ同じなので、あわせてチェックしてみてください。

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

ここまで辞書の使い方を解説してきましたが、独学だと「自分の書き方が正しいのか分からない」「エラーでつまずいて先に進めない」と感じる場面も出てきます。そんなときは、プロの講師にマンツーマンで質問できる環境があると、つまずきを一気に解消できます。未経験からPythonを習得して転職を目指したい方は、無料カウンセリングで自分に合った学習プランを相談できるプログラミングスクールを活用するのも一つの手です。

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

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

まとめ

今回はPythonの辞書（dict）について、基本から実践的な使い方まで解説しました。最後に要点をおさらいしましょう。

• 辞書は「キー」と「値」をペアで管理するデータ構造
• 値の取り出しは [] または get()（存在しないキーでも安全なのは get）
• キー = 値 で追加・更新、del で削除できる
• ループ処理では items() でキーと値を同時に取得できる
• keys()・values()・update()・in など便利なメソッドを使いこなそう
• 辞書内包表記を使えば1行でスマートに辞書を作れる

辞書はデータをまとめて扱ううえで欠かせない、とても出番の多いデータ構造です。ぜひ実際にコードを書いて、自分のものにしてくださいね。

Pythonの勉強を進めていると、リストや辞書に続いて「タプル（tuple）」という言葉が出てきて、「リストと何が違うの？」「いつ使えばいいの？」と戸惑う方は多いのではないでしょうか。

タプルはリストとよく似ていますが、「中身を変更できない」という大きな特徴を持っています。この記事では、タプルの基本的な作り方から、リストとの違い、実際の現場でよく使われる便利な使い方まで、初心者の方にも分かりやすく解説していきます。サンプルコードを実際に動かしながら、ぜひ手を動かして覚えていきましょう。

タプルとは？リストとの違い

タプル（tuple）とは、複数の値をひとまとめにして扱うためのデータ型です。複数の値を順番に並べて管理できるという点ではリストとよく似ていますが、最大の違いは「一度作ったら中身を変更できない」という点にあります。リスト自体の操作に不安がある方は、リストに要素を追加する方法の記事もあわせて読んでみてください。

リストは [ ]（角カッコ）で作るのに対して、タプルは ( )（丸カッコ）で作ります。変更できないという性質は一見不便に思えるかもしれませんが、「うっかり書き換えられたくないデータ」を安全に管理できるという大きなメリットになります。

タプルの基本的な作り方

それでは、実際にタプルを作ってみましょう。丸カッコの中に、カンマ区切りで値を並べるだけで作成できます。

# タプルを作る
fruits = ("りんご", "みかん", "ぶどう")
print(fruits)
# 実行結果: ('りんご', 'みかん', 'ぶどう')

# カッコを省略しても作れます
numbers = 1, 2, 3
print(numbers)
# 実行結果: (1, 2, 3)

# 要素が1つだけのタプルは、末尾にカンマが必要です
single = ("apple",)
print(type(single))
# 実行結果: <class 'tuple'>

注目してほしいのが、最後の「要素が1つだけのタプル」です。カッコだけでカンマを付けないと、これはただのカッコと見なされて文字列になってしまいます。要素が1つのタプルを作るときは、末尾にカンマを付けるのを忘れないようにしましょう。

タプルの要素にアクセスする

タプルの中身を取り出す方法は、リストと全く同じです。インデックス（要素の番号）を使ってアクセスでき、番号は0から始まります。スライスや繰り返し処理（for文）にもそのまま使えます。

colors = ("赤", "青", "緑")

# インデックスでアクセス（0から始まります）
print(colors[0])    # 実行結果: 赤
print(colors[-1])   # 実行結果: 緑

# スライスで一部を取り出す
print(colors[0:2])  # 実行結果: ('赤', '青')

# 繰り返し処理にも使えます
for color in colors:
    print(color)
# 実行結果:
# 赤
# 青
# 緑

タプルは変更できない（イミュータブル）

タプルの最も重要な特徴が、この「変更できない」という性質です。このような変更できないデータ型のことを、専門用語で「イミュータブル（immutable）」と呼びます。試しにタプルの中身を書き換えようとすると、エラーが発生します。

point = (10, 20)

# 値を変更しようとするとエラーになります
point[0] = 100
# 実行結果: TypeError: 'tuple' object does not support item assignment

このように、タプルは要素の代入や追加・削除ができません。「途中で書き換わってほしくない定数のようなデータ」を扱いたいときに、タプルはとても役立ちます。

タプルの便利な使い方

「変更できないなら、リストだけ使えばいいのでは？」と思うかもしれません。しかし、タプルはPythonの現場で本当によく登場します。代表的な2つの使い方を見てみましょう。

関数から複数の値をまとめて返す

Pythonの関数は、タプルを使うことで複数の値を一度に返すことができます。最小値と最大値を同時に返す関数を作ってみましょう。

def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([3, 1, 8, 5])
print(result)
# 実行結果: (1, 8)

アンパック代入で複数の変数に分ける

タプルの中身は、複数の変数にまとめて代入することができます。これを「アンパック代入」と呼びます。同じ仕組みはリストのアンパックでも使えるので、こちらの記事も参考になりますよ。先ほどの関数の戻り値を、そのまま2つの変数で受け取ってみましょう。

# タプルの中身を複数の変数にまとめて代入できます
low, high = get_min_max([3, 1, 8, 5])
print(low)   # 実行結果: 1
print(high)  # 実行結果: 8

# 変数の値の入れ替えも一行でできます
a, b = 1, 2
a, b = b, a
print(a, b)  # 実行結果: 2 1

特に最後の「a, b = b, a」という書き方は、2つの変数の値を入れ替える便利なテクニックとして、実際のコードでもよく使われます。

タプルとリストの使い分け

最後に、タプルとリストをどう使い分ければよいのか、目安をまとめておきます。

• タプルを使う場面：曜日の名前や座標（x, y）など、後から変更されたくない固定のデータを扱うとき。
• リストを使う場面：要素の追加・削除・並べ替えなど、中身を頻繁に変更したいとき。
• 速度面：タプルはリストよりも少しだけ動作が速く、メモリの使用も効率的です。

迷ったときは「あとで変更するかどうか」で判断するとよいでしょう。なお、リストをより便利に扱う書き方としてリスト内包表記もあるので、慣れてきたらぜひチェックしてみてください。変更しないデータならタプル、変更するデータならリスト、と覚えておけば失敗しません。

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

ここまでタプルの使い方を解説してきましたが、独学で学習を進めていると「この書き方で合っているのかな？」「エラーの原因が分からない」と、一人で悩んで手が止まってしまうこともありますよね。

そんなときは、プログラミングスクールでプロの講師にマンツーマンで教えてもらうのも一つの方法です。未経験からのPython習得や、エンジニアへの転職サポートに対応したスクールもあり、つまずきやすいポイントをその場で質問しながら効率よく学べます。多くのスクールでは無料カウンセリングも用意されているので、まずは気軽に相談してみると、自分に合った学習プランが見えてきますよ。

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

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

まとめ

今回は、Pythonのタプル（tuple）について解説しました。最後に要点を振り返っておきましょう。

• タプルは丸カッコで作る、複数の値をまとめて扱うデータ型です。
• 最大の特徴は「一度作ると中身を変更できない（イミュータブル）」という点です。
• 要素が1つだけのタプルは、末尾にカンマを付ける必要があります。
• 要素へのアクセスやfor文での繰り返しは、リストと同じように使えます。
• 関数から複数の値を返したり、アンパック代入で変数に分けたりするときに活躍します。
• 変更しないデータはタプル、変更するデータはリスト、と使い分けましょう。

タプルはリストと並んでPythonの基礎となるデータ型です。ぜひ実際にコードを書いて、その便利さを体感してみてくださいね。