Python Scope, First-Class Functions, *args,**kwargs & Mutable Default Arguments

Python has several concepts that look difficult at first, but they become simple once we understand what Python is actually doing.

This guide covers:

• LEGB Scoping Rule
• Local, Enclosing, Global and Built-in scopes
• nonlocal
• First-Class Functions
• *args
• **kwargs
• Packing and Unpacking
• Mutable Default Argument Pitfall
• Safe ways to use default arguments

---

1. LEGB Scoping Rule

What is Scope?

Scope means the area of a program where a variable can be accessed.

For example:

def greet():
    name = "Deepika"
    print(name)

greet()

Here, name is created inside greet(), so it belongs to the local scope of that function.

Python follows a specific rule to find variables. This rule is called the LEGB rule.

• L → Local
• E → Enclosing
• G → Global
• B → Built-in

Python searches for a variable in this order:

Local
   ↓
Enclosing
   ↓
Global
   ↓
Built-in

Python stops searching as soon as it finds the variable.

---

2. L → Local Scope

A variable created inside a function is usually a local variable.

Example

def greet():
    name = "Deepika"
    print(name)

greet()

Here, name = "Deepika" is local to greet().

It cannot normally be accessed outside the function:

def greet():
    name = "Deepika"

print(name)

This gives a NameError because name only exists inside greet().

Simple Definition: Local scope is the scope inside the current function.

---

3. E → Enclosing Scope

The enclosing scope appears when one function is defined inside another function.

Example

def outer():
    name = "Deepika"

    def inner():
        print(name)

    inner()

outer()

Here, name is not inside inner(). It is inside outer().

Therefore, from the point of view of inner(), name is in the enclosing scope.

outer()
│
├── name = "Deepika"
│
└── inner()
       │
       └── print(name)

Simple Definition: Enclosing scope is the scope of an outer function surrounding the current inner function.

This concept is especially important when learning closures.

---

4. G → Global Scope

A variable created outside all functions is generally in the global scope.

Example

name = "Deepika"

def greet():
    print(name)

greet()

Python cannot find name inside greet(), so it looks in the global scope and finds it.

Local      → Not found
Enclosing  → Not found
Global     → Found!

Output:

Deepika

Simple Definition: Global scope is the scope outside functions and classes at the module level.

---

5. B → Built-in Scope

Python already provides many names that we can use directly.

Examples: print(), len(), sum(), max(), min(), type()

These names belong to Python's built-in scope.

Example

numbers = [10, 20, 30]

print(len(numbers))

For len, Python searches:

Local      → Not found
Enclosing  → Not found
Global     → Not found
Built-in   → Found!

Output:

3

Simple Definition: Built-in scope contains names that are provided by Python itself.

---

6. Complete LEGB Example

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        x = "Local"
        print(x)

    inner()

outer()

Output:

Local

Why? Because Python searches Local first and finds it there. It stops immediately and does not continue searching the enclosing, global, or built-in scopes.

---

7. Another LEGB Example

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        print(x)

    inner()

outer()

Output:

Enclosing

Why? Python searches:

Local      → Not found
Enclosing  → Found!

So it uses "Enclosing".

---

8. nonlocal

nonlocal is used when an inner function wants to modify a variable belonging to an enclosing function.

Example

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1

    inner()
    print(count)

outer()

Output:

1

Here, nonlocal count tells Python: "count belongs to the enclosing function. I want to modify that variable."

Simple Definition: nonlocal tells Python to use a variable from the enclosing function's scope instead of creating a new local variable.

When is nonlocal useful? It is commonly used with:

• Nested functions
• Closures
• Functions that need to remember and update state

---

9. First-Class Functions

One of the most important things about Python is:

Functions are objects too.

Because functions are objects, they can be treated like other values. A function can be:

• Assigned to a variable
• Passed as an argument
• Returned from another function
• Stored in a list
• Stored in a dictionary
• Used later

This is called first-class functions.

---

10. Assigning a Function to a Variable

def greet():
    print("Hello!")

x = greet

x()

Output:

Hello!

Here, x = greet means x now refers to the greet function.

Important Difference

• greet means: the function itself.
• greet() means: call or execute the function.

So x = greet stores the function, but x = greet() calls the function immediately and stores its return value.

---

11. Passing a Function as an Argument

Because functions are first-class objects, we can pass a function to another function.

def greet():
    print("Hello!")

def execute(function):
    function()

execute(greet)

Output:

Hello!

Here, execute(greet) passes the greet function to execute(). Inside execute(), function() calls the function.

The flow is:

greet
  ↓
passed to execute()
  ↓
stored in parameter "function"
  ↓
function()
  ↓
Hello!

---

12. Returning a Function

A function can also return another function.

def outer():
    def inner():
        print("Hello!")

    return inner

x = outer()

x()

Output:

Hello!

Here, x = outer() stores the returned inner function in x. Then x() calls inner().

This idea is very important for understanding closures and decorators.

