Python lambdaの使い方｜sorted・map・filterのコピペ例一覧

Pythonのlambda（ラムダ式・無名関数）とは、lambda 引数: 式 の形で「名前を付けずにその場で作る小さな関数」です。 sorted の key、map、filter、max／min、defaultdict など、「関数を引数として渡す場所」に1行で書けるのが持ち味です。

この記事では、用途別のコピペ例を一覧表にまとめ、すべてに実行結果を付けました（Python 3.14.7 で実行。3.11.15 でも同じ出力になることを確認しています）。さらに、ループの中で lambda を作ると全部同じ値になる「遅延束縛」の再現と直し方、内包表記・def・operator.itemgetter との使い分けと速度の実測、lambda に書けないもの、PEP 8 が「lambda を変数に代入しない」と勧める理由まで、順番に確認していきます。

Python lambdaの早見表

まず基本形です。lambda 引数: 式 は、def で書いた「式を1つ return するだけの関数」と同じ働きをします。

# lambda で書く
lambda x: x * 2

# 同じ働きの def
def double(x):
    return x * 2

次の表が、よく使う場面の一覧です。入力データは表の下にまとめてあります。

# 早見表の入力データ
items = [
    {"name": "ノート", "price": 300, "stock": 12},
    {"name": "ペン", "price": 120, "stock": 40},
    {"name": "ファイル", "price": 300, "stock": 5},
    {"name": "付箋", "price": 250, "stock": 0},
]
words = ["banana", "Apple", "cherry"]
scores = {"sato": 82, "kato": 95, "abe": 70}

lambdaの基本の書き方

構文と、defとの対応

lambda は「式」なので、値として引数に渡したり、リストや辞書に入れたりできます。 一方 def は「文」で、関数に名前を付けて定義します。

引数の書き方一覧

引数の書き方は def と同じです。引数なし・複数・デフォルト値・可変長のどれも使えます。

print((lambda: 42)())                         # 引数なし
print((lambda x, y: x + y)(1, 2))             # 複数の引数
print((lambda x, y=10: x + y)(1))             # デフォルト値
print((lambda *a, **k: (a, k))(1, 2, z=3))    # 可変長引数
print((lambda x: "偶数" if x % 2 == 0 else "奇数")(7))  # 条件式

42
3
11
((1, 2), {'z': 3})
奇数

(lambda ...)(引数) のように丸かっこで包んで直後に呼ぶと、その場で実行できます。動作確認に便利な書き方です。

条件分岐は「条件式（三項演算子）」で書く

lambda の中に if 文は書けませんが、値1 if 条件 else 値2 という条件式なら書けます。 else を省くと次のエラーになります（実際のメッセージ）。

f = lambda x: x if x > 0

SyntaxError: expected 'else' after 'if' expression

else を付けて lambda x: x if x > 0 else 0 とすれば動きます。

sortedとlambdaで並べ替える

sorted(リスト, key=関数) の key には、「各要素から、比べる材料を取り出す関数」を渡します。ここが lambda のいちばんの出番です。

辞書のリストを1つのキーで並べる・降順にする

items = [
    {"name": "ノート", "price": 300, "stock": 12},
    {"name": "ペン", "price": 120, "stock": 40},
    {"name": "ファイル", "price": 300, "stock": 5},
    {"name": "付箋", "price": 250, "stock": 0},
]

asc = sorted(items, key=lambda x: x["price"])
desc = sorted(items, key=lambda x: x["price"], reverse=True)
print([x["name"] for x in asc])
print([x["name"] for x in desc])

['ペン', '付箋', 'ノート', 'ファイル']
['ノート', 'ファイル', '付箋', 'ペン']

同じ価格（300）の「ノート」と「ファイル」は、元の並び順のままです。Python の並べ替えは「安定ソート」で、キーが同じ要素は入力の順番を保ちます。reverse=True のときも、同点どうしの順番は入れ替わりません。

複数キーで並べる（タプルを返す）

lambda がタプルを返すと、左の要素から順に比べてくれます。

by_two = sorted(items, key=lambda x: (x["price"], x["stock"]))
print([x["name"] for x in by_two])

