# Scope, Closures and Advanced Function Arguments in Python

Source: https://skills101.in/learn/python/python-scope-and-closures — Skills101 free tutorial (Python Programming). Updated 2026-11-21.

In the functions lesson you saw that variables made inside a function are **local**. This lesson goes one level deeper. You will learn exactly how Python decides which variable a name refers to, how an inner function can **remember** values (a **closure**), and the extra ways to define and pass arguments. Closures are also the base for **decorators**, which come in a later lesson.

## 1. The LEGB rule: where Python looks for a name

When your code uses a name like `rate`, Python searches **four places in order** and stops at the first match:

| Letter | Scope | What it holds |
|---|---|---|
| **L** | Local | names created inside the current function |
| **E** | Enclosing | names in any outer function that this function is inside |
| **G** | Global | names created at the top level of the file (module) |
| **B** | Built-in | names Python always has: `print`, `len`, `max`, … |

![Four nested boxes: Built-in outside, then Global, then Enclosing (outer function), then Local (inner function); Python searches from the innermost Local box outwards](https://skills101.in/learn-img/python/legb.svg)

```python
rate = "global rate"

def outer():
    rate = "enclosing rate"
    def inner():
        rate = "local rate"
        print(rate)
    inner()
    print(rate)

outer()
print(rate)
print(len("abc"))      # len is found in the built-in scope
```

```text
local rate
enclosing rate
global rate
3
```

Each `rate` is a **different variable**. Assigning to a name inside a function creates a local variable, unless you say otherwise.

A side effect of this rule: if you create a variable called `list` or `max`, it **hides** the built-in one until you delete it. Avoid using built-in names for your own variables.

## 2. global and nonlocal

Reading an outer variable is always allowed. **Assigning** to it needs a declaration:

- `global name` — assign to the module-level variable.
- `nonlocal name` — assign to the variable of the **nearest enclosing function**.

```python
visits = 0

def visit():
    global visits
    visits += 1

def make_counter():
    count = 0
    def increase():
        nonlocal count      # without this line: UnboundLocalError
        count += 1
        return count
    return increase

visit(); visit()
print("visits:", visits)
c = make_counter()
print(c(), c(), c())
```

```text
visits: 2
1 2 3
```

Why the error without `nonlocal`? `count += 1` assigns to `count`, so Python treats `count` as **local** in the whole of `increase`. Then it tries to read a local `count` that has no value yet.

Use `global` rarely. Code that passes values in and returns results is easier to test.

## 3. Closures: functions that remember

A **closure** is an inner function that **remembers** variables from the enclosing function, even after the enclosing function has finished running. `make_counter` above already made one. Here is another example: a shop that applies different discounts.

```python
def make_discount(percent):
    def apply(price):
        return price - price * percent / 100
    return apply

festival = make_discount(20)
student = make_discount(10)
print(festival(500), student(500))
print(festival.__closure__[0].cell_contents)
```

```text
400.0 450.0
20
```

`festival` and `student` are two separate functions. Each one keeps its own `percent` in a small storage area called a **cell**. You can see it through `__closure__`, though you will rarely need to.

![make_discount(20) returns the function apply, which carries a cell holding percent = 20; calling festival(500) uses that cell and returns 400.0](https://skills101.in/learn-img/python/closure-cell.svg)

Closures are useful when you want a small function with some settings "built in", without writing a full class.

## 4. The late-binding trap in loops

A closure remembers the **variable**, not the value it had at the time. Python looks up the value **when the inner function runs**. This is called **late binding**.

```python
funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])

fixed = []
for i in range(3):
    fixed.append(lambda i=i: i)   # default value is saved NOW
print([f() for f in fixed])
```

```text
[2, 2, 2]
[0, 1, 2]
```

All three lambdas in the first loop see the same `i`, which is `2` when they are finally called. A default argument value is evaluated when the function is **defined**, so `i=i` saves the current value.

## 5. Keyword-only and positional-only parameters

Two special markers in a parameter list control **how** arguments may be passed:

- Parameters **after `*`** must be passed by keyword.
- Parameters **before `/`** must be passed by position (Python 3.8+).

```python
def book_ticket(name, /, seats, *, ac=False):
    return f"{name}: {seats} seat(s), AC={ac}"

print(book_ticket("Asha", 2))
print(book_ticket("Ravi", seats=1, ac=True))
try:
    book_ticket("Neha", 1, True)
except TypeError as e:
    print("Error:", e)
```

```text
Asha: 2 seat(s), AC=False
Ravi: 1 seat(s), AC=True
Error: book_ticket() takes 2 positional arguments but 3 were given
```

Why use them? Keyword-only arguments make calls readable: `ac=True` is clearer than a bare `True`. Positional-only parameters let you rename a parameter later without breaking anyone's code, which is why many built-ins such as `len(obj, /)` use them.

## 6. Unpacking arguments with * and **

In a **call**, `*` spreads a list or tuple into positional arguments, and `**` spreads a dictionary into keyword arguments. It is the reverse of `*args` and `**kwargs` in a definition.

```python
def result(name, maths, science):
    return f"{name}: total {maths + science}"

row = ["Asha", 88, 92]
info = {"name": "Ravi", "maths": 70, "science": 81}
print(result(*row))
print(result(**info))

first, *middle, last = [10, 20, 30, 40, 50]
print(first, middle, last)
```

```text
Asha: total 180
Ravi: total 151
10 [20, 30, 40] 50
```

The last example is **extended unpacking**: `*middle` collects all the items that are left over into a list.

## Common mistakes

- Assigning to an outer variable without `global`/`nonlocal` and getting `UnboundLocalError`.
- Using `global` everywhere instead of returning values.
- Naming a variable `list`, `str` or `sum`, which hides the built-in.
- Creating lambdas in a loop and expecting each one to remember its own loop value.
- Forgetting that after a bare `*` in a definition, the remaining parameters must be passed by keyword.

## Quick recap

- Name lookup order: Local → Enclosing → Global → Built-in.
- `global` assigns to a module variable; `nonlocal` to the nearest enclosing function's variable.
- A closure is an inner function that keeps the enclosing variables alive.
- Closures look values up when called (late binding); use `x=x` to freeze a value.
- `*` in a definition → keyword-only after it; `/` → positional-only before it.
- In calls, `*seq` and `**dict` unpack arguments.


Practice quiz and free certificate: https://skills101.in/learn/python/python-scope-and-closures