Built-in scope in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the built-in scope in Python?

The built-in scope is the area where Python's built-in functions and names like <code>print()</code>, <code>len()</code>, and <code>int()</code> live. These are always available anywhere in your code without needing to import or define them.

beginner

Where does Python look first when you use a name in your code?

Python first looks in the local scope (inside the current function or block), then in the enclosing scopes (like outer functions), then in the global scope (the main script), and finally in the built-in scope if it doesn't find the name anywhere else.

intermediate

Can you override a built-in function name in your code? What happens?

Yes, you can create a variable or function with the same name as a built-in. This will hide the built-in inside your current scope, so when you use that name, Python uses your version instead of the built-in. This can cause confusion, so it's best to avoid it.

beginner

Example: What will this code print?

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

It will print 3 because len() is a built-in function that returns the number of items in a list.

intermediate

How can you see all the names in the built-in scope?

You can import the <code>builtins</code> module and use <code>dir(builtins)</code> to list all built-in names available in Python.

Which scope does Python check LAST when looking for a variable name?

A Local scope

B Global scope

C Built-in scope

D Enclosing scope

Python checks the built-in scope last after local, enclosing, and global scopes.

What happens if you define a variable named print in your code?

A Your variable hides the built-in print function in that scope.

B The built-in print function is still used.

C Python throws an error.

D The built-in print function is deleted.

Your variable named print hides the built-in function in the current scope.

How can you list all built-in functions and names in Python?

A Use <code>dir(builtins)</code> after importing <code>builtins</code>.

B Use <code>dir()</code> with no arguments.

C Use <code>help()</code>.

D Use <code>list_builtins()</code>.

Import builtins and use dir(builtins) to see all built-in names.

Which of these is NOT a built-in function in Python?

A len()

B print()

C input()

D my_function()

my_function() is not a built-in function; it's a user-defined name.

If a name is not found in local, enclosing, or global scopes, what does Python do?

A Raises a syntax error.

B Looks in the built-in scope.

C Creates a new variable.

D Ignores the name.

Python looks in the built-in scope before raising a NameError.

Explain the order Python uses to find a variable name when you use it in your code.

Think about the LEGB rule.

Describe what happens if you create a variable with the same name as a built-in function.

Consider how Python decides which name to use.

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