['ペン', '付箋', 'ファイル', 'ノート']

価格が同じ300のうち、在庫が少ない「ファイル（5）」が「ノート（12）」より前に来ました。

降順と昇順を混ぜる

「価格は高い順、同じなら名前の昇順」のように向きを混ぜたいときは、数値のキーにマイナスを付けます。

mixed = sorted(items, key=lambda x: (-x["price"], x["name"]))
print([x["name"] for x in mixed])

['ノート', 'ファイル', '付箋', 'ペン']

文字列にはマイナスを付けられないので、文字列を降順にしたいときは「優先度の低いキーから順に2回並べる」方法が使えます。詳しい手順は、当サイトの「Python sorted・sortのkey指定」の記事で扱っているので、あわせて読むと整理しやすくなります。

辞書（dict）を値で並べる

scores = {"sato": 82, "kato": 95, "abe": 70}

print(sorted(scores.items(), key=lambda kv: kv[1], reverse=True))  # (キー, 値)のリスト
print(dict(sorted(scores.items(), key=lambda kv: kv[1])))          # 辞書に戻す
print(sorted(scores, key=lambda k: scores[k]))                     # キーだけ欲しいとき

[('kato', 95), ('sato', 82), ('abe', 70)]
{'abe': 70, 'sato': 82, 'kato': 95}
['abe', 'sato', 'kato']

scores.items() は (キー, 値) のタプルを順に返すので、kv[1] が値です。 辞書は挿入順を保つため、dict(...) で包み直すと「値の順に並んだ辞書」になります。

文字数順・大文字小文字を無視・Noneを後ろへ

print(sorted(["kiwi", "fig", "banana"], key=lambda s: len(s)))
print(sorted(["banana", "Apple", "cherry"], key=lambda s: s.lower()))
print(sorted([3, None, 1, None, 2], key=lambda v: (v is None, v or 0)))

['fig', 'kiwi', 'banana']
['Apple', 'banana', 'cherry']
[1, 2, 3, None, None]

3行目は、(Noneかどうか, 値) のタプルをキーにして None を後ろへ送る書き方です。False < True なので、None でない要素が先に並びます。

なお、1行目と2行目は lambda を使わず key=len、key=str.lower と書けます。すでにある関数を呼ぶだけなら、関数そのものを渡すほうが短く速くなります（後半の「使い分け」で実測します）。

mapとlambdaで全要素を変換する

map(関数, イテラブル) は、各要素に関数を当てた結果を順に返します。戻り値はイテレータ（1回だけ順に取り出せるオブジェクト）なので、中身を見るには list() で包みます。

print(list(map(lambda x: x * 2, [1, 2, 3])))
print(list(map(lambda x, y: x + y, [1, 2, 3], [10, 20, 30])))  # 2つのリストを同時に

m = map(lambda x: x * 2, [1, 2, 3])
print(m)

[2, 4, 6]
[11, 22, 33]
<map object at 0x7f...>

イテラブルを2つ渡すと、lambda の引数も2つになります。同じ処理は、内包表記で [x * 2 for x in [1, 2, 3]] とも書けます。

filterとlambdaで条件に合う要素を取り出す

filter(関数, イテラブル) は、関数が真を返した要素だけを残します。

print(list(filter(lambda x: x % 2 == 0, range(10))))

in_stock = list(filter(lambda x: x["stock"] > 0, items))
print(len(in_stock))

[0, 2, 4, 6, 8]
3

在庫が0の「付箋」が外れて3件になりました。内包表記では [x for x in items if x["stock"] > 0] です。

reduceとlambdaでたたみ込む

functools.reduce(関数, イテラブル, 初期値) は、「これまでの結果」と「次の要素」を関数に渡し続けて、1つの値にまとめます。

from functools import reduce

print(reduce(lambda acc, x: acc + x, [1, 2, 3, 4], 0))   # 合計
print(reduce(lambda acc, x: acc * x, [1, 2, 3, 4], 1))   # 積

10
24

合計なら sum()、積なら math.prod() という専用の関数があり、そちらのほうが読みやすく速く動きます。reduce は、専用の関数がない「独自のまとめ方」をしたいときに使うとよいです。

