Global scope in Python

Introduction

Global scope means a variable can be used anywhere in the program. It helps share information across different parts of the code.

When you want to use the same data in many functions without passing it around.

When you have a setting or value that should stay the same everywhere.

When you want to keep track of a value that changes but is needed in multiple places.

Syntax

Python

variable_name = value  # This is a global variable

def some_function():
    print(variable_name)  # Access global variable

# To change a global variable inside a function, use 'global' keyword:

def change_global():
    global variable_name
    variable_name = new_value

Global variables are created outside of functions.

Use the global keyword inside a function to modify a global variable.

Examples

This example shows reading a global variable inside a function.

Python

count = 10  # global variable

def show_count():
    print(count)  # prints 10

show_count()

This example shows changing a global variable inside a function using global.

Python

score = 5

def increase_score():
    global score
    score += 1

increase_score()
print(score)  # prints 6

Sample Program

This program shows how a global variable can be read and changed inside functions.

Python

message = "Hello, world!"  # global variable

def greet():
    print(message)  # use global variable

def change_message():
    global message
    message = "Hi, everyone!"  # change global variable

greet()
change_message()
greet()

Important Notes

Be careful with global variables because changing them can affect many parts of your program.

Try not to use too many global variables to keep your code easy to understand.

Summary

Global variables can be used anywhere in the program.

Use global keyword inside functions to change global variables.

Global scope helps share data but use it carefully.

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