Lambda Functions

By the end of this lesson you can:

• Write lambda x: expression for tiny one-liners.
• Use lambdas as the key= argument to sorted, min, max.
• Recognise when a lambda is appropriate — and when a named def is clearer.
• Avoid the "lambda assignment" anti-pattern that PEP 8 frowns on.

These two are equivalent:

# Named function
def double(x):
    return x * 2

# Lambda — same thing, anonymous
double = lambda x: x * 2

print(double(5))     # 10

The lambda version has three parts: the keyword lambda, parameters, a colon, and one expression. The expression is automatically the return value — no explicit return.

The syntax

lambda PARAMETERS: EXPRESSION

       |          |
       └ same as  └ what would normally be after 'return'
         def's
         parameters

The expression is the return value. No statements allowed — no if-blocks, no loops, no print (well, print works because it's an expression, but it returns None, so the lambda becomes useless).

Two-argument lambdas

add = lambda a, b: a + b
print(add(3, 4))             # 7

multiply = lambda a, b: a * b
print(multiply(3, 4))        # 12

Parameters separated by commas. Default values work too: lambda x, n=2: x ** n.

The conditional expression trick

You can't use if as a statement, but the conditional expression works:

abs_val = lambda x: x if x >= 0 else -x
print(abs_val(-7))           # 7

label = lambda score: "pass" if score >= 50 else "fail"
print(label(75))             # pass

Same shape: VALUE_IF_TRUE if CONDITION else VALUE_IF_FALSE. Compact but cramped — if it gets longer than one line, switch to a real def.

The most common use · key=

You've seen this all over Level 2 and 3. sorted, min, max take a key argument — a function that extracts the value to sort/compare by.

words = ["python", "is", "fun", "indeed"]

# Sort by length
print(sorted(words, key=lambda w: len(w)))
# → ['is', 'fun', 'python', 'indeed']

# Find the longest word
print(max(words, key=lambda w: len(w)))    # 'indeed'

# Sort dicts by a key
students = [
    {"name": "Aisyah", "score": 92},
    {"name": "Wei Jie", "score": 87},
]
print(sorted(students, key=lambda s: s["score"], reverse=True))

The lambda is the "by what" — by length, by score, etc. Use the lambda when the key would be a tiny one-liner; use a named function when it's complicated.

Lambdas as values

Lambdas are values. You can store them in lists or dicts:

ops = {
    "+": lambda a, b: a + b,
    "-": lambda a, b: a - b,
    "*": lambda a, b: a * b,
    "/": lambda a, b: a / b,
}

print(ops["+"](3, 4))     # 7
print(ops["*"](3, 4))     # 12

# A simple calculator
op = input("op: ")
a  = float(input("a: "))
b  = float(input("b: "))
print(ops[op](a, b))

A dict-of-lambdas is the "dispatch table" pattern — much cleaner than a long if-elif chain.

The anti-pattern · assigning a lambda

PEP 8 (Python's style guide) explicitly says: don't do this.

# ❌ Don't
square = lambda x: x ** 2

# ✅ Do
def square(x):
    return x ** 2

If you're going to give the function a name, just use def — same syntax, same length, plus you get a proper function name in tracebacks. Lambdas are for anonymous functions you pass directly to something.

Lambda vs def · when to choose which

Use lambda when…              Use def when…
- 1-line body                  - more than 1 line
- used once, inline            - reused
- passed as a key= argument    - has docstring / type hints
- pure value computation       - has side effects (print, write)

Save as sort_showcase.py:

# sort_showcase.py — lambdas for sorting

students = [
    {"name": "Aisyah",  "score": 92, "year": 13},
    {"name": "Wei Jie", "score": 87, "year": 12},
    {"name": "Priya",   "score": 95, "year": 13},
    {"name": "Iman",    "score": 60, "year": 12},
    {"name": "Aizat",   "score": 81, "year": 13},
]

# 1 — by score, low to high
print("By score (asc):")
for s in sorted(students, key=lambda s: s["score"]):
    print(f"  {s['name']:<10} {s['score']}")

# 2 — by score descending
print("\nBy score (desc):")
for s in sorted(students, key=lambda s: s["score"], reverse=True):
    print(f"  {s['name']:<10} {s['score']}")

# 3 — by name length, ties broken alphabetically
print("\nBy name length then alpha:")
for s in sorted(students, key=lambda s: (len(s["name"]), s["name"])):
    print(f"  {s['name']:<10}")

# 4 — by year ASC then score DESC inside each year
print("\nGrouped by year, score desc within:")
for s in sorted(students, key=lambda s: (s["year"], -s["score"])):
    print(f"  Year {s['year']}: {s['name']:<10} {s['score']}")

# 5 — max
top = max(students, key=lambda s: s["score"])
print(f"\nTop scorer: {top['name']} ({top['score']})")

# 6 — bottom 3 (slice the sorted list)
bottom_3 = sorted(students, key=lambda s: s["score"])[:3]
print("\nBottom 3:")
for s in bottom_3:
    print(f"  {s['name']:<10} {s['score']}")

Output

By score (asc):
  Iman       60
  Aizat      81
  Wei Jie    87
  Aisyah     92
  Priya      95

By score (desc):
  Priya      95
  Aisyah     92
  Wei Jie    87
  Aizat      81
  Iman       60

By name length then alpha:
  Iman
  Aizat
  Priya
  Aisyah
  Wei Jie

Grouped by year, score desc within:
  Year 12: Wei Jie    87
  Year 12: Iman       60
  Year 13: Priya      95
  Year 13: Aisyah     92
  Year 13: Aizat      81

Top scorer: Priya (95)

Bottom 3:
  Iman       60
  Aizat      81
  Wei Jie    87

Read the diff

Six different sorting needs. Each line is one lambda. The two-key sort uses a tuple — (s["year"], -s["score"]) — primary year asc, secondary score desc (negative trick for descending in a tuple sort). The name-length sort has a tie-breaker by name. Each lambda is short enough that adding a named helper would be more code than it saves.

A lambda is a one-expression anonymous function. Use it as a key= argument to sorted, min, max; as a value in a dispatch dict; or anywhere a tiny throwaway function fits. Conditional expressions (x if cond else y) work inside lambdas; statements don't. If you're tempted to assign a lambda to a variable — just use def instead. Lambdas earn their keep precisely because they're anonymous.