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 Definition Syntax — Introduces the `def` keyword, naming conventions, parameters, and the function header.
Function Body and Indentation — Explains that the function body must be indented and contains the execution logic.
Function Call Execution — Demonstrates how to call a function by passing arguments and traces the execution flow line by line.
Single Responsibility Principle — Discusses the best practice of having one job per function and refactors the example to separate calculation from printing.
Namespaces and Local Scope — Explains global and local namespaces and why accessing an internal variable outside the function fails.
The Return Statement — Shows how `return` passes a value back to the caller before the local namespace is destroyed.
Local Namespace Purpose — Illustrates how local namespaces prevent naming conflicts with existing global variables.

PDF notes

Bottom line: You will be able to define, call, and structure Python functions effectively using parameters and arguments. You will also understand how Python uses global and local namespaces to manage variable scope and ensure function predictability.

This lesson on Python Functions is hands-on and example-driven. You will be able to define, call, and structure Python functions effectively using parameters and arguments. You will also understand how Python uses global and local namespaces to manage variable scope and ensure function predictability.

What You'll Be Able To Do

Define a function using the def keyword, name, and parameters.
Trace the execution flow of a function call, distinguishing arguments from parameters.
Implement the Single Responsibility Principle by separating calculation from output.
Use the return statement to pass values from a function back to the calling program.
Explain why local variables are inaccessible outside the function call.
Structure code to avoid naming conflicts using Python's namespace system.

Detailed Concept Walkthrough

1. Defining and Calling Functions

Functions are reusable blocks of code defined using def. Defining a function only registers it; execution only occurs when the function is explicitly called.

Syntax Rule: The function header starts with def, followed by the function name, parentheses containing parameters, and ends with a colon.
Execution Flow: When Python encounters the def line, it memorizes the function definition (name, parameters, body) but does not execute the body yet.
Mechanism: A function call triggers execution, assigning input arguments (values) to the function's defined parameters (variables).
Best Practice: The function body must be indented by one tab or four spaces; unindented code is not considered part of the function.

def calculate_rect_area(length, width): # Header defines parameters
    area = length * width # Body is indented
    return area

# Function call provides arguments
result = calculate_rect_area(14, 10)
print(result)

Key Takeaway: Definition registers the function; calling it executes the body.

2. Single Responsibility and Return

The Single Responsibility Principle (SRP) states that a function should have exactly one job. Use the return statement to pass results back to the caller, separating calculation from output.

Best Practice: A function should focus on calculation or processing; external actions like printing should be handled by the main program.
Mechanism: The return statement immediately exits the function and passes the specified value back to the point where the function was called.
Execution Flow: The function call expression evaluates to the returned value, which must be captured by a variable if it is needed later in the program.

def calculate_area(l, w):
    return l * w # Only calculates and returns

area = calculate_area(5, 5)
print(f"Area is {area}.") # Output handled externally

Key Takeaway: Functions should calculate or process data, not handle external output like printing.

3. Namespaces and Variable Scope

Namespaces are organizational systems Python uses to track variable names and values, preventing naming conflicts and ensuring function predictability.

Under the Hood: Variables defined outside any function reside in the global namespace and are called global variables.
Under the Hood: When a function is called, Python creates a temporary local namespace to store parameters and variables defined inside the function (local variables).
Mechanism: When a function finishes (or returns), its local namespace is destroyed, making local variables inaccessible outside the function call.
Execution Flow: Python checks the local namespace first for a variable name; if not found, it checks the global namespace.

global_area = 200

def calc(l, w):
    local_area = l * w # Local variable
    return local_area

result = calc(10, 10)
# print(local_area) # Error: local_area is destroyed
print(global_area) # 200 (unmodified)

Key Takeaway: Local variables are temporary and destroyed upon function completion; global variables persist.

Topics Covered in Python Functions

Function Definition Syntax (0:00 - 0:45) — Introduces the def keyword, naming conventions, parameters, and the function header.
Function Body and Indentation (0:45 - 1:15) — Explains that the function body must be indented and contains the execution logic.
Function Call Execution (1:15 - 2:00) — Demonstrates how to call a function by passing arguments and traces the execution flow line by line.
Single Responsibility Principle (2:00 - 3:00) — Discusses the best practice of having one job per function and refactors the example to separate calculation from printing.
Namespaces and Local Scope (3:00 - 4:30) — Explains global and local namespaces and why accessing an internal variable outside the function fails.
The Return Statement (4:30 - 5:30) — Shows how return passes a value back to the caller before the local namespace is destroyed.
Local Namespace Purpose (5:30 - 6:30) — Illustrates how local namespaces prevent naming conflicts with existing global variables.

Python Cheat Sheet

def function_name(param1, param2): — Defines a new function header and parameters
```
def calc_area(l, w):
```
Indentation — Marks the code block belonging to the function body
```
area = l * w
```
return value — Exits function and passes value back to caller
```
return area
```
Parameters — Variables listed in the function header definition
```
def func(length, width):
```
Arguments — Actual values passed during the function call
```
func(14, 10)
```
Global Namespace — Stores variables defined outside any function
```
unit = "feet squared"
```
Local Namespace — Stores parameters and variables defined inside functions

Comparison Table

Concept	Location/Definition	Lifespan/Role
Parameter	Function header definition	Placeholder for input
Argument	Function call expression	Actual value passed
Global Variable	Outside any function	Persists throughout program
Local Variable	Inside function/Local Namespace	Destroyed on return

Common Pitfalls

Mistake: Trying to access a variable created inside a function from the main program. Avoid: Use a return statement to explicitly pass the value back.
Mistake: Defining a function that calculates a value and also prints the result. Avoid: Follow SRP; let the function calculate and the main program handle output.
Mistake: Assuming Python executes the function body immediately upon definition. Avoid: Remember definition only registers the function; execution requires a function call.
Mistake: Relying on a function to modify a global variable directly. Avoid: Use the return value to update global variables in the main program.

FAQs

What is the difference between a parameter and an argument? Parameters are the variable names defined in the function header; arguments are the actual values passed during the function call.
Why are local variables destroyed after the function returns? This prevents naming conflicts and ensures the function does not unintentionally modify variables defined elsewhere in the program, upholding SRP.
Can a function access a global variable? Yes, Python checks the global namespace if a variable name is not found within the function's local namespace.

Common pitfalls

Mistake: Trying to access a variable created inside a function from the main program. Avoid: Use a `return` statement to explicitly pass the value back.
Mistake: Defining a function that calculates a value and also prints the result. Avoid: Follow SRP; let the function calculate and the main program handle output.
Mistake: Assuming Python executes the function body immediately upon definition. Avoid: Remember definition only registers the function; execution requires a function call.
Mistake: Relying on a function to modify a global variable directly. Avoid: Use the return value to update global variables in the main program.

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 defaf 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 calcul rect area. Next, we follow the function's name with parenthesis. Inside these parenthesis, 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 functions name and inputs, is known as the functions 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 functions 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 parenthesis. Inside the parenthesis, 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 functions header. Here, Python memorizes the name of the function, its inputs, and the code in the functions 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 functions 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 functions header are called parameters. Once the arguments have been assigned to the parameters, Python executes the functions 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 squared, 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 functions 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 name space 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 a 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 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 name space. 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 name space, 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 names defined in the function header; arguments are the actual values passed during the function call.

Why are local variables destroyed after the function returns?

This prevents naming conflicts and ensures the function does not unintentionally modify variables defined elsewhere in the program, upholding SRP.

Can a function access a global variable?

Yes, Python checks the global namespace if a variable name is not found within the function's local namespace.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.