Python lambda式とは？短い関数を簡単に作る方法

みなさん、プログラミングで「ちょっとした処理をする関数」が欲しいときはありませんか？

「わざわざ関数を定義するほどでもないけど...」「もっと簡単に書けたらいいのに」「名前を考えるのが面倒」

こんなふうに思ったことありますよね。

実は、Pythonにはlambda式という便利な機能があります。 これを使えば、名前をつけずにその場で関数を作れちゃうんです。

この記事では、lambda式の基本から実践的な使い方まで、わかりやすく解説していきます。 map関数やfilter関数との組み合わせ方も、バッチリマスターできますよ！

lambda式って何？

lambda式は、名前を付けずにその場で作れる短い関数のことです。

簡単に言うと、「使い捨ての関数」を1行で書ける機能なんです。

基本的な書き方

lambda式の基本的な書き方を見てみましょう。

lambda 引数: 式

この形で書きます。 lambdaの後に引数を書いて、コロンの後に処理を書きます。

実際に使ってみましょう。

# 普通の関数
def add(x, y):
    return x + y

# lambda式で同じことをする
add_lambda = lambda x, y: x + y

print(add(3, 5))        # 8
print(add_lambda(3, 5)) # 8

実行結果はこちらです。

8 8

どちらも同じ結果になります。 lambda式の方が短く書けてますね。

普通の関数との違い

普通の関数とlambda式を比較してみましょう。

# 普通の関数で作る場合
def square(x):
    return x ** 2

def is_even(x):
    return x % 2 == 0

# lambda式で作る場合
square_lambda = lambda x: x ** 2
is_even_lambda = lambda x: x % 2 == 0

# 使ってみよう
print(f"普通の関数: {square(4)}")        # 16
print(f"lambda式: {square_lambda(4)}")   # 16

print(f"普通の関数: {is_even(6)}")       # True
print(f"lambda式: {is_even_lambda(6)}")  # True

実行結果はこちらです。

普通の関数: 16 lambda式: 16 普通の関数: True lambda式: True

lambda式を使うと、関数定義がとてもシンプルになります。

map関数と組み合わせる

基本的な使い方

map関数とlambda式を組み合わせると、リストの各要素に処理を適用できます。

# リストの各要素を2倍にする
numbers = [1, 2, 3, 4, 5]

# lambda式を使用
doubled = list(map(lambda x: x * 2, numbers))
print(f"2倍にした結果: {doubled}")

# 普通の関数と比較
def double_func(x):
    return x * 2

doubled_normal = list(map(double_func, numbers))
print(f"普通の関数: {doubled_normal}")

実行結果はこちらです。

2倍にした結果: [2, 4, 6, 8, 10] 普通の関数: [2, 4, 6, 8, 10]

lambda x: x * 2 で各要素を2倍にしています。 map関数がリストの全要素にこの処理を適用してくれます。

複数のリストで使う

2つのリストを組み合わせる処理も簡単です。

# 2つのリストの要素を足し算
list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]

sums = list(map(lambda x, y: x + y, list1, list2))
print(f"要素の合計: {sums}")

# 3つのリストで掛け算
list3 = [2, 2, 2, 2]
products = list(map(lambda x, y, z: x * y * z, list1, list2, list3))
print(f"要素の積: {products}")

実行結果はこちらです。

要素の合計: [6, 8, 10, 12] 要素の積: [10, 24, 42, 64]

lambda x, y: x + y で2つの引数を受け取って足し算しています。

文字列の処理

文字列のリストも簡単に処理できます。

words = ["hello", "world", "python"]

# 各単語を大文字にする
upper_words = list(map(lambda word: word.upper(), words))
print(f"大文字: {upper_words}")

# 各単語の文字数を取得
word_lengths = list(map(lambda word: len(word), words))
print(f"文字数: {word_lengths}")

# 各単語の最初の2文字を取得
first_two = list(map(lambda word: word[:2], words))
print(f"最初の2文字: {first_two}")

実行結果はこちらです。

大文字: ['HELLO', 'WORLD', 'PYTHON'] 文字数: [5, 5, 6] 最初の2文字: ['he', 'wo', 'py']