---

13. When Are First-Class Functions Useful?

First-class functions are useful when we want to:

• Pass behavior to another function
• Create callbacks
• Build decorators
• Create closures
• Choose a function dynamically
• Store multiple functions
• Execute functions later

Simple Idea

Normally, we pass data:

process(10)

But because functions are objects, we can also pass behavior:

process(greet)

---

14. *args

Sometimes we don't know how many positional arguments a function will receive.

def add(a, b):
    return a + b

This function expects two arguments: add(10, 20). But this will cause an error:

add(10, 20, 30, 40)

If we want the function to accept any number of positional arguments, we can use *args.

Syntax

def function_name(*args):
    ...

Example

def show(*args):
    print(args)

show(10, 20, 30)

Output:

(10, 20, 30)

The arguments are collected into a tuple:

args = (10, 20, 30)

---

15. Example Using *args

def add(*args):
    total = 0

    for number in args:
        total += number

    return total

print(add(10, 20))
print(add(10, 20, 30))
print(add(10, 20, 30, 40))

Output:

30
60
100

Simple Definition: *args allows a function to accept any number of positional arguments and collects them into a tuple.

---

16. Is args a Special Keyword?

No. The * is what matters. The name can technically be anything:

def show(*numbers):
    print(numbers)

But Python programmers normally use *args because it is the standard convention.

---

17. **kwargs

Now let's talk about keyword arguments.

def student(name, age):
    print(name)
    print(age)

We can call this function using keyword arguments:

student(name="Deepika", age=21)

But what if we don't know how many keyword arguments will be provided? We can use **kwargs.

Syntax

def function_name(**kwargs):
    ...

Example

def student(**kwargs):
    print(kwargs)

student(name="Deepika", age=21, city="Bangalore")

Output:

{'name': 'Deepika', 'age': 21, 'city': 'Bangalore'}

The keyword arguments are collected into a dictionary:

kwargs = {
    "name": "Deepika",
    "age": 21,
    "city": "Bangalore"
}

---

18. Simple Definition of **kwargs

**kwargs allows a function to accept any number of keyword arguments and collects them into a dictionary.

---

19. *args vs **kwargs

Feature	*args	**kwargs
Accepts	Positional arguments	Keyword arguments
Stores data as	Tuple	Dictionary
Example	10, 20, 30	name="Deepika"
Symbol	*	**

The easiest way to remember:

*args → Positional arguments → Tuple
**kwargs → Keyword arguments → Dictionary

---

20. Using *args and **kwargs Together

We can use both in the same function.

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

demo(
    10,
    20,
    30,
    name="Deepika",
    age=21
)

Output:

(10, 20, 30)
{'name': 'Deepika', 'age': 21}

Python separates them: 10, 20, 30 → *args → Tuple, and name="Deepika", age=21 → **kwargs → Dictionary.

---

21. Packing and Unpacking

The * and ** symbols can also be used for unpacking. There are two different ideas: Packing and Unpacking.

---

22. Packing

When defining a function:

def demo(*args):
    print(args)

*args collects multiple positional arguments into one tuple. This is called packing.

demo(10, 20, 30)

becomes conceptually:

args = (10, 20, 30)

---

23. Unpacking with *

Suppose we have a list:

numbers = [10, 20, 30]

def add(a, b, c):
    return a + b + c

We can do:

print(add(*numbers))

This is equivalent to:

print(add(10, 20, 30))

The * takes the elements from the list and passes them as separate positional arguments. This is called unpacking.

---

24. Dictionary Unpacking with **

Suppose we have:

student = {
    "name": "Deepika",
    "age": 21
}

def show(name, age):
    print(name)
    print(age)

We can do:

show(**student)

This is equivalent to:

show(name="Deepika", age=21)

The ** unpacks the dictionary into keyword arguments.

---

25. Packing vs Unpacking

PACKING
↓
Many values → One variable

Example: def show(*args):

UNPACKING
↓
One collection → Many arguments

Example: show(*numbers)

For dictionaries:

• **kwargs packs keyword arguments into a dictionary.
• function(**data) unpacks a dictionary into keyword arguments.

---

26. Mutable Default Argument Pitfall

Now let's look at one of Python's famous pitfalls.

A default argument is a value given to a parameter when the caller doesn't provide one.

def greet(name="Deepika"):
    print("Hello", name)

greet()

Output:

Hello Deepika

Here, name="Deepika" is the default value.

---

27. What Is a Mutable Object?

A mutable object is an object whose contents can be changed. Common mutable types include list, dict, set.

numbers = []

numbers.append(10)

print(numbers)

Output:

[10]

The list was modified.

---

28. The Mutable Default Argument Problem

Consider this function:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Apple', 'Banana']
['Apple', 'Banana', 'Mango']

This may be surprising. We might expect:

['Apple']
['Banana']
['Mango']

But that's not what happens.

---

29. Why Does This Happen?

