Python Functions

Understand how functions help you write reusable, modular code and make your analysis cleaner and scalable.

14 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Ready to continue?

Mark this lesson as complete when you're ready to proceed.

Key moments

Function Syntax and Headers — Covers def syntax, function naming conventions, parameter declarations, and indented body blocks.
Calling Functions and Argument Passing — Traces how function calls pass arguments into parameters and execute indented logic sequentially.
Single Responsibility Principle — Explains why isolating computation from printing improves function modularity and reusability.
Global vs Local Namespaces — Introduces namespaces and explains why local variables are inaccessible outside their parent function.
Returning and Capturing Values — Demonstrates using return statements to pass data out of local scope into calling variables.
Scope Isolation and Variable Shadowing — Illustrates how local namespaces prevent accidental mutation of identically named global variables.

PDF notes

Bottom line: You will be able to define modular Python functions with explicit parameters and return values while correctly navigating variable scope. You will write isolated, single-responsibility functions that prevent side effects and namespace pollution across your data engineering pipelines.

This lesson on Python Functions is hands-on and example-driven. You will be able to define modular Python functions with explicit parameters and return values while correctly navigating variable scope. You will write isolated, single-responsibility functions that prevent side effects and namespace pollution across your data engineering pipelines.

What You'll Be Able To Do

Define custom Python functions using the def keyword, parameters, and indented bodies.
Pass arguments by position to execute function logic and return calculated results.
Differentiate between global and local namespaces to avoid variable lookup and scope errors.
Refactor multi-action functions into single-responsibility units that isolate computation from display.

Detailed Concept Walkthrough

1. Function Definition and Execution Lifecycle

A function is a reusable, named block of code that encapsulates specific logic and executes only when explicitly called. It establishes a contract taking inputs as parameters and returning an output.

Syntax Rule: A function definition begins with the def keyword, followed by a descriptive function name, comma-separated parameters in parentheses, and a trailing colon. The internal body must be indented by one standard tab or four spaces.
Under the Hood: When Python reads the def statement, it memorizes the function header, signature, and body instructions into the current namespace without evaluating the internal calculations. The body executes only when a function call expression occurs.
Execution Flow: Calling a function pairs incoming argument values to declared parameters by position, executes the indented statements sequentially, and directs execution back to the caller upon completion.

# Define a function with two parameters
def calc_rect_area(length, width):
    area = length * width
    return area

# Call the function with arguments and capture the output
result = calc_rect_area(14, 10)
print(result)  # Outputs: 140

Key Takeaway: Defining a function registers its code for later execution, while calling it triggers parameter binding and statement evaluation.

2. The Single Responsibility Principle

Every function should perform exactly one task to maximize reusability, testability, and clarity. Combining distinct actions like computation and display couples logic and limits where that code can be used.

Best Practice: Separate calculation from output presentation by returning raw data from functions rather than calling print() internally. This allows the caller to format, log, or further transform the returned result as needed.
Mechanism: Coupling data processing with printing locks the output format and makes automated testing difficult. A dedicated calculation function remains purely analytical and versatile across pipelines.
Nuance: Descriptive naming (e.g., calc_rect_area) must accurately reflect all internal operations. If a function calculates and prints, its name becomes misleading.

# Antipattern: Mixed calculation and display
def calc_and_print_area(length, width):
    area = length * width
    print(f"{area} feet^2")  # Hardcodes presentation

# Best Practice: Single responsibility with return
def calc_rect_area(length, width):
    return length * width  # Pure calculation

unit = "feet^2"
total_area = calc_rect_area(14, 10)
print(f"{total_area} {unit}")  # Caller controls presentation

Key Takeaway: A function must have one unambiguous job and return its result so calling code controls formatting and downstream use.

3. Namespaces and Variable Lifecycles

Namespaces are internal mapping structures where Python organizes variable names and their current values during runtime. Scopes isolate function internals from global program state.

Mechanism: Variables declared at the script level reside in the global namespace, which persists throughout program execution. Calling a function spins up a separate, temporary local namespace for parameters and internal assignments.
Under the Hood: When a function completes execution, Python immediately destroys its local namespace. Any local variables not explicitly returned to the caller are discarded and cannot be accessed externally.
Execution Flow: During variable lookup, Python searches the local namespace first before falling back to the global namespace. Local assignments never overwrite identically named global variables without explicit instruction.

