Python Functions

Understanding how Python passes arguments, manages variables/scopes, and executes functions behind the scenes will help you write more predictable, efficient, and bug-free code.

Topics Covered

In this module, you’ll learn:

Function Arguments: Positional vs Keyword argument passing
Print formatting: sep and end parameters
Packing and Unpacking: * and ** operators, *args, and **kwargs
Mutable Default Arguments Pitfall
Variable Scope and resolution (LEGB rule, global and nonlocal keywords)

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

Function Arguments: Positional and Keyword passing

When calling functions, you can pass arguments in two ways:

Positional Arguments: Matched by position (order).
Keyword Arguments: Matched by parameter name.

def display_profile(name, age):
    print(f"Name: {name}, Age: {age}")

# Positional passing
display_profile("Alice", 25)

# Keyword passing (order does not matter)
display_profile(age=25, name="Alice")

Output ?

Show Output

Name: Alice, Age: 25
Name: Alice, Age: 25

All positional arguments must appear before keyword arguments.

# Valid
display_profile("Alice", age=25)

# Invalid - raises SyntaxError
# display_profile(name="Alice", 25)

Output ?

Show Output

Name: Alice, Age: 25

Exercise 1

Create a function divide(a, b) and call it using keyword arguments such that b is passed first.

Solution

def divide(a, b):
    return a / b

print(divide(b=5, a=10))

Print Formatting Parameters: `sep` and `end`

The print() function contains two special parameters that format how text is displayed:

sep: Specifies the separator character placed between multiple arguments (defaults to a space " ").
end: Specifies what character is printed at the very end of the output (defaults to a newline "\n").

print("Python", "FastAPI", "Uvicorn", sep=" | ")
print("Hello", end=" ")
print("World")

Output

Show Output

Python | FastAPI | Uvicorn
Hello World

Exercise 1

Print three words separated by a hyphen - using sep.

Solution

print("one", "two", "three", sep="-")

Exercise 2

Print numbers from 1 to 5 on the same line separated by spaces using a for loop and the end argument.

Solution

for i in range(1, 6):
    print(i, end=" ")

Packing and Unpacking

Python provides the * and ** operators to pack or unpack values during function calls and parameter definitions.

Packing with `*args` and `**kwargs`

*args (Positional Packing): Collects extra positional arguments into a tuple.
**kwargs (Keyword Packing): Collects extra keyword arguments into a dictionary.

def func(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

func(1, 2, name="Alice", age=25)

Output

Show Output

args: (1, 2)
kwargs: {'name': 'Alice', 'age': 25}

Unpacking arguments

You can expand lists/tuples/sets using * and dictionaries using ** while calling functions.

def add(x, y, z):
    return x + y + z

nums = [1, 2, 3]
print(add(*nums))

details = {"x": 10, "y": 20, "z": 30}
print(add(**details))

Output ?

Show Output

6
60

Exercise 1

Write a function sum_all(*args) that sums all positional arguments passed to it.

Solution

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4))

Exercise 2

Explain the difference between func(*list_val) and func(list_val).

Solution

func(*list_val) unpacks each element of list_val as a separate positional argument.
func(list_val) passes the entire list as a single positional argument.

Mutable Default Argument Pitfall

When defining a function, default arguments are evaluated only once when the function is defined, not when it is called. If you use a mutable default argument (like a list or a dictionary) and modify it inside the function, those modifications persist across subsequent calls.

def add_item(item, basket=[]):
    basket.append(item)
    return basket

print(add_item("Apple"))
print(add_item("Banana"))

Output

Show Output

['Apple']
['Apple', 'Banana']

The Clean Solution

Use None as the default value and instantiate a new mutable object inside the function if needed.

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add_item("Apple"))
print(add_item("Banana"))

Output

Show Output

['Apple']
['Banana']

Exercise 1

Predict the output of the following code:

def add_to_dict(key, value, my_dict={}):
    my_dict[key] = value
    return my_dict

print(add_to_dict("a", 1))
print(add_to_dict("b", 2))

Output ?

Show Output

{'a': 1}
{'a': 1, 'b': 2}

Solution

{'a': 1}
{'a': 1, 'b': 2}