max・minのkeyにlambdaを渡す

max／min にも key があります。「何を基準に最大・最小を決めるか」を lambda で指定すると、基準の値ではなく要素そのものが返ります。

print(max(items, key=lambda x: x["price"])["name"])   # 価格が最大の商品
print(min(items, key=lambda x: x["stock"])["name"])   # 在庫が最小の商品
print(max(scores, key=lambda k: scores[k]))           # 値が最大のキー
print(max(["kiwi", "fig", "banana"], key=lambda s: len(s)))  # 最も長い文字列

ノート
付箋
kato
banana

価格300は「ノート」と「ファイル」の2つありますが、max は同点のとき最初に見つかった要素を返すため「ノート」になります。値が最大のキーは max(scores, key=scores.get) とも書けます。

defaultdictの既定値をlambdaで作る

collections.defaultdict は、存在しないキーを読んだときに「引数なしの関数」を呼んで既定値を作ります。int や list 以外の既定値がほしいときに、引数なしの lambda が役立ちます。

from collections import defaultdict

d = defaultdict(lambda: "未設定")
print(d["color"], dict(d))

stats = defaultdict(lambda: {"count": 0, "total": 0})
stats["a"]["count"] += 1
print(dict(stats))

tree = lambda: defaultdict(tree)   # 何段でも掘れる入れ子の辞書
t = tree()
t["a"]["b"]["c"] = 1
print(t["a"]["b"]["c"])

未設定 {'color': '未設定'}
{'a': {'count': 1, 'total': 0}}
1

defaultdict("未設定") のように値をそのまま渡すと TypeError になります。渡すのは「値」ではなく「値を作る関数」と覚えると迷いません。defaultdict そのものの使い方は、当サイトの collections の記事にまとめています。

関数の辞書・コールバックとして使う

lambda は値なので、辞書に入れて「名前で処理を切り替える表」にできます。

ops = {
    "add": lambda a, b: a + b,
    "mul": lambda a, b: a * b,
}
print(ops["mul"](3, 4))

12

GUI のボタンやイベントに渡す処理（コールバック）にもよく使われます。このとき、次の「遅延束縛」を知っておくと安心です。

ループ内lambdaが全部同じ値になる「遅延束縛」

再現：3つ作ったのに全部同じ結果

funcs = [lambda x: x * i for i in range(3)]
print([f(10) for f in funcs])

[20, 20, 20]

[0, 10, 20] になりそうに見えますが、3つとも 20 です。

なぜそうなるか

lambda の中の変数 i は、「作った時点の値」ではなく「呼ばれた時点の値」を見に行きます。 これを遅延束縛（レイトバインディング）と呼びます。3つの lambda は同じ変数 i を共有していて、ループが終わった時点で i は 2 です。その後で呼ぶので、全部 10 * 2 = 20 になります。

flowchart LR
    A["lambda その1"] --> I["変数 i（ループ終了後は 2）"]
    B["lambda その2"] --> I
    C["lambda その3"] --> I

これは lambda だけの性質ではなく、def で作った関数でも同じです。Python 公式の FAQ（Programming FAQ）にも「ループ内で定義した lambda が同じ結果を返すのはなぜか」として載っています。

直し方1：デフォルト引数で値を固定する

デフォルト引数は「関数を作った時点」で評価されます。 そこで i=i と書くと、その回の値を lambda ごとに保存できます。

funcs = [lambda x, i=i: x * i for i in range(3)]
print([f(10) for f in funcs])

[0, 10, 20]

直し方2：functools.partialを使う

from functools import partial
from operator import mul

funcs = [partial(mul, i) for i in range(3)]
print([f(10) for f in funcs])

[0, 10, 20]

直し方3：関数を作る関数に包む

def make(i):
    return lambda x: x * i

print([f(10) for f in [make(i) for i in range(3)]])

[0, 10, 20]

make(i) を呼ぶたびに新しい変数 i が作られるので、値が混ざりません。

コールバックでの例

ボタンごとに処理を登録する場面で、同じことが起きます。

callbacks = {}
for name in ["save", "load", "exit"]:
    callbacks[name] = lambda: print("押された:", name)
