Function | Haobin Tan

Function: First Class Object

Sat, 03 Dec 2022 00:00:00 +0000

TL;DR

Everything in Python is an object, including functions. You can
- assign them to variables
- store them in data structures
- pass or return them to and from ohter functions
First-class functions allow you to abstract away and pass around behavior in your programs.
Functions can be nested and they can capture and carry some of the parent function’s state with them.
Objects can be made callable, which allows you to treat them like functions.

Python’s functions are first-class objects. You can

assign them to variables
store them in data structures
pass them as arguments to other functions
return them as values from other functions

Example throughout:

def yell(text):
 return text.upper() + '!'

>>> yell('hello')
'HELLO!'

Functions Are Objects

Like strings, lists, modules, functions in Python are also just objects.

Becaus the yell function is an object in Python, we can assign it to another variable:

bark = yell

This line doesn’t call the function. It takes the function object referenced by yell and creates a second name, bark, that points to it.

You could now also execute the same underlying function object by calling bark:

>>> bark('woof')
'WOOF!'

Function objects and their names are two separate concerns. We can delete the function’s original name (yell). Since another name (bark) still points to the underlying function, you can still call the function through it:

>>> del yell

>>> yell('hello?')
NameError: "name 'yell' is not defined"

>>> bark('hey')
'HEY!'

For debugging purposes, Python attaches a string identifier to every function at creation time. We can access this internal identifier with the __name__ attribute:

>>> bark.__name__
'yell'

Functions Can Be Stored in Data Structures

We can store functions in data structures, just like we can do with other objects.

Example:

>>> funcs = [bark, str.lower, str.capitalize]

>>> funcs
[<function yell at 0x10ff96510>,
 <method 'lower' of 'str' objects>,
 <method 'capitalize' of 'str' objects>]

Accessing the function objects stored inside the list works like it would with any other type of object:

>>> for f in funcs:
... print(f, f('hey there'))

<function yell at 0x10ff96510> 'HEY THERE!'
<method 'lower' of 'str' objects> 'hey there'
<method 'capitalize' of 'str' objects> 'Hey there'

We can do the lookup and then immediately call the resulting “disembodied” function object within a single expres- sion:

>>> funcs[0]('heyho')
'HEYHO!'

Functions Can Be Passed to Other Functions

We can pass functions as arguments to other functions.

Example:

def greet(func):
 greeting = func('Hi, I am a Python program')
 print(greeting)

We pass the bark functon to greet:

>>> greet(bark)
'HI, I AM A PYTHON PROGRAM!'

The ability to pass function objects as arguments to other functions is powerful. It allows you to abstract away and pass around behavior in your programs. 👍

Functions that can accept other functions as arguments are also called higher-order functions. They are a necessity for the functional programming style. The classical example for higher-order functions in Python is the built-in map function: It takes a function object and an iterable, and then calls the function on each element in the iterable, yielding the results as it goes along.

Example

>>> list(map(bark, ['hello', 'hey', 'hi']))
['HELLO!', 'HEY!', 'HI!']

Functions Can Be Nested

Python allows functions to be defined inside other functions. These are often called nested functions or inner functions.

Example:

def speak(text):
 def whisper(t):
 return t.lower() + '...'
 return whisper(text)

>>> speak('Hello, World')
'hello, world...'

Notice that the inner function is “nested”. In other words, whisper does NOT exist outside speak.

>>> whisper('Yo')
NameError:
"name 'whisper' is not defined"

>>> speak.whisper
AttributeError:
"'function' object has no attribute 'whisper'"

Is it possible to access that nested whisper? Yes. Remember that function are just objects - we can return the inner function to the caller of the parent function.

Example:

def get_speak_func(volume):
 def whisper(text):
 return text.lower() + "..."

 def yell(text):
 return text.upper() + "!"

 return yell if volume > 0.5 else whisper

Our get_speak_funct does NOT actually call any of its inner functions. Instead, it simply selects the appropriate inner function based on the volume argument and then returns the function object.

>>> get_speak_func(0.3)
<function get_speak_func.<locals>.whisper at 0x10ae18>

>>> get_speak_func(0.7)
<function get_speak_func.<locals>.yell at 0x1008c8>

>>> speak_func = get_speak_func(0.7)
>>> speak_func('Hello')
'HELLO!'

Functions Can Capture Local State

Not only can functions return other functions, these inner functions can also capture and carry some of the parent function’s state with them.

Let’s slightly rewrite the get_speak_func above:

def get_speak_func(text, volume):
 def whisper():
 return text.lower() + "..."

 def yell():
 return text.upper() + "!"

 return yell if volume > 0.5 else whisper

>>> get_speak_func('Hello, World', 0.7)()
'HELLO, WORLD!'

Notice that the inner functions whisper and yell do not have a text parameter. But somehow they can still access the text parameter defined in the parent function. They seem to capture and “remember” the value of that argument.

