As we write more functions, our programs become more complex. While our code might make perfect sense to us the moment we write it, it can be nearly incomprehensible to others—or even to ourselves six months from now. Good code is not just code that works; it’s code that is understandable. In this post, we’re … Read more
In our previous posts on scope (Post #94, #95, and #96), we’ve seen that variables can exist in different “workspaces”—primarily the local scope inside a function and the global scope outside of any function. But what happens when you use a variable name? How does Python decide which variable you’re referring to, especially if the … Read more
In Post #96, we ran into a puzzle. When we tried to change a global variable from inside a function, we instead created a new “shadow” local variable, and the original global variable remained untouched. This is Python’s default behavior, designed to protect your global scope from accidental changes by functions. But what if you … Read more
In Post #95, we did a deep dive into the “local scope”—the private, temporary workspace inside a function. We learned that local variables are created when a function is called and destroyed when it finishes. Now, let’s zoom out from the “inside of the box” to look at the big picture. In this post, we’ll … Read more
In Post #94, we introduced the concept of variable scope and made a key distinction between the “outside” global scope and the “inside” local scope of a function. We saw that variables created inside a function are hidden from the outside world, creating a protective boundary. In this post, we will take a closer look … Read more
In our journey through Part 4, we’ve learned how to pass data into functions as arguments and get data out of them using return. Now we need to ask a fundamental question: what happens to the variables we create inside a function? Where do they live, and who can see them? This brings us to … Read more
In Post #91, we learned how to use the return statement to send a single value back from a function. In Post #92, we saw that if we don’t return anything, the function implicitly returns None. This covers returning one value or no value, but what if a function needs to send back multiple pieces … Read more
In Post #91, we learned how to use the return statement to send a calculated value back from a function. This is essential for functions that are designed to produce a result that can be stored in a variable or used in further calculations. But this raises an interesting question: what about the functions we … Read more
Up to this point, our custom functions have performed actions—they’ve printed banners or messages to the console. They do things, but they don’t give us anything back that we can store and use later in our program. What if we want a function to perform a calculation and hand us the result? How do we … Read more
This post covers what is arguably one of the most famous and confusing “gotchas” in the Python language. In Post #89, we learned how to use default parameter values, which is a fantastic feature for making functions more flexible. However, using a mutable type (like a list or a dictionary) as a default can lead … Read more