Names and Environment in Python¶

Overview¶

In Python, names refer to identifiers that are bound to objects, and the environment refers to the mapping between names and the objects they reference.

Understanding how names are created, looked up, and managed is essential for writing correct and efficient Python programs.

Names (Identifiers)¶

A name is a label used to reference an object.
Created through assignment.

Example:: x = 10

Here, “x” is a name bound to the integer object 10.

Rules: - Must start with a letter or underscore (_) - Can contain letters, digits, and underscores - Case-sensitive

Binding¶

Binding is the association between a name and an object.

Example:: a = [1, 2, 3] b = a

Both “a” and “b” refer to the same list object.

Key Idea: - Python uses reference semantics, not copying by default.

Namespaces¶

A namespace is a container that maps names to objects.

Types of Namespaces:¶

Local Namespace - Inside a function
Enclosing Namespace - In nested functions
Global Namespace - At the module level
Built-in Namespace - Predefined names (e.g., len, print)

LEGB Rule¶

Python resolves names using the LEGB rule:

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

Example:

x = “global”

def outer():

x = “enclosing”

def inner():: x = “local” print(x)

inner()

outer()

Output: “local”

Environment¶

The environment is the collection of active namespaces.
Determines how names are resolved during execution.
Environments change dynamically during function calls.

Scope¶

Scope defines where a name is accessible.

Types:¶

Local Scope: inside functions
Enclosing Scope: outer functions
Global Scope: module level
Built-in Scope: Python’s predefined names

Global and Nonlocal Keywords¶

global:¶

Declares a name as global inside a function.

Example:

x = 10

def change():: global x x = 20

nonlocal:¶

Refers to a variable in the enclosing scope.

Example:

def outer():

x = 10

def inner():: nonlocal x x = 20

inner() return x

Lifetime of Names¶

Names exist as long as their namespace exists.

Examples: - Local variables: destroyed after function execution - Global variables: exist until program ends

Aliasing and Mutability¶

Aliasing:¶

Multiple names refer to the same object.

Example:: a = [1, 2] b = a

Mutability:¶

Mutable objects can be changed (list, dict)
Immutable objects cannot (int, str, tuple)

Effect:: a.append(3) # b also sees the change

First-Class Objects¶

Everything in Python is an object.
Names can refer to functions, classes, etc.

Example:

def greet():: print(“Hello”)

f = greet f()

Garbage Collection¶

Python automatically manages memory.
Objects are deleted when no names reference them.

Summary¶

Names are references to objects.
Namespaces store name-object mappings.
LEGB rule determines name resolution.
Scope defines visibility.
Environment is the active set of namespaces.
Python uses reference semantics and automatic memory management.

Quick Reference¶

Concept	Description
Name	Identifier for an object
Namespace	Mapping of names to objects
Scope	Region where name is accessible
Environment	Active namespaces at runtime
LEGB Rule	Name resolution order