Functions that do this are called lexical closures (or just closures). A closure remembers the values from its enclosing lexical scope even when the program flow is no longer in that scope.

This means not only can functions return behaviors but they can also pre-configure those behaviors. Example:

def make_adder(n):
 def add(x):
 return x + n
 return add

>>> plus_3 = make_adder(3)

>>> plus_3(4)
7

>>> make_adder(5)(4)
9

Here make_adder serves as a factory to create and configure “adder” functions. Notice that the inner add function can still access the n argument of the make_adderfunction, since it is in thee enclosing scope.

Object can behave like functions

Objects can be made callable, which allows us to treat them like functions in many cases.

If an object is callable, we can use the round parentheses function call syntax on it and even pass in function call arguments. This is powered by the __call__ dunder method. Under the hood, “calling” an object instance as a function attempts to execute the object’s __call__ method.

Example:

class Adder:
 def __init__(self, n):
 self.n = n

 def __call__(self, x):
 return self.n + x

>>> plus_3 = Adder(3)
>>> plus_3(4)
7

Notice that NOT all objects are callable. We can use the built-in callable function to check whether an object appears to be callable or not.

Lambda Function

Sat, 03 Dec 2022 00:00:00 +0000

The lambda keyword in Python provides a shortcut for declaring small anonymous functions. Lambda functions behave just like regular functions declared with the def keyword.

Example:

>>> add = lambda x, y: x + y
>>> add(5, 3)
8

It is equivalent to declaring the same add function with the def keyword (which would be slightly moer verbose):

>>> def add(x, y):
... return x + y
>>> add(5, 3)
8

We can also define a lambda function and then immediately evaluated it inline, without binding the function object to a name:

>>> (lambda x, y: x + y)(5, 3)
8

The syntactic difference between lambdas and regular function definitions is: Lambda functions are restricted to a single expression. This means a lambda function can’t use statements or annotations—not even a return statement.

Executing a lambda function evaluates its expression and then automatically returns the expression’s result, so there’s always an implicit return statement.

When to use `lambda`?

Lambdas provide a handy and “unbureaucratic” shortcut to defining a function in Python. A typical use case for lambdas is writing short and concise key funcs for sorting iterables by an alternate key:

>>> tuples = [(1, 'd'), (2, 'b'), (4, 'a'), (3, 'c')]
>>> sorted(tuples, key=lambda x: x[1])
[(4, 'a'), (2, 'b'), (3, 'c'), (1, 'd')]

Just like regular nested functions, lambdas also work as lexical closures.

Example:

>>> def make_adder(n):
... return lambda x: x + n

>>> plus_3 = make_adder(3)

>>> plus_3(4)
7

The x + n lambda can still access the value of n even though it was defined in the make_adder function (the enclosing scope).

When NOT to use `lambda`?

Lambda functions should be used sparingly and with extraordinary care!!!

If you’re tempted to use a lambda, spend a few seconds (or minutes) to think if it is really the cleanest and most maintainable way to achieve the desired result.

For example:

# Bad readablility with lambda:
>>> list(filter(lambda x: x % 2 == 0, range(16))) [0, 2, 4, 6, 8, 10, 12, 14]

# Better readablility with list comprehension
>>> [x for x in range(16) if x % 2 == 0] [0, 2, 4, 6, 8, 10, 12, 14]

Do not use lambda just for show-off purpose.

If you find yourself doing anything remotely complex with lambda expressions, consider defining a standalone function with a proper name instead.
Saving a few keystrokes won’t matter in the long run, but your col- leagues (and your future self) will appreciate clean and readable code more than terse wizardry.

Function: Return `None`

Sun, 04 Dec 2022 00:00:00 +0000

Python adds an implicit return None statement to the end of any function. In other words, if a function doesn’t specify a return value, it returns None by default.

This means you can replace return None statements with bare return statements or even leave them out completely and still get the same result. E.g.:

def foo1(value):
 if value:
 return value
 else:
 return None


def foo2(value):
 """Bare return statement implies `return None`"""
 if value:
 return value
 else:
 return


def foo3(value):
 """Missing return statement implies `return None`"""
 if value:
 return value

>>> type(foo1(0))
<class 'NoneType'>

>>> type(foo2(0))
<class 'NoneType'>

>>> type(foo3(0))
<class 'NoneType'>

Rule of thumb:

If a function does NOT have a return value (other languages would call this a procedure), then leave out the return statement.
If a function does have a return value from a logical point of view, then you need to decide whether to use an im- plicit return or not.

Function | Haobin Tan

Function: First Class Object

Functions Are Objects

Functions Can Be Stored in Data Structures

Functions Can Be Passed to Other Functions

Functions Can Be Nested

Functions Can Capture Local State

Object can behave like functions

Lambda Function

When to use lambda?

When NOT to use lambda?

Function: Return `None`

When to use `lambda`?

When NOT to use `lambda`?