Why aren't python nested functions called closures?

In Python, nested functions are indeed related to closures, but not all nested functions are closures. 

**Nested Functions:** When you define a function inside another function, the inner function is called a nested function. It can access variables from the enclosing (outer) function's scope.

**Closures:** A closure is a specific type of nested function that captures and remembers the environment in which it was created. For a nested function to be considered a closure, it must:

1. Be defined within another function (i.e., be a nested function).
2. Reference variables from the outer function's scope.
3. Be returned or used in such a way that it can be called later, maintaining access to the outer function's variables.

Here's a simple example of a closure in Python:

```python
def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # Outputs 15
```

In this example, `inner_function` is a closure because it captures the `x` value from `outer_function`, even after `outer_function` has finished executing.

So, while all closures are nested functions, not all nested functions necessarily become closures. For example, if a nested function does not capture any variables from its enclosing scope or is not returned from the enclosing function, it would not be considered a closure.