callbacks["save"]()

for name in ["save", "load", "exit"]:
    callbacks[name] = lambda name=name: print("押された:", name)
callbacks["save"]()

押された: exit
押された: save

1回目は「save」を呼んだのに「exit」と表示されました。name=name を足すだけで、意図どおりになります。

デフォルト引数の方法は、呼ぶ側が2つ目の引数を渡すと i が上書きされます。引数を渡されうるコールバックでは、partial か関数を作る関数を選ぶと安心です。

lambdaに書けないもの（文は書けない）

lambda の本体に書けるのは「式」1つだけです。 return、代入、raise、for、try などの「文」を書くと構文エラーになります。実際に試したエラーメッセージを載せます。

代入式（:=、セイウチ演算子）は式なので、lambda の中でも使えます。

f = lambda x: (y := x + 1, y * 2)[-1]
print(f(3))

8

動きはしますが、読む人が立ち止まる書き方です。2つ以上のことをしたくなったら、def に切り替える合図と考えるとよいでしょう。

ほかに、lambda にできないこと・気を付けることをまとめます。

import pickle
pickle.dumps(lambda x: x)

_pickle.PicklingError: Can't pickle <function <lambda> at 0x7fd8108161f0>: it's not found as __main__.<lambda>

multiprocessing などで別プロセスに関数を渡すときは pickle が使われるので、lambda ではなく def で定義したトップレベルの関数を渡します。

PEP 8は「lambdaを変数に代入しない」と勧めている

Python の公式スタイルガイド PEP 8 には、lambda 式を直接名前に束縛する代入文ではなく、def 文を使うという勧めがあります。

# PEP 8 が勧めない書き方
double = lambda x: x * 2

# 勧められる書き方
def double(x):
    return x * 2

チェックツールでも検出されます。pycodestyle 2.15.0 と Ruff 0.15.11 で実際に確認した結果です。

$ python -m pycodestyle e731.py
e731.py:1:1: E731 do not assign a lambda expression, use a def

$ ruff check --select E731 e731.py
E731 Do not assign a `lambda` expression, use a `def`

理由は、エラーが出たときの読みやすさです。lambda は名前が <lambda> になるため、トレースバックでどの関数か分かりにくくなります。

def run():
    f = lambda x: 1 / x
    return f(0)

run()

Traceback (most recent call last):
  File "tb.py", line 5, in <module>
    run()
    ~~~^^
  File "tb.py", line 3, in run
    return f(0)
  File "tb.py", line 2, in <lambda>
    f = lambda x: 1 / x
                  ~~^~~
ZeroDivisionError: division by zero

in <lambda> と表示されます。def inv(x): return 1 / x と書けば、ここが in inv になり、ログを読むだけで場所が分かります。

lambda の良さは「式の中に埋め込めること」です。変数に代入するとその良さを使わないことになるので、名前を付けたいなら def を選ぶ、というのが PEP 8 の考え方です。sorted(items, key=lambda x: x["price"]) のように引数へ直接渡す使い方は、この勧めの対象外です。

内包表記・def・itemgetterとの使い分け

判断表

迷ったときの目安は「1行で、1回だけ、引数として渡す」なら lambda、それ以外は def か内包表記です。

itemgetter・attrgetterで書き換える

from operator import itemgetter, attrgetter

print([x["name"] for x in sorted(items, key=itemgetter("price"))])
print([x["name"] for x in sorted(items, key=itemgetter("price", "stock"))])  # 複数キー

pairs = [("b", 2), ("a", 2), ("c", 1)]
print(sorted(pairs, key=itemgetter(1, 0)))   # 2番目→1番目の順

class User:
    def __init__(self, name, age):
        self.name, self.age = name, age
    def __repr__(self):
        return f"U({self.name},{self.age})"

users = [User("sato", 30), User("abe", 25)]
print(sorted(users, key=attrgetter("age")))

['ペン', '付箋', 'ノート', 'ファイル']
['ペン', '付箋', 'ファイル', 'ノート']
[('c', 1), ('a', 2), ('b', 2)]
[U(abe,25), U(sato,30)]

