Functions - Additional Topics

This notebook presents additional, miscellaneous topics related to functions.

Packing and Unpacking Arguments

In Python, the asterisk * is used for packing and unpacking arguments, which allows for more flexible argument passing to functions.

Positional

When defining a function, use *args to pack all positional arguments into a tuple. This is useful when you don’t know how many arguments will be passed to your function.

def pack_args(*args):
    print("Number of arguments:", len(args))
    for index, item in enumerate(args):
        print("{}: {}".format(index,item))

pack_args(1, 2, 3, 4)  # Output: (1, 2, 3, 4)

Number of arguments: 4
0: 1
1: 2
2: 3
3: 4

You can mix regular arguments with *args in function definitions. Regular arguments are assigned first, and the rest are captured by *args.

def mixed_arguments(first, *args):
    print("First argument:", first)
    print("Other arguments:", args)

mixed_arguments(1, 2, 3, 4)  

First argument: 1
Other arguments: (2, 3, 4)

Keyword

While *args packs positional arguments, **kwargs packs keyword arguments, which are placed into a dictionary.

def greet_all(**kwargs):
    for key, value in kwargs.items():
        print("{}: {}".format(key,value))

greet_all(John="Hello", Alice="Hi")

John: Hello
Alice: Hi

Unpacking (exploding) Arguments

Outside of a function definition, we can use * and ** to unpack (explode) arguments to be sent to a function.

def greet(first, last):
    print("Hello {} {}!".format(first,last))

alist = ['Condoleezza','Rice']
adict = {'first': 'Edward', 'last': 'Sorin' }
greet(*alist)
greet(**adict)

Hello Condoleezza Rice!
Hello Edward Sorin!

Pass by Reference

As a reminder, everything in Python is an object. When we pass arguments to a function, the reference to the object is passed. So if a mutable object is passed to a function, any changes to that object within the function will be reflected outside of the function.

In Python, a side effect refers to any change that a function makes to its state or the global program state, in addition to its return value. Typically, side effects emerge from modifying a global variables or changing mutatable arguments (e.g., a list or dictionary passed to a function).

An interesting case arises when a mutable object is used a default parameter. In the following function f, a naive reading would assume that a new list is created everytime f is called.

def f(a = [], b = 2.34 * 500):
    a.append("test")
    print("b's identifier: ", id(b))
    return a

In actuality, the Python interpreter only evaluates the default arguments once - most likely when the function itself is evaluated and then stored for future use.

print(f())
print(f())

b's identifier:  4581675664
['test']
b's identifier:  4581675664
['test', 'test']

Since the identifier for b remains constant, we can safely conclude that the interpreter only evaluates the expression 2.34 * 500 once. That expression was explicitly chosen over something like 1, which the Python intrepeter optimizes for performance.

Also, you’ll see that the side effect of appending “test” to a occurs and that the default value for a remains unchanged through subsequent calls.

Functions are First-class Citizens

Since everything in Python is an object, functions are also objects. Primarily, this means we can assign functions to varables. In turn, this allows us to store them in functions, pass them as arguments, and return them from functions.

 def greet(name):
    return "Hello, {}!".format(name)

greet_function = greet
print(greet_function("Alice")) 

Hello, Alice!

def shout(text):
    return text.upper()

def whisper(text):
    return text.lower()

def greet(style, name):
    return style(name)

print(greet(shout, "Hello"))
print(greet(whisper, "Hello"))

HELLO
hello

Inner functions

As we saw in the Recursion notebook with wrapper functions, we can define a function within another function. These functions are often used for organization, encapsulation, or to create closures. In a future notebook, We’ll also see how they are used to create decorators.

def outer_function(text):
    # This is the outer enclosing function

    def inner_function():
        # This is the nested inner function
        return text.upper()

    # The outer function returns the result of the inner function
    return inner_function()

result = outer_function("hello")
print(result) 

HELLO

Closures

Inner functions can also create closures in Python. A closure in Python is a function object that remembers values in enclosing scopes. It’s a record that stores a function together with an environment: a mapping associating each free variable of the function with the value or reference to which the name was bound when the closure was created. A closure occurs when:

1. A nested function references a value in its enclosing scope.

2. The enclosing function returns the nested function.

def outer_function(text):
    
    def inner_function():
        return text

    return inner_function

# Create a closure
my_closure = outer_function("Hello, world!")
print(my_closure())

Hello, world!

Key Points of a Closure

1. Enclosure: The inner function inner_function is enclosed within the scope of outer_function.

2. Environment: inner_function remembers the environment in which it was created. In this case, it remembers the value of the variable text.

3. Persistence: Even after outer_function has finished executing, my_closure retains the information about the variable text.

Advantages of Closures

1. Data Hiding: Closures can prevent data from being modified unintentionally.

2. Function Factories: Closures can generate functions tailored to specific needs.

3. Maintaining State: Closures can persist state across function calls without using global variables.

Function Factory

Suppose we want to create a function that multiplies a number by a specific factor. We can use a closure to create a factory for such functions:

def multiplier_factory(n):
    def multiplier(x):
        return x * n
    return multiplier

double = multiplier_factory(2)
triple = multiplier_factory(3)

print(double(5)) 
print(triple(5)) 

10
15