## usecase

• The aim of this tutorial🔍 is to introduce anonymous/lambda functions in Python just to make sure they work in the Higher Order Functions class of SICP

### 1. syntax

Unlike lambda forms in other languages, where they add functionality, Python lambdas are only a shorthand notation if you’re too lazy to define a function.

Design and History FAQ — Python 3.9.1 documentation

• restrictive
• minimal
• in python, lambdas are synonymous with anonymous functions
• introduce it with `lambda` instead of `def`
``````lambda args: expression
``````
• multiple `args`
• only a single expression

### 2. lambda as function expression

• `lambda` can be assigned to a binding and thus have “name”
``````double = lambda x: x*2
print(double(5))
>>> 10
``````
• note that a vscode linter does rephrase this into a function declaration

### 3. usage

• tiny in size
• needed for a short time
• possibly, the expression is more expressive than the name
• usually, they are passed an argument for higher-order functions

### 4.3. example: lambdas in higher-order functions (HOF)

• the HOF `summationRecursive` from SICP returns the same result for `sumInt(a,b)` as well as for `sumIntLambda(a,b)`
``````def summationRecursive(term, a, next, b):
if (a > b):
return 0
else:
return term(a) + summationRecursive(term, next(a), next, b)

""" proper function declarations """
def sumInt(a, b):
def _identity(x): return x
def _next(x): return x+1
return summationRecursive(_identity, a, _next, b)

""" using lambda functions """
def sumIntLambda(a,b):
return summationRecursive(lambda x: x, a, lambda x: x+1, b)
``````