The important rule is:

Python creates default argument objects when the function is defined, not every time the function is called.

So def add_item(item, items=[]): creates one default list.

Function
   |
   └── Default list
          |
          ├── First call → ['Apple']
          |
          ├── Second call → ['Apple', 'Banana']
          |
          └── Third call → ['Apple', 'Banana', 'Mango']

The same list is being reused. Because lists are mutable, changes made to that list remain there.

---

30. Why Is It Called a "Mutable Default Argument Pitfall"?

• Mutable — the object can be changed. [] is a mutable list.
• Default Argument — this is the default parameter: items=[]
• Pitfall — the same mutable object can be reused across function calls.

Simple Definition: The mutable default argument pitfall occurs when a mutable object such as a list, dictionary, or set is used as a default parameter and modified, causing its changes to persist between function calls.

---

31. The Wrong Way

Avoid this when you want a fresh list for every function call:

def add_item(item, items=[]):
    items.append(item)
    return items

---

32. The Safe Way: Use None

Instead, use:

def add_item(item, items=None):
    if items is None:
        items = []

    items.append(item)
    return items

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Banana']
['Mango']

Perfect!

---

33. Why Does None Fix the Problem?

We use items=None as a signal meaning: "The caller did not provide a list."

Then if items is None: items = [] creates a new list when needed.

So instead of:

Call 1 ─┐
Call 2 ─┼──→ SAME LIST
Call 3 ─┘

we get:

Call 1 → NEW LIST
Call 2 → NEW LIST
Call 3 → NEW LIST

---

34. Mutable Default Dictionaries

The same problem can happen with dictionaries.

Avoid:

def add_user(name, users={}):
    users[name] = "active"
    return users

Prefer:

def add_user(name, users=None):
    if users is None:
        users = {}

    users[name] = "active"
    return users

---

35. Mutable Default Sets

The same idea applies to sets.

Avoid:

def add_number(number, numbers=set()):
    numbers.add(number)
    return numbers

Prefer:

def add_number(number, numbers=None):
    if numbers is None:
        numbers = set()

    numbers.add(number)
    return numbers

---

36. Are All Default Arguments Dangerous?

No. The problem specifically concerns mutable objects that are modified.

Common immutable types include: int, float, str, tuple, bool, None.

def counter(count=0):
    count += 1
    return count

print(counter())
print(counter())
print(counter())

Output:

1
1
1

This is fine because integers are immutable.

---

37. The Safe Pattern to Remember

Whenever you want a fresh mutable object for every function call, use None.

List

def function(data=None):
    if data is None:
        data = []

Dictionary

def function(data=None):
    if data is None:
        data = {}

Set

def function(data=None):
    if data is None:
        data = set()

This pattern is extremely common in real Python code.

---

38. Quick Revision

LEGB

L → Local
E → Enclosing
G → Global
B → Built-in

LEGB is Python's rule for searching for a variable name.

nonlocal

nonlocal variable

nonlocal tells an inner function to use and modify a variable from its enclosing function.

First-Class Functions

Functions are objects in Python, so they can be assigned to variables, passed as arguments, returned from functions, and stored in collections.

def greet():
    print("Hello")

x = greet
x()

*args

def function(*args):

*args accepts any number of positional arguments and stores them in a tuple.

def show(*args):
    print(args)

show(10, 20, 30)

Output: (10, 20, 30)

`kwargs`**

def function(**kwargs):

**kwargs accepts any number of keyword arguments and stores them in a dictionary.

def show(**kwargs):
    print(kwargs)

show(name="Deepika", age=21)

Output: {'name': 'Deepika', 'age': 21}

Mutable Default Argument

Avoid:

def function(items=[]):

Prefer:

def function(items=None):
    if items is None:
        items = []

A mutable default argument can cause changes to persist between function calls because the default object is created when the function is defined and can be reused.

---

39. Final Cheat Sheet

LEGB

L → Local
E → Enclosing
G → Global
B → Built-in

Python searches in this order.

First-Class Functions

Functions are objects.

They can be:
• Assigned to variables
• Passed as arguments
• Returned from functions
• Stored in collections

*args

Many positional arguments
        ↓
      Tuple

`kwargs`**

Many keyword arguments
        ↓
    Dictionary

Mutable Default Argument

Avoid:
def func(items=[]):

Prefer:
def func(items=None):
    if items is None:
        items = []

One-Minute Memory

LEGB → Where does Python search for a variable?
Local → Enclosing → Global → Built-in

First-Class Function → Function can be treated like an object.

*args → Many positional arguments → Tuple

**kwargs → Many keyword arguments → Dictionary

*list → Unpack list/sequence → Positional arguments

**dictionary → Unpack dictionary → Keyword arguments

Mutable Default → Avoid [] / {} / set() as defaults → Use None → Create a fresh object inside the function

---

These concepts are important foundations for understanding closures, decorators, callbacks, scope, function arguments, and advanced Python programming.