Built-in scope in Python - Step-by-Step Execution

Concept Flow - Built-in scope

Start: Code runs

↓

Look for variable in Local scope

↓

Found?

No→Look in Enclosing scope

↓

Found?

No→Look in Global scope

↓

Use Local value

↓

Found?

No→Look in Built-in scope

↓

Use Enclosing

↓

Use Built-in value

↓

Variable not found: Error

When Python looks for a name, it checks local, then enclosing, then global, and finally built-in scope.

Execution Sample

Python

print(len([1, 2, 3]))

len = 5
print(len)

# print(len([1, 2, 3]))  # This would error now

This code shows how Python uses the built-in len function first, then a local variable named len, and how redefining len hides the built-in.

Execution Table

Step	Action	Name looked up	Scope checked	Result	Output/Effect
1	Call print(len([1, 2, 3]))	len	Local -> Enclosing -> Global -> Built-in	Built-in len function found	Prints 3
2	Assign len = 5	len	Local	len variable created with value 5	No output
3	Call print(len)	len	Local	len variable found with value 5	Prints 5
4	Call print(len([1, 2, 3]))	len	Local	len variable found (int 5), not callable	Error if run (commented out)

💡 Execution stops after printing 5; calling len as function now errors because local len hides built-in.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
len	built-in function	5 (local variable shadows built-in)	5	5

Key Moments - 2 Insights

Why does print(len([1, 2, 3])) work the first time but not after len = 5?

At step 1 in the execution_table, Python finds len in the built-in scope and uses the function. After step 2, len is a local variable (int 5), so at step 4 it no longer refers to the built-in function, causing an error.

Does assigning len = 5 delete the built-in len function?

No, the built-in len function still exists but is hidden by the local variable named len, as shown in variable_tracker where len changes from built-in to local.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of len?

A The built-in len function

B The integer 5

C An error occurs

D Undefined

💡 Hint

Check the 'Result' column at step 3 in execution_table and variable_tracker for len value.

At which step does Python stop using the built-in len function?

A Step 1

B Step 3

C Step 4

D Step 2

💡 Hint

Look at the 'Scope checked' and 'Result' columns in execution_table for step 4.

If we rename the local variable from len to my_len, what happens at step 4?

A Prints 3 using built-in len function

B Error because len is undefined

C Prints the value of my_len

D Prints 5

💡 Hint

Consider how variable_tracker shows local variables shadowing built-ins and what happens if local len is removed.

Concept Snapshot

Built-in scope is the last place Python looks for names.
Python searches: Local -> Enclosing -> Global -> Built-in.
Built-in names like len exist unless shadowed by local/global variables.
Assigning a local variable with a built-in name hides the built-in.
Use caution when naming variables to avoid hiding built-ins.

Full Transcript

This visual execution shows how Python finds names using the built-in scope last. Initially, calling print(len([1, 2, 3])) uses the built-in len function and prints 3. Then, assigning len = 5 creates a local variable named len that hides the built-in. Printing len now shows 5. Trying to call len as a function after this causes an error because the local len is an integer, not a function. The variable tracker confirms len changes from built-in function to local integer. This teaches that built-in names exist but can be hidden by local variables with the same name, so naming variables carefully is important.

Practice

1. Which of the following best describes the built-in scope in Python?

easy

A. It is where user-defined variables are stored.

B. It is the first place Python looks for variable names.

C. It contains names of functions and variables Python always knows.

D. It only contains names defined inside functions.

Solution

1. Step 1: Understand what built-in scope means

   Built-in scope contains names of functions and constants Python always knows, like print and len.

2. Step 2: Identify where Python looks last

   Python looks in local, then global, then built-in scope last when searching for a name.

3. Final Answer:

   It contains names of functions and variables Python always knows. -> Option C

4. Quick Check:

   Built-in scope = Python's always known names [OK]

Hint: Built-in scope has Python's default functions and constants [OK]

Common Mistakes:

• Thinking built-in scope is searched first
• Confusing built-in scope with local or global scope
• Assuming user variables are in built-in scope

2. Which of the following is the correct way to use a built-in function without causing a naming conflict?

easy

A. print('Hello, world!')

B. def print(): pass

C. len = 5

D. input = 'data'

Solution

1. Step 1: Identify correct usage of built-in functions

   Using print('Hello, world!') calls the built-in print function correctly.

2. Step 2: Recognize naming conflicts

   Defining print, len, or input as variables or functions overwrites built-ins and causes conflicts.

3. Final Answer:

   print('Hello, world!') -> Option A

4. Quick Check:

   Use built-ins directly without redefining [OK]

Hint: Avoid naming variables same as built-ins to prevent errors [OK]

Common Mistakes:

• Redefining built-in function names as variables or functions
• Calling built-ins after overwriting them
• Assuming built-ins can be safely replaced

3. What will be the output of the following code?

len = 10
print(len('hello'))

medium

A. 5

B. 10

C. NameError

D. TypeError

Solution

1. Step 1: Understand variable shadowing

   The variable len is assigned the integer 10, which hides the built-in len function.

2. Step 2: Analyze the function call

   Calling len('hello') tries to call the integer 10 as a function, causing a TypeError.

3. Final Answer:

   TypeError -> Option D

4. Quick Check:

   Overwriting built-in function causes TypeError when called [OK]

Hint: Overwriting built-ins causes errors when called as functions [OK]

Common Mistakes:

• Expecting output 5 (length of 'hello')
• Confusing variable value with function behavior
• Ignoring that built-in is overwritten

4. Find the error in this code snippet:

def input():
    return 'user input'

print(input())
print(len('abc'))

medium

A. SyntaxError due to function definition

B. No error, prints 'user input' and 3

C. Error because len is undefined

D. Error because input is redefined, blocking built-in input

Solution

1. Step 1: Check function definition and shadowing

   Defining input() shadows the built-in input, but the code calls the custom function.

2. Step 2: Verify execution flow

   print(input()) prints 'user input'; print(len('abc')) uses built-in len (unaffected) and prints 3. No errors occur.

3. Final Answer:

   No error, prints 'user input' and 3 -> Option B

4. Quick Check:

   Code executes fine despite shadowing [OK]

Hint: Avoid redefining built-in names to prevent unexpected behavior [OK]

Common Mistakes:

• Thinking redefining input causes immediate runtime error
• Assuming len is undefined or affected
• Confusing bad practice with actual syntax or runtime error

5. You want to use the built-in max function inside a function that has a local variable named max. How can you still call the built-in max function?

hard

A. Use __builtins__.max() to call the built-in function.

B. Rename the local variable to max_builtin.

C. Call max() directly; Python will use the built-in automatically.

D. Use global max inside the function.

Solution

1. Step 1: Understand local variable shadowing

   A local variable named max hides the built-in max function inside the function scope.

2. Step 2: Access built-in function explicitly

   Using __builtins__.max() calls the original built-in max function despite the local variable.

3. Final Answer:

   Use __builtins__.max() to call the built-in function. -> Option A

4. Quick Check:

   Use __builtins__ to access hidden built-ins [OK]

Hint: Use __builtins__.function() to bypass local shadowing [OK]

Common Mistakes:

• Assuming calling max() calls built-in despite local variable
• Using global keyword incorrectly
• Renaming variable without changing code