Flexible Function Interfaces

Up to now, our functions have had a rigid structure: a fixed number of inputs, each with a predefined name. But what if you need to write a function that can accept any number of coordinates? Or a function that processes spatial features with a completely unpredictable set of attributes?

In this section, we will unlock the power of flexible function interfaces and anonymous functions.

1. Collecting Positional Arguments with *args¶

Imagine you want to write a function that calculates the average elevation from a set of GPS points. You don’t know in advance if the user will provide 3 points, 10 points, or 100 points.

You could force the user to put all the points into a single list before passing them to the function. But Python offers a cleaner way: the unpacking operator (*).

When you place an asterisk before a parameter name in a function definition, Python collects an arbitrary number of positional arguments into a tuple. By convention, we name this parameter *args.

2. Collecting Keyword Arguments with kwargs¶

Just as *args collects unknown positional arguments, kwargs collects an arbitrary number of keyword arguments.

This is incredibly useful in spatial data science when dealing with metadata. A geographic point must have a latitude and longitude, but it might also have an elevation, a Coordinate Reference System (CRS), a name, or a category.

When you place a double asterisk before a parameter name (conventionally kwargs), Python collects any remaining keyword-value pairs into a dictionary.

3. Unpacking Collections¶

The asterisk operators can also be used outside of function definitions to do the opposite: unpacking a collection into separate variables.

Consider a bounding box stored as a list of four coordinates:

[min_x, min_y, max_x, max_y]. If you have a function that expects four separate arguments, you can use the * operator to unpack the list directly into the function call.

Unpacking Dictionaries with ``¶

You can use the double asterisk (``) to unpack a dictionary directly into a function’s keyword arguments. For this to work, the keys in your dictionary must match the parameter names in the function exactly.

Imagine you have a function to style and plot a map marker, and your styling data is stored in a dictionary:

Notice how Python automatically matches the "lat" key in the dictionary to the lat parameter in the function!

Advanced Unpacking¶

You can also use the asterisk to elegantly split lists into variables. Notice how the *rest variable below scoops up everything in the middle of the list:

Concept Check: The Unpacking Explosion¶

You have a mapping function plot_station(name, lat, lon, elevation) and a dictionary containing your metadata:

station_data = {"name": "Zugspitze", "lat": 45.93, "lon": 7.86, "elevation": 4600}

How do you pass this dictionary to the function so that each key automatically maps to the correct parameter?

A) plot_station(*station_data)

B) plot_station(station_data)

C) plot_station(station_data)

The Dual Nature of Asterisks¶

The hardest part about * and `` is that they do the exact opposite depending on where you use them.

1. When DEFINING a function (Packing): If you put an asterisk in the def statement (e.g., def my_func(*args)), it acts like a vacuum. It sucks up many loose arguments and packs them tightly into a single tuple (or dictionary for ``).

2. When CALLING a function (Unpacking): If you put an asterisk in the function call (e.g., my_func(*my_list)), it acts like an explosion. It takes a packed collection (like a list or dictionary) and blows it apart into many separate, loose arguments.

4. The Lambda Function¶

Sometimes you need a tiny, single-use function for a quick operation (like extracting a value or formatting text). Defining a full function block with def and return can feel like overkill if you are only going to use it once.

For these situations, Python offers lambda functions. A lambda function is a small, anonymous function (a function without a name) written in a single line. It evaluates an expression and automatically returns the result.

The syntax is: lambda arguments: expression

Because they are nameless, you should not assign a lambda to a variable. Instead, lambdas shine brightest when you pass them directly into other functions or methods that require a function as an argument.

A perfect example is sorting a list of dictionaries. If you have a list of metadata dictionaries, you can use a lambda function to quickly sort them by a specific key in just one line.

numbers = [1200, 400, 850]
numbers.sort() 
# Result: [400, 850, 1200]

stations = [
    {"name": "Station A", "elevation": 1200},
    {"name": "Station B", "elevation": 400},
    {"name": "Station C", "elevation": 850}
]

# 1. We write a function that takes ONE dictionary and returns its elevation
def get_elevation(station_dict):
    return station_dict["elevation"]

# 2. We hand that function to the sort method
stations.sort(key=get_elevation)

stations.sort(key=lambda station: station["elevation"])

[
    {'name': 'Station B', 'elevation': 400}, 
    {'name': 'Station C', 'elevation': 850}, 
    {'name': 'Station A', 'elevation': 1200}
]

5. Exercises¶

Test your understanding of flexible interfaces!

Exercise 1: The Trail Aggregator (Core)¶

Write a function called total_trail_distance() that accepts any number of trail segment lengths (in kilometers) using *args. It should return the total summed distance of the trail.

def total_trail_distance(*segments):
    # 'segments' is a tuple of all provided arguments
    return sum(segments)

# Testing the function with 4 segments
print(total_trail_distance(5.2, 3.1, 4.0, 1.5))

Exercise 2: Building GeoJSON Properties (Stretch)¶

In web mapping, spatial features use a format called GeoJSON, which stores data in a "properties" dictionary. Write a function create_feature(name, kwargs) that takes a required name and any number of keyword arguments. It should return a dictionary formatted like this: {"name": name, "properties": {all_the_kwargs}}

def create_feature(name, **kwargs):
    # kwargs is automatically a dictionary containing the extra arguments
    feature = {
        "name": name,
        "properties": kwargs
    }
    return feature

# Testing the function
site = create_feature("Site 42", status="active", soil_type="clay", ph=6.5)
print(site)

Exercise 3: Lambda Sorting (Challenge)¶

You have a list of coordinate pairs: coords = [[8.54, 47.37], [6.14, 46.20], [7.44, 46.94]]. Using the .sort() method and a lambda function, sort this list based only on the latitude (the second item in each pair, index 1).

coords = [[8.54, 47.37], [6.14, 46.20], [7.44, 46.94]]

# The lambda takes one item (a coordinate pair like [8.54, 47.37]) 
# and returns index 1 (the latitude) to use as the sorting key
coords.sort(key=lambda pair: pair[1])

print(coords)
# Output should be ordered by latitude: Geneva, Bern, Zürich

6. Summary¶

In this section, you learned how to break free from rigid function definitions:

• *args: Collects an arbitrary number of positional arguments into a tuple.

• kwargs: Collects an arbitrary number of keyword arguments into a dictionary, perfect for flexible metadata.

• Unpacking (*): Extracts items from lists or dictionaries directly into function arguments or separate variables.

• Lambda functions: Provide a concise, one-line syntax for simple operations, often used as arguments inside other functions.

What comes next?¶

Next, we will look at how to construct Professional Functions by focusing on standard documentation (docstrings), introspection (help()), and learning how to avoid the most common function-related bugs in data science pipelines.