Global scope in Python - Time & Space Complexity

Time Complexity: Global scope

O(n)

Understanding Time Complexity

We want to see how using variables in the global scope affects how long a program takes to run.

Does accessing or changing global variables slow down the program as it gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

count = 0  # global variable

def increment(n):
    global count
    for i in range(n):
        count += 1
    return count

result = increment(5)

This code increases a global number by 1, n times, then returns the total.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that runs n times.
• How many times: Exactly n times, where n is the input number.

How Execution Grows With Input

Each time n grows, the loop runs more times, increasing work linearly.

Input Size (n)	Approx. Operations
10	10 increments
100	100 increments
1000	1000 increments

Pattern observation: The work grows directly with n; double n means double work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the input size.

Common Mistake

[X] Wrong: "Using a global variable makes the program slower because it's harder to access."

[OK] Correct: Accessing or changing a global variable takes about the same time as a local one in this simple case, so it doesn't add extra time as input grows.

Interview Connect

Understanding how global variables affect performance helps you write clear and efficient code, a skill valued in many coding challenges and real projects.

Self-Check

"What if we replaced the global variable with a local variable inside the function? How would the time complexity change?"

Practice

1. What does the global keyword do inside a Python function?

easy

A. It deletes a global variable.

B. It creates a new local variable inside the function.

C. It makes the function run faster.

D. It allows the function to modify a variable defined outside the function.

Solution

1. Step 1: Understand the role of global keyword

   The global keyword tells Python that the variable inside the function refers to the variable defined outside (in global scope).

2. Step 2: Effect on variable modification

   Without global, assigning a value creates a new local variable. With global, it modifies the existing global variable.

3. Final Answer:

   It allows the function to modify a variable defined outside the function. -> Option D

4. Quick Check:

   global keyword modifies outer variable [OK]

Hint: global lets functions change outside variables [OK]

Common Mistakes:

• Thinking global creates a new local variable
• Assuming global deletes variables
• Believing global affects performance

2. Which of the following is the correct way to declare a global variable inside a function?

easy

A. def global x:

B. global = x

C. global x

D. x global

Solution

1. Step 1: Recall correct syntax for global declaration

   The correct syntax is to write the keyword global followed by the variable name, separated by a space.

2. Step 2: Check each option

   global x matches the correct syntax. Others are invalid Python syntax.

3. Final Answer:

   global x -> Option C

4. Quick Check:

   global keyword followed by variable name [OK]

Hint: Use 'global' then variable name to declare global inside function [OK]

Common Mistakes:

• Using '=' with global keyword
• Trying to define global like a function
• Placing global after variable name

3. What will be the output of this code?

count = 5
def increment():
    global count
    count += 1
increment()
print(count)

medium

A. 6

B. None

C. Error

D. 5

Solution

1. Step 1: Understand the global variable usage

   The variable count is defined globally with value 5. Inside increment(), global count allows modifying this global variable.

2. Step 2: Trace the function call and print

   The function adds 1 to count, changing it from 5 to 6. Then print(count) outputs 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   global lets function change count to 6 [OK]

Hint: global lets function update outside variable [OK]

Common Mistakes:

• Expecting original value 5 to print
• Thinking global causes error here
• Assuming function returns None

4. Find the error in this code:

total = 10
def add():
    total += 5
add()
print(total)

medium

A. Missing global declaration inside add()

B. Syntax error in function definition

C. total is not defined globally

D. print statement is incorrect

Solution

1. Step 1: Identify variable scope issue

   Inside add(), total += 5 tries to modify total. Without global total, Python treats total as local but it's used before assignment, causing an error.

2. Step 2: Fix by adding global declaration

   Adding global total inside add() tells Python to use the global total variable, fixing the error.

3. Final Answer:

   Missing global declaration inside add() -> Option A

4. Quick Check:

   Modify global variable needs global keyword [OK]

Hint: Add global keyword to modify global variable inside function [OK]

Common Mistakes:

• Ignoring need for global keyword
• Thinking total is local automatically
• Assuming no error occurs

5. You want to count how many times a function is called using a global variable. Which code correctly updates the global counter?

hard

A. calls = 0
def func():
calls += 1
func()
print(calls)

B. calls = 0
def func():
global calls
calls += 1
func()
print(calls)

C. calls = 0
def func():
calls = calls + 1
func()
print(calls)

D. calls = 0
def func():
global calls
calls = calls
func()
print(calls)

Solution

1. Step 1: Understand global variable modification

   To update a global variable inside a function, you must declare it with global inside the function.

2. Step 2: Analyze each option

   calls = 0 def func(): calls += 1 func() print(calls) tries to increment without global, causing error. calls = 0 def func(): global calls calls += 1 func() print(calls) correctly uses global calls and increments. calls = 0 def func(): calls = calls + 1 func() print(calls) tries to read and assign without global, causing UnboundLocalError. calls = 0 def func(): global calls calls = calls func() print(calls) declares global but does not increment.

3. Final Answer:

   calls = 0 def func(): global calls calls += 1 func() print(calls) -> Option B

4. Quick Check:

   global keyword needed to update global variable [OK]

Hint: Use global keyword to update global counter inside function [OK]

Common Mistakes:

• Forgetting global keyword causes UnboundLocalError
• Assigning without global causes UnboundLocalError when reading variable
• Declaring global but not updating variable