itemgetter("price", "stock") は lambda x: (x["price"], x["stock"]) と同じ働きです。マイナスを付ける、lower() を呼ぶなど「取り出した後にひと手間」があるときは lambda が向いています。

速度の実測

10万件のデータで、書き方ごとの時間を測りました（Python 3.14.7、timeit で5回実行×40セットの最小値。数値は環境によって変わります）。

import random, timeit
from functools import reduce
from operator import itemgetter

random.seed(0)
data = [{"id": i, "price": random.randint(1, 10000)} for i in range(100_000)]
nums = list(range(100_000))

def by_price(x):
    return x["price"]

読み取れることは次の3つです。

• 並べ替えは、lambda・def・itemgetter でほぼ同じでした。別の回に測り直すと順位が入れ替わる程度の差で、並べ替えそのものの時間が大半を占めます。key の書き方は読みやすさで選んで問題ありません。
• map／filter に lambda を渡す形は、内包表記より時間がかかりました（約1.7倍）。要素ごとに関数呼び出しが1回入るためです。変換と絞り込みは内包表記が読みやすく、速度の面でも有利です。
• map(str, nums) のように組み込み関数をそのまま渡すと、内包表記と同等かやや速い結果でした。「lambda を挟むかどうか」が差になります。合計は sum が約11倍速く、専用の関数があるならそれを使うのが近道です。

内包表記の書き方と速度の詳しい比較は、当サイトの「Python内包表記」の記事にまとめています。

よくあるつまずきと直し方

lambdaを読みやすく保つチェックリスト

書いた lambda を見直すときに使える確認項目です。1つでも「いいえ」があれば、def か内包表記に書き換えると読みやすくなります。

最後の行はよくある形です。lambda s: len(s) は len、lambda s: s.lower() は str.lower、lambda x: str(x) は str と書けて、関数呼び出しが1段減ります。「引数をそのまま別の関数に渡しているだけ」に気づいたら、その関数を直接渡せます。

よくある質問

Q. lambda と def はどちらが速いですか？

A. 作られる関数の中身は同じなので、速度はほぼ同じです。10万件の並べ替えで測ったところ、lambda が 23.87 ms、def が 23.08 ms で、測るたびに入れ替わる程度の差でした。読みやすさと、名前が必要かどうかで選ぶとよいです。

Q. lambda の中で if は使えますか？

A. if 文は書けませんが、条件式 値1 if 条件 else 値2 は書けます。else は省けません。分岐が2つ以上になるなら、def にすると読みやすくなります。

Q. map・filter と内包表記はどちらを使えばよいですか？

A. lambda を書く必要があるなら内包表記が読みやすく、実測でも速い結果でした。map(str, xs) のように既存の関数をそのまま渡せるときは map も簡潔です。巨大なデータを少しずつ処理したいときは、map やジェネレータ式のように「必要な分だけ計算する」形が向いています。

Q. lambda を変数に代入するのはなぜ勧められないのですか？

A. PEP 8 が、名前を付けるなら def を使うよう勧めているためです。lambda は名前が <lambda> になり、トレースバックでどの関数か分かりにくくなります。引数として直接渡す使い方は、この勧めの対象外です。

まとめ

• lambda は lambda 引数: 式 で作る、名前のない小さな関数。def で「式を1つ return する関数」を書くのと同じ働き
• いちばんの出番は sorted／max／min の key。複数キーはタプル、降順の混在はマイナスで書ける
• map／filter は list() で包んで結果を見る。lambda が必要なら内包表記のほうが読みやすく、実測でも約1.7倍速かった
• ループ内で作った lambda は、呼ばれた時点の変数を見る（遅延束縛）。lambda x, i=i: ... で作った時点の値に固定できる
• lambda に書けるのは式1つだけ。return・代入・raise・型ヒント・docstring が必要になったら def に切り替える
• PEP 8 は lambda の変数への代入ではなく def を勧めている（E731）。トレースバックに関数名が出て、原因を追いやすくなる
• 値を取り出すだけの key は itemgetter／attrgetter、既存の関数は key=len のようにそのまま渡せる

株式会社RJCでは、Pythonのlambdaや関数の書き方を仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。