文字列の操作も lambda式でサクッと書けます。

filter関数と組み合わせる

数値のフィルタリング

filter関数を使うと、条件に合う要素だけを抽出できます。

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

# 偶数だけを抽出
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(f"偶数: {even_numbers}")

# 5より大きい数を抽出
greater_than_5 = list(filter(lambda x: x > 5, numbers))
print(f"5より大きい: {greater_than_5}")

# 3の倍数を抽出
multiples_of_3 = list(filter(lambda x: x % 3 == 0, numbers))
print(f"3の倍数: {multiples_of_3}")

実行結果はこちらです。

偶数: [2, 4, 6, 8, 10] 5より大きい: [6, 7, 8, 9, 10] 3の倍数: [3, 6, 9]

lambda x: x % 2 == 0 で偶数かどうかを判定しています。 Trueが返された要素だけが残ります。

文字列のフィルタリング

文字列の条件でフィルタリングしてみましょう。

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

# 5文字以上の単語を抽出
long_words = list(filter(lambda word: len(word) >= 5, words))
print(f"5文字以上: {long_words}")

# 'a'を含む単語を抽出
words_with_a = list(filter(lambda word: 'a' in word, words))
print(f"'a'を含む: {words_with_a}")

# 'e'で終わる単語を抽出
ends_with_e = list(filter(lambda word: word.endswith('e'), words))
print(f"'e'で終わる: {ends_with_e}")

実行結果はこちらです。

5文字以上: ['apple', 'banana', 'cherry', 'elderberry'] 'a'を含む: ['apple', 'banana', 'date'] 'e'で終わる: ['apple', 'date']

文字列の条件判定もlambda式で簡単に書けます。

辞書のフィルタリング

辞書のリストをフィルタリングしてみましょう。

students = [
    {"name": "田中", "age": 20, "score": 85},
    {"name": "佐藤", "age": 22, "score": 92},
    {"name": "鈴木", "age": 19, "score": 78},
    {"name": "高橋", "age": 21, "score": 95}
]

# 80点以上の学生を抽出
high_scorers = list(filter(lambda student: student["score"] >= 80, students))
print("80点以上の学生:")
for student in high_scorers:
    print(f"  {student['name']}: {student['score']}点")

