Built-in scope in Python

Introduction

Built-in scope holds names of functions and variables that Python always knows. It helps you use common tools without extra work.

When you use functions like <code>print()</code> or <code>len()</code> without defining them yourself.

When you want to understand why a name works even if you didn't create it.

When debugging to see if a name is from your code or Python's built-ins.

When you want to avoid naming your variables the same as built-in names to prevent confusion.

Syntax

Python

No special syntax to access built-in scope directly.
Python automatically looks here if a name is not found in local or global scopes.

Built-in scope is the last place Python looks for a name.

You can see built-in names using the dir(__builtins__) command.

Examples

Uses built-in functions print() and len() without defining them.

Python

print(len("hello"))

max() is a built-in function that finds the largest number in a list.

Python

x = max([1, 5, 3])
print(x)

Shows that print is part of the built-in scope.

Python

import builtins
print('print' in dir(builtins))

Sample Program

This program shows the built-in len() function and a user-made version. It also checks if len is in the built-in scope.

Python

def my_len(s):
    count = 0
    for _ in s:
        count += 1
    return count

print(len('hello'))  # built-in len
print(my_len('hello'))  # user-defined len

import builtins
print('len' in dir(builtins))  # check if len is built-in

Important Notes

Built-in names include functions like print, len, max, and constants like True, None.

Avoid naming your variables the same as built-in names to prevent bugs.

You can override built-in names, but it is not recommended because it can cause confusion.

Summary

Built-in scope contains names Python always knows.

Python looks here last when finding a name.

Use built-in functions freely, but avoid naming conflicts.

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