Built-in scope in Python - Mini Project: Build & Apply

Exploring Built-in Scope in Python

📖 Scenario: Imagine you are learning how Python finds names like functions and variables when you use them. Python first looks in your own code, then in the places it knows by default, called the built-in scope.

🎯 Goal: You will create a simple program to see how Python uses built-in names and how you can use your own names without changing the built-in ones.

📋 What You'll Learn

Create a variable named my_len with a list of three fruits

Create a variable named length and set it to 0

Use a for loop with variable item to count items in my_len

Print the value of length

Print the result of the built-in len function on my_len

💡 Why This Matters

🌍 Real World

Understanding built-in scope helps you avoid mistakes when naming your variables and using Python's built-in functions.

💼 Career

Knowing how Python finds names is important for writing clear and bug-free code, a key skill for any programming job.

1

Create a list named my_len

Create a list called my_len with these exact items: 'apple', 'banana', and 'cherry'.

Python

# Create the list my_len with 'apple', 'banana', and 'cherry'
# Your code here

Hint

Use square brackets [] to create a list and separate items with commas.

2

Create a variable length to count items

Create a variable called length and set it to 0. This will hold the count of items in my_len.

Python

my_len = ['apple', 'banana', 'cherry']
# Create a variable length and set it to 0
# Your code here

Hint

Just write length = 0 to start counting from zero.

3

Count items in my_len using a for loop

Use a for loop with variable item to go through each item in my_len. Inside the loop, add 1 to length for each item.

Python

my_len = ['apple', 'banana', 'cherry']
length = 0
# Use a for loop with item to count items in my_len
# Your code here

Hint

Use for item in my_len: and inside the loop write length += 1 to add one each time.

4

Print the counted length and the built-in length

Print the value of length. Then print the result of the built-in len function called on my_len to compare.

Python

my_len = ['apple', 'banana', 'cherry']
length = 0
for item in my_len:
    length += 1
# Print length
# Print len(my_len)
# Your code here

Hint

Use print(length) and print(len(my_len)) to show both counts.

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