# 20歳以上の学生を抽出
adults = list(filter(lambda student: student["age"] >= 20, students))
print(f"
20歳以上の学生: {len(adults)}人")

実行結果はこちらです。

80点以上の学生: 田中: 85点 佐藤: 92点 高橋: 95点 20歳以上の学生: 3人

lambda student: student["score"] >= 80 で辞書の要素を参照して条件判定しています。

sorted関数と組み合わせる

基本的なソート

sorted関数でカスタムソートができます。

words = ["python", "java", "c", "javascript", "go"]

# 文字数でソート
sorted_by_length = sorted(words, key=lambda word: len(word))
print(f"文字数順: {sorted_by_length}")

# 文字数の降順でソート
sorted_desc = sorted(words, key=lambda word: len(word), reverse=True)
print(f"文字数降順: {sorted_desc}")

実行結果はこちらです。

文字数順: ['c', 'go', 'java', 'python', 'javascript'] 文字数降順: ['javascript', 'python', 'java', 'go', 'c']

key=lambda word: len(word) で並び替えの基準を指定しています。

複雑なデータのソート

辞書のリストを色々な条件でソートしてみましょう。

products = [
    {"name": "ノートPC", "price": 89800, "stock": 15},
    {"name": "マウス", "price": 2500, "stock": 50},
    {"name": "キーボード", "price": 8500, "stock": 30},
    {"name": "モニター", "price": 25000, "stock": 8}
]

# 価格でソート
sorted_by_price = sorted(products, key=lambda product: product["price"])
print("価格順:")
for product in sorted_by_price:
    print(f"  {product['name']}: {product['price']:,}円")

# 在庫数でソート（少ない順）
sorted_by_stock = sorted(products, key=lambda product: product["stock"])
print("
在庫少ない順:")
for product in sorted_by_stock:
    print(f"  {product['name']}: {product['stock']}個")

実行結果はこちらです。

価格順: マウス: 2,500円 キーボード: 8,500円 モニター: 25,000円 ノートPC: 89,800円 在庫少ない順: モニター: 8個 ノートPC: 15個 キーボード: 30個 マウス: 50個

lambda式で辞書のキーを指定してソートできます。

複数条件でのソート

複数の条件を組み合わせたソートも可能です。

students = [
    {"name": "田中", "class": "A", "score": 85},
    {"name": "佐藤", "class": "B", "score": 92},
    {"name": "鈴木", "class": "A", "score": 78},
    {"name": "高橋", "class": "B", "score": 85}
]

# クラス→スコアの順でソート
sorted_students = sorted(students, key=lambda student: (student["class"], student["score"]))
print("クラス→スコア順:")
for student in sorted_students:
    print(f"  {student['class']}組 {student['name']}: {student['score']}点")

# クラス→スコア降順でソート
sorted_desc = sorted(students, key=lambda student: (student["class"], -student["score"]))
print("
クラス→スコア降順:")
for student in sorted_desc:
    print(f"  {student['class']}組 {student['name']}: {student['score']}点")

実行結果はこちらです。

クラス→スコア順: A組 鈴木: 78点 A組 田中: 85点 B組 高橋: 85点 B組 佐藤: 92点 クラス→スコア降順: A組 田中: 85点 A組 鈴木: 78点 B組 佐藤: 92点 B組 高橋: 85点

(student["class"], student["score"]) でタプルを返すと、複数条件でソートできます。

実践的な使い方

データ処理パイプライン

map、filter、sortedを組み合わせて、データを順番に処理してみましょう。

# 売上データの処理
sales_data = [
    {"product": "商品A", "price": 1000, "quantity": 5},
    {"product": "商品B", "price": 1500, "quantity": 3},
    {"product": "商品C", "price": 800, "quantity": 8},
    {"product": "商品D", "price": 2000, "quantity": 2}
]

# 1. 各商品の売上金額を計算
sales_with_total = list(map(lambda item: {
    **item, 
    "total": item["price"] * item["quantity"]
}, sales_data))

# 2. 売上金額が3000円以上の商品をフィルタリング
high_sales = list(filter(lambda item: item["total"] >= 3000, sales_with_total))

# 3. 売上金額で降順ソート
sorted_sales = sorted(high_sales, key=lambda item: item["total"], reverse=True)

print("高売上商品（3000円以上）:")
for item in sorted_sales:
    print(f"  {item['product']}: {item['total']:,}円")

実行結果はこちらです。

高売上商品（3000円以上）: 商品A: 5,000円 商品B: 4,500円 商品C: 6,400円 商品D: 4,000円

データを段階的に処理して、最終的な結果を得られました。

条件付きデータ処理

より複雑な条件でデータを処理してみましょう。

users = [
    {"name": "田中", "age": 25, "department": "開発", "salary": 450000},
    {"name": "佐藤", "age": 30, "department": "営業", "salary": 520000},
    {"name": "鈴木", "age": 28, "department": "開発", "salary": 480000},
    {"name": "高橋", "age": 35, "department": "管理", "salary": 600000}
]

# 開発部門の人だけ抽出
dev_users = list(filter(lambda user: user["department"] == "開発", users))

# 開発部門の給与リストを作成
dev_salaries = list(map(lambda user: user["salary"], dev_users))

# 平均給与を計算
dev_avg_salary = sum(dev_salaries) / len(dev_salaries)
print(f"開発部門平均給与: {dev_avg_salary:,.0f}円")

# 30歳以上の人を給与順でソート
senior_users = list(filter(lambda user: user["age"] >= 30, users))
sorted_senior = sorted(senior_users, key=lambda user: user["salary"], reverse=True)

print("
30歳以上の社員（給与順）:")
for user in sorted_senior:
    print(f"  {user['name']} ({user['age']}歳): {user['salary']:,}円")

実行結果はこちらです。

開発部門平均給与: 465,000円 30歳以上の社員（給与順）: 高橋 (35歳): 600,000円 佐藤 (30歳): 520,000円

複数の条件を組み合わせて、欲しいデータを抽出できました。

注意点と使い分け

複雑な処理には向かない

lambda式は短い処理専用です。

# 悪い例：複雑すぎる
# complex_lambda = lambda x: x * 2 if x > 0 else (x / 2 if x < 0 else 0)

# 良い例：普通の関数で書く
def process_number(x):
    if x > 0:
        return x * 2
    elif x < 0:
        return x / 2
    else:
        return 0

# 使ってみよう
numbers = [-5, 0, 3, -2, 7]
processed = list(map(process_number, numbers))
print(f"処理結果: {processed}")

実行結果はこちらです。

処理結果: [-2.5, 0, 6, -1.0, 14]

複雑な処理は普通の関数で書いた方が読みやすいです。

いつlambda式を使う？

lambda式を使うべき場面をまとめてみましょう。

# 適切な使用例

# 1. 簡単な計算
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))

# 2. 簡単な条件判定
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

# 3. 簡単なソートキー
words = ["python", "java", "c++"]
sorted_words = sorted(words, key=lambda word: len(word))

print(f"2倍: {doubled}")
print(f"偶数: {even_numbers}")
print(f"長さ順: {sorted_words}")

実行結果はこちらです。

2倍: [2, 4, 6, 8, 10] 偶数: [2, 4] 長さ順: ['c++', 'java', 'python']

短くて分かりやすい処理にはlambda式がピッタリです。

その他の便利な使い方

reduce関数と組み合わせ

reduce関数でリストを1つの値にまとめられます。

from functools import reduce

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

# 全要素の合計
total = reduce(lambda x, y: x + y, numbers)
print(f"合計: {total}")

# 全要素の積
product = reduce(lambda x, y: x * y, numbers)
print(f"積: {product}")

# 最大値を見つける
maximum = reduce(lambda x, y: x if x > y else y, numbers)
print(f"最大値: {maximum}")

実行結果はこちらです。

合計: 15 積: 120 最大値: 5

lambda x, y: x + y で2つの値を足し算して、順次処理していきます。

文字列処理

文字列の処理でも活躍します。

# ログデータの処理
log_entries = [
    "2024-01-15 10:30:15 INFO User login successful",
    "2024-01-15 10:31:22 ERROR Database connection failed",
    "2024-01-15 10:32:45 INFO File uploaded",
    "2024-01-15 10:33:12 WARNING Memory usage high",
    "2024-01-15 10:34:55 ERROR API call timeout"
]

# エラーログのみを抽出
error_logs = list(filter(lambda log: "ERROR" in log, log_entries))
print("エラーログ:")
for log in error_logs:
    print(f"  {log}")

# ログレベルを抽出
log_levels = list(map(lambda log: log.split()[2], log_entries))
print(f"
ログレベル: {log_levels}")

実行結果はこちらです。

エラーログ: 2024-01-15 10:31:22 ERROR Database connection failed 2024-01-15 10:34:55 ERROR API call timeout ログレベル: ['INFO', 'ERROR', 'INFO', 'WARNING', 'ERROR']

lambda log: "ERROR" in log でエラーログを抽出できます。

まとめ

Python lambda式の基本から実践的な使い方まで解説しました。

今回学んだポイント

lambda式の基本

• 名前を付けずにその場で関数を作成
• lambda 引数: 式 の形で書く
• 短い処理に適している

主な組み合わせパターン

• map関数: リストの各要素を変換
• filter関数: 条件に合う要素を抽出
• sorted関数: カスタムソート

実践的な活用場面

• データ処理パイプライン
• 条件付きフィルタリング
• カスタムソート
• ログ処理

使い分けのコツ

• 簡単な処理はlambda式で
• 複雑な処理は普通の関数で
• 1行で書けるものはlambda式が最適

lambda式をマスターすると、Pythonのコードがとてもスッキリと書けるようになります。 まずはmap、filter、sortedとの組み合わせから始めて、徐々に色々な場面で使ってみてくださいね！