In our exploration of functions, we’ve focused on how to organize code within a single file to be more reusable and DRY (Don’t Repeat Yourself). But as a project grows from a few dozen lines to hundreds or thousands, even a well-organized single file becomes a problem. It can be hard to navigate, difficult to … Read more
In Post #106 and Post #107, we explored lambda functions—Python’s tool for creating small, anonymous one-liners. We saw that they are particularly useful as arguments for higher-order functions like sorted(), map(), and filter(). This naturally leads to a question of style and best practice: when should you use a concise lambda, and when should you … Read more
In Post #106, we introduced lambda functions as a way to create small, anonymous, one-line functions. We mentioned that their primary purpose is to be used as quick, “throwaway” functions that are passed as arguments to higher-order functions. In this post, we’ll see exactly what that means. We will explore three of Python’s most common … Read more
So far, we have been defining our functions using the def keyword. This is the standard way to create named, multi-line functions, and it’s perfect for most tasks. However, sometimes you need a very simple function that performs just one small operation, and you may only need to use it in one specific place. For … Read more
In Post #104, we learned that functions in Python are “first-class citizens,” meaning they can be treated like any other object—assigned to variables, stored in lists, and even passed to other functions. This flexibility allows for some powerful structural patterns, one of which is the ability to define a function inside of another function. In … Read more
So far, we’ve thought of functions as blocks of code—like recipes that we define and call upon to perform a task. But in Python, they are much more than that. Python treats functions as first-class citizens, which is a profound concept that unlocks many advanced and elegant programming patterns. In this post, we’ll explore what … Read more
In our journey through functions, we’ve encountered several types of parameters: standard positional parameters, parameters with default values (Post #89), the catch-all *args (Post #101), and the catch-all **kwargs (Post #102). A natural question arises: “Can we use all of these in a single function?” The answer is yes! But Python is very strict about … Read more
In Post #101, we learned how to use *args to create flexible functions that can accept any number of positional arguments, which Python then collects into a tuple. But what about keyword arguments? Is there a way to write a function that can handle any number of named arguments that we don’t know about in … Read more
So far, every function we’ve written has had a fixed number of parameters. A function defined with def my_func(a, b): requires exactly two arguments, no more and no less. But many real-world problems require more flexibility. Think about Python’s built-in print() function. You can give it one argument (print(“hello”)), or five (print(1, 2, 3, 4, … Read more
In Post #99, we learned how to use docstrings to document what our functions do, including what kind of data they expect as parameters. This is a great practice for human readers. Modern Python, however, offers a more formal and powerful way to annotate our code with this information. In this landmark 100th post, we’ll … Read more