A closure is a function defined inside another function that "captures" variables from the outer function's scope. The inner function carries those captured values with it, even after the outer function has returned.

Three ways to think about closures:

As functions with memory. A normal function only sees its parameters and globals. A closure additionally remembers values from the function that created it. That extra memory is what "closure" refers to — the inner function has "closed over" the outer function's variables.
As factories. The outer function is a recipe that produces customized inner functions. make_region_filter("California") doesn't do the filtering — it BUILDS a filter function pre-loaded with "California" inside. You can then call that built function many times.
As partial applications. You've taken a function that needs two inputs (region and event) and "frozen" one of them (region), getting back a function that only needs the other (event). Same idea as plugging in one of the arguments and leaving the rest open.

The classic use case makes it concrete. "Make me a filter for events in California" — you want a function that, given an event, says yes or no based on the event's region. Hard-coding California into the function makes it un-reusable. Closures let you build the function with the region "baked in":

def make_region_filter(region: str):
    def matches(event: dict) -> bool:
        # parse the region from the place string (M3 split technique)
        event_region = event["place"].split(", ")[-1]
        return event_region == region
    return matches

california_filter = make_region_filter("California")
alaska_filter = make_region_filter("Alaska")

california_filter({"place": "Mammoth Lakes, California"})    # True
california_filter({"place": "Adak, Alaska"})                  # False

The inner function matches refers to region — which is a parameter of the outer function. When make_region_filter("California") returns, the outer function is gone, but its parameter is preserved (closed over) by the returned matches function. california_filter "remembers" that region == "California" forever.

One trap to avoid: "California in event['place']" looks tempting but is wrong. Real-world USGS data has place strings like "5km W of Mammoth Lakes, CA" where the region is abbreviated — substring matching would miss all the California events. Splitting on ", " and taking the last part gives you the actual region; comparing with == gives you exact matches. This is the difference between code that works on test data and code that works on real data.

Where closures actually show up:

Factories, like the example above. "Make me a function that does X with a specific value baked in." Region filters, threshold checkers, currency converters at a fixed exchange rate.
Decorators, M10's entire subject. A decorator is a function that takes a function and returns a wrapped version — the wrapper is a closure over the original function. Once closures click, decorators are just "closures applied to functions."
Callbacks with context. When you pass a function to be called later (e.g. as a sort key, an event handler, or a worker for asynchronous code), closures let that function remember its setup context without you having to pass extra arguments through.