area = 200  # Global namespace

def calc_rect_area(length, width):
    area = length * width  # Local namespace
    return area

result = calc_rect_area(14, 10)
print(result)  # Prints local calculation: 140
print(area)    # Global variable remains unchanged: 200

Key Takeaway: Local namespaces isolate function execution and prevent accidental overwrites of global state.

4. Returning and Capturing Values

The return statement passes evaluated data out of a function's local namespace back to the invocation point before local memory is cleared. Callers must capture this value to use it downstream.

Mechanism: The return keyword terminates function execution immediately and delivers the specified expression back to the calling line. The function call itself evaluates to that returned value.
Execution Flow: To persist the returned output beyond the line of invocation, the caller must assign the function call expression to a variable. That receiving variable lives in the caller's namespace.
Syntax Rule: The capturing variable in the calling scope does not need to share a name with the internal variable used in the return statement.

def calc_rect_area(length, width):
    area = length * width
    return area  # Passes local value out

# Capture returned value in a distinct variable name
final_measurement = calc_rect_area(14, 10)
print(final_measurement)  # 140

Key Takeaway: Use return to extract values from transient local scope and assign the function call to persist that data.

Topics Covered in Python Functions

Function Syntax and Headers (0:00 - 0:45) — Covers def syntax, function naming conventions, parameter declarations, and indented body blocks.
Calling Functions and Argument Passing (0:45 - 1:25) — Traces how function calls pass arguments into parameters and execute indented logic sequentially.
Single Responsibility Principle (1:25 - 2:10) — Explains why isolating computation from printing improves function modularity and reusability.
Global vs Local Namespaces (2:10 - 3:00) — Introduces namespaces and explains why local variables are inaccessible outside their parent function.
Returning and Capturing Values (3:00 - 3:50) — Demonstrates using return statements to pass data out of local scope into calling variables.
Scope Isolation and Variable Shadowing (3:50 - 4:45) — Illustrates how local namespaces prevent accidental mutation of identically named global variables.

Python Cheat Sheet

def function_name(param1, param2): — Declares a function header with named input parameters
```
def calc_rect_area(length, width):
    return length * width
```
return value — Exits function and passes data back to caller
```
return length * width
```
var_name = function_name(arg1, arg2) — Calls function with arguments and stores returned result
```
area = calc_rect_area(14, 10)
```
Global Namespace — Stores module-level variables and top-level function definitions
```
unit = "feet^2"
area = 200
```
Local Namespace — Temporarily stores function parameters and internal variables
```
def calc(x):
    y = x * 2  # y is local
    return y
```

Comparison Table

Feature	Local Namespace	Global Namespace
Creation Time	Created upon function invocation	Created when script execution begins
Destruction Time	Destroyed when function exits	Destroyed when program terminates
Accessibility	Accessible only inside function	Accessible throughout entire script
Contents	Parameters and function-scoped variables	Top-level variables and function objects
Shadowing Priority	Evaluated first during lookups	Used as fallback if local missing

Common Pitfalls

Mistake: Accessing a local function variable from the global program scope. Avoid: Return the variable from the function and assign the call expression to a global variable.
Mistake: Printing results inside calculation functions instead of returning them. Avoid: Keep computation separate from I/O by returning computed values to the caller.
Mistake: Forgetting to capture a returned value in a variable. Avoid: Assign the function call directly to a variable to store its output in memory.
Mistake: Assuming calling def executes internal calculation logic immediately. Avoid: Remember def only registers definitions; explicitly invoke the function with arguments to run it.

FAQs

What is the difference between a parameter and an argument? Parameters are the variable placeholder names defined in the function header, while arguments are the actual concrete values passed into the function during a call.
Why does Python delete local variables when a function finishes? Deleting the local namespace frees up system memory and prevents naming collisions between different functions across your program.
Does the variable capturing a return value need to match the name inside the function? No, the caller can assign the returned value to any variable name in its own scope regardless of internal local naming.
What happens if a function accesses a variable not defined in its local namespace? Python searches outward into the global namespace to find and read the variable value if it exists there.

Common pitfalls

Mistake: Accessing a local function variable from the global program scope. Avoid: Return the variable from the function and assign the call expression to a global variable.
Mistake: Printing results inside calculation functions instead of returning them. Avoid: Keep computation separate from I/O by returning computed values to the caller.
Mistake: Forgetting to capture a returned value in a variable. Avoid: Assign the function call directly to a variable to store its output in memory.
Mistake: Assuming calling def executes internal calculation logic immediately. Avoid: Remember def only registers definitions; explicitly invoke the function with arguments to run it.