Because the default dictionary my_dict={} is mutable, modifications persist across subsequent function calls.

Variable Scope

A variable’s scope determines where it can be accessed in a program. Python resolves variables using the LEGB Rule:

Local – Inside the current function.
Enclosing – Inside nested/enclosing functions.
Global – At the top level of the module.
Built-in – Built-in functions and names (e.g., print, len).

Local Scope

Variables defined inside a function belong to the local scope of that function and cannot be accessed outside.

def calculate():
    result = 100
    print("Inside:", result)

calculate()
# print(result)  # NameError: name 'result' is not defined

Output ?

Show Output

Inside: 100

Global Scope

Variables defined at the top level of a file are global and can be read from anywhere inside that file.

message = "Global Message"

def show():
    print(message)

show()

Output

Show Output

Global Message

The `global` Keyword

To modify a global variable inside a function, you must declare it using the global keyword.

count = 0

def increment():
    global count
    count += 1

increment()
print(count)

Output

Show Output

Enclosing Scope and the `nonlocal` Keyword

When you nest functions, the outer function’s scope is the enclosing scope for the inner function. To modify a variable in the enclosing scope, use nonlocal.

def outer():
    count = 10

    def inner():
        nonlocal count
        count += 5
        print("Inner count:", count)

    inner()
    print("Outer count:", count)

outer()

Output

Show Output

Inner count: 15
Outer count: 15

Exercise 1

Predict the output of the following code:

x = 50

def func():
    global x
    x = 2
    
func()
print(x)

Output ?

Solution

The global x statement inside func() makes any assignment to x modify the global variable x.

Exercise 2

Write a nested function where the inner function increments a variable defined in the outer function’s scope by 1 and prints it.

Solution

def counter():
    val = 0
    def step():
        nonlocal val
        val += 1
        print(val)
    return step

my_step = counter()
my_step()

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice local and global scope resolution, LEGB rules, sep and end parameters, arguments packing/unpacking, and mutable default arguments.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned how Python manages variables, scopes, function parameters, and execution behind the scenes.

Key Concepts Covered

Positional vs Keyword function argument passing
print parameters sep and end
Packing and Unpacking with * and ** operators
The mutable default argument pitfall and its solution
LEGB Variable scopes and scope resolution
The global and nonlocal keywords

Adv. Python & FastAPI Workshop

03-Python Functions

Python Functions

Topics Covered

Function Arguments: Positional and Keyword passing

Exercise 1

Print Formatting Parameters: `sep` and `end`

Exercise 1

Exercise 2

Packing and Unpacking

Packing with `*args` and `**kwargs`

Unpacking arguments

Exercise 1

Exercise 2

Mutable Default Argument Pitfall

The Clean Solution

Exercise 1

Variable Scope

Local Scope

Global Scope

The `global` Keyword

Enclosing Scope and the `nonlocal` Keyword

Exercise 1

Exercise 2

Practice

Follow-Along Practice

Summary

Key Concepts Covered

​Python Functions

​Topics Covered

​Function Arguments: Positional and Keyword passing

​Exercise 1

​Print Formatting Parameters: sep and end

​Exercise 1

​Exercise 2

​Packing and Unpacking

​Packing with *args and **kwargs

​Unpacking arguments

​Exercise 1

​Exercise 2

​Mutable Default Argument Pitfall

​The Clean Solution

​Exercise 1

​Variable Scope

​Local Scope

​Global Scope

​The global Keyword

​Enclosing Scope and the nonlocal Keyword

​Exercise 1

​Exercise 2

​Practice

Follow-Along Practice

​Summary

​Key Concepts Covered

Python Functions

Topics Covered

Function Arguments: Positional and Keyword passing

Exercise 1

Print Formatting Parameters: `sep` and `end`

Exercise 1

Exercise 2

Packing and Unpacking

Packing with `*args` and `**kwargs`

Unpacking arguments

Exercise 1

Exercise 2

Mutable Default Argument Pitfall

The Clean Solution

Exercise 1

Variable Scope

Local Scope

Global Scope

The `global` Keyword

Enclosing Scope and the `nonlocal` Keyword

Exercise 1

Exercise 2

Practice

Summary

Key Concepts Covered