03-Python Functions

Understand function arguments, print parameters, packing/unpacking, mutable defaults, and variable scope LEGB resolution.

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:

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

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

---

Back to Top ↑

Function Arguments: Positional and Keyword passing

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

1. Positional Arguments: Matched by position (order).
2. 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))

---

Back to Top ↑

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=" ")

---

Back to Top ↑

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.

---

Back to Top ↑

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.

---

Back to Top ↑

Variable Scope

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

1. Local – Inside the current function.
2. Enclosing – Inside nested/enclosing functions.
3. Global – At the top level of the module.
4. 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

1

---

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

2

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()

---

Back to Top ↑

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

---

Back to Top ↑

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