Want to create your own Python functions? Writing good functions requires more than just knowing the syntax. You need to truly understand how they work under the hood. In this video, we'll show you how to write functions and explore exactly how Python executes them behind the scenes. To get familiar with the syntax, let's define a simple function that calculates a rectangle's area and displays the result. In Python, we use the keyword def to define a new function. We follow this keyword with a name for our function. When naming a function, it is best to choose something descriptive that reflects the function's purpose. Since the purpose of our function is to calculate the area of a rectangle, let's name it calc_rect_area. Next, we follow the function's name with parentheses. Inside these parentheses, we specify the inputs our function needs to perform its task. Since calculating a rectangle's area requires its length and width, we write the variable names length and width as inputs, separated by a comma. Finally, we end the line with a colon. This first line, which specifies the function's name and inputs, is known as the function's header. After pressing enter at the end of the header, the code editor automatically indents the line. This is a feature, not a bug. After the header, the lines of code in a function must be indented by one tab. The indented code within a function is called the function's body. The function's body contains the code that does the heavy lifting, running calculations, and other steps to get the result we want. Any unindented code that appears after the function's body is not considered part of the function. Awesome. Let's now fill in the body of the function to calculate the area of a rectangle using the inputs. To calculate the area of a rectangle, we'll multiply length by width and store the result in a variable called area. Finally, after calculating the area, we display the result with a print statement. Awesome. Now that we've defined our calculate rectangle area function, we can use it in our program. To use the function, we write its name, followed by a pair of parentheses. Inside the parentheses, we write the inputs to our function. For example, to calculate the area of a rectangle with a length of 14 and a width of 10, we write 14, 10. Great. Now you know how to define and use your own functions. Running the cell, we get 140 in the output box. Our code works! But to really understand how Python executes functions, let's trace through the execution of the code line by line. When Python executes the code, it first runs our function's header. Here, Python memorizes the name of the function, its inputs, and the code in the function's body. To emphasize, Python is not calculating the area of any rectangles at this point. Python only memorizes the definition of the function so it can be used later. The actual execution of the calculate rectangle area function happens on the next line. When Python reaches this line, it recognizes that we want to use the calculate rectangle area function with the values 14 and 10 as inputs. In programming, we say that this line of code calls the function calculate rectangle area, passing 14 and 10 as arguments. A function call triggers the execution of its code. The execution begins by assigning the input values to the variables listed in the function's header. For example, this function call assigns 14 to the variable length and 10 to the variable width. In programming, the variable names specified in the function's header are called parameters. Once the arguments have been assigned to the parameters, Python executes the function's body. On the first line, Python calculates the area by multiplying 14 by 10 and assigns the result to the variable area. Finally, Python prints the area of the rectangle, 140. Great. You now understand how Python executes functions. As you can see, writing a Python function is straightforward. But to write functions that really add value, it's important to follow some best practices. One of those best practices is called the Single Responsibility Principle. As the name suggests, the Single Responsibility Principle states that each function should have exactly one job or responsibility. That's because when a function tries to do too many things at once, it becomes hard to understand, maintain, and reuse. Additionally, each function should have a name that clearly describes what it does. In our example, the function name calculate rectangle area suggests it should only calculate the area. It's not immediately clear from the name of the function that it also prints the area. To keep our function focused on calculation, let's move the print statement to the main program. This way, our function only calculates the area, and we can control how to print the results in the main program. For example, the main program could print the area along with a unit. This is a better way to structure our program, but there's a problem. If we run the cell, we get an error at the print statement. Python says the variable area is not defined. But we did create area inside the function, so why can't we use it? To answer this question, we need to understand how Python uses something called namespaces to track variables during a program's execution. A namespace is like a notebook where Python writes down variable names and their current values during execution. When Python runs a line of code like unit = feet^2, it doesn't just randomly store this information. It carefully organizes this data in memory. In Python's organization system, variables created outside of any function, like our unit variable, get placed in what is called a global namespace. Variables living in the global namespace are called global variables. But the global namespace doesn't just store variables. It also stores the names of any function we define in our main program. For example, during the execution of the next line, Python stores the name of the calculate rectangle area function and its code in the global namespace. But the global namespace is not the only place where Python can store names and values. In particular, during function calls, Python creates a new temporary namespace called a local namespace. Python uses this namespace to store the function's parameters and any variables defined inside it. For example, when Python calls the calculate rectangle area function, it assigns the arguments 14 and 10 to the parameters length and width in the local namespace. And when Python executes the body of the function, the variable area is also stored in the local namespace. Variables living in the local namespace, like length, width, and area, are called local variables. Now, here's the key to understanding our previous error message. When a function finishes executing and returns to the calling point, its local namespace is always destroyed. This means that the variables stored in the local namespace are no longer available after the program returns to the calling point. That's why when we tried to print the area variable outside the function, we got an error saying that area doesn't exist. Unlike global variables, local variables are temporary. They only exist during a function call. Awesome. Now that we understand what went wrong, let's see how to fix this. To display the calculated area while following the Single Responsibility Principle, we need to return the area back to the main program before the local namespace is destroyed. We can do this by using a return statement. A return statement starts with the keyword return, followed by the variable whose value we'd like to return to the main program. In our example, we want to pass back the value of area. During the execution of our program, when Python executes the return statement, the value of area is returned back to the calling point before the local namespace is discarded. In practice, this means that the function call expression evaluates to the return value, 140. To keep using the return value in the rest of our program, we need to capture it in a variable. Otherwise, the value will be lost once the program continues to the next line. For example, we can capture 140 by assigning it to a new variable called area. This creates a global variable containing 140. Running the cell, we no longer get an error. Note that we could capture the return value using any variable name. It doesn't need to match the name of the local variable returned by the function. By adding a return statement, our program can finally display the area of the rectangle while following the Single Responsibility Principle. But to do this, we had to work around the short lifespan of the local namespace. If local namespaces make it complicated to access variables, why does Python bother creating them? Wouldn't it be simpler if Python stored all names and values in the global namespace? At first glance, this might seem better. But using a single namespace could quickly lead to naming conflicts and unpredictable behavior as a program gets more complicated. To help us see this issue, let's create another area variable at the top of our program. Now let's trace the code assuming Python stores everything in the global namespace. Like before, the first two variable assignments and the function definition are stored in the global namespace. We first see the problem with using a single namespace when Python executes the function call. Without a local namespace, Python must put the parameters and their arguments in the global namespace. Since the length and width parameters don't already exist there, this works fine. But when Python executes the first line of the body, there's an issue. Since the area variable already exists in the namespace, Python would replace the original value, 200, with the new value, 140. But this is bad. The function now violates the Single Responsibility Principle. In addition to calculating the area, it also changes the value of a variable defined elsewhere in the program. If Python worked this way, any function call could have unintended consequences. This is why when a function is called, Python creates a local namespace. This way, when the first line of the function is executed, Python creates a new local area variable without modifying the global area variable. Finally, Python moves to the return statement. But at this point, there are two area variables with different values. Which area variable will Python choose to return? It's not immediately clear. By default, Python uses the local version of the area variable if it exists. This is the case here, so Python returns 140. But note that if a local area variable did not exist, Python would return the value of the global area variable, 200. If we print the value of area and run the code, we see that the calculate rectangle area function call does not change the original area value. The creators of Python designed local namespaces to help us write functions that serve a single purpose. Great. You now have a comprehensive understanding of how functions work in Python. If you want to practice what you've learned, we've created a notebook with a few exercises. We're also thinking about creating videos focused on exercises and walking through their solutions. If you would be interested in this, let us know in the comments below. We're working on lots more Python explainer videos like this one, so be sure to subscribe so that you don't miss out. If you found this video helpful, be sure to share it with a friend. And if you have any questions or topics that you'd like to learn about, let us know in the comments below. We'd love to hear from you. Thanks for watching.

Frequently asked questions

What is the difference between a parameter and an argument?

Parameters are the variable placeholder names defined in the function header, while arguments are the actual concrete values passed into the function during a call.

Why does Python delete local variables when a function finishes?

Deleting the local namespace frees up system memory and prevents naming collisions between different functions across your program.

Does the variable capturing a return value need to match the name inside the function?

No, the caller can assign the returned value to any variable name in its own scope regardless of internal local naming.

What happens if a function accesses a variable not defined in its local namespace?

Python searches outward into the global namespace to find and read the variable value if it exists there.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.