Python Scope
Contents
Python Scope
Python scope refers to the region of a program where a particular variable can be accessed or referenced.
What is the Python Scope ?
- In Python, scope refers to the region of a program where a particular variable, function, or object can be accessed or referenced.
- Python has two types of scopes: global scope and local scope.
Global scope refers to the area of a program where a variable, function, or object can be accessed by any part of the program.In other words, a global variable or function can be accessed from any part of the code.
Local scope, on the other hand, refers to the region of a program where a variable, function, or object can be accessed only by a specific part of the program, such as a function or a block of code. A local variable or function can only be accessed within the specific function or block where it was defined.
It’s important to understand the concept of scope in Python in order to write efficient and effective code. By properly defining and managing the scope of variables and functions, you can reduce the risk of naming conflicts and improve the readability and maintainability of your code.
The types of Python Scope
In Python, there are two types of scope: global scope and local scope. Here are some examples to illustrate the difference between these two types of scope:
Global Scope: Variables or functions that are defined outside of any functions or classes have global scope. They can be accessed from anywhere in the code.
Example:
x = 10
def my_func():
print(x) my_func()
# Output: 10
In this example, x is defined outside of the function my_func(), so it has global scope. The function can access x and print its value.
Local Scope: Variables or functions that are defined inside a function have local scope. They can only be accessed within that function.
Example:
def my_func():
y = 5 print(y)
my_func()
# Output: 5 print(y) # Output: NameError: name ‘y’ is not defined
In this example, y is defined inside the function my_func(), so it has local scope. The variable y can only be accessed within the function. When we try to print y outside the function, we get a NameError because y is not defined in the global scope.
It’s important to note that variables defined in a nested function have local scope within that function, but not in the outer function or global scope. Similarly, variables defined in a class have class scope, which is a form of global scope limited to the class and its instances.
Function Inside Function
In Python, it is possible to define a function inside another function. This is known as a nested function. When a function is defined inside another function, the inner function has access to the outer function’s variables and scope.
Here is an example of a function inside another function:
def outer_function(): x = 1
def inner_function():
y = 2
print(x + y)
inner_function()
outer_function()
# Output: 3
- In this example, inner_function() is defined inside outer_function(). inner_function() has access to the variable x, which is defined in outer_function().
- When outer_function() is called, it calls inner_function(), which prints the sum of x and y.
- It’s important to note that the inner function can only be called from within the outer function, since it has local scope within that function.
- The outer function can also return the inner function as a value, which can be used to call the inner function from outside the outer function.
- Nested functions can be useful for organizing code and creating modular functions.
- They can also be used to create closures, which are functions that remember the values of their enclosing environment even after the enclosing function has returned.
What is difference between Global Scope and local scope ?
The main difference between global scope and local scope in Python is the region of a program where a particular variable can be accessed or referenced.
Here are some examples that illustrate the difference between global scope and local scope:
Global Scope:
x = 10
def my_func():
print(x) my_func()
# Output: 10
print(x)
# Output: 10
In this example, x is defined in the global scope, which means it can be accessed from anywhere in the program.
The function my_func() can access x and print its value, and we can also print x outside the function.
Local Scope:
def my_func():
y = 5
print(y)
my_func() # Output: 5
print(y) # Output: NameError: name ‘y’ is not defined
In this example, y is defined inside the function my_func(), which means it has local scope.
The variable y can only be accessed within the function, and we get a NameError when we try to print it outside the function.
Python Global and Local Scope
x = 10
def my_func():
x = 5
print(x)
my_func()
# Output: 5
print(x)
# Output: 10
- In this example, there is a global variable x with a value of 10, and a local variable x inside the function my_func() with a value of 5. When we call my_func(), it prints the value of the local variable x.
- However, when we print x outside the function, it prints the value of the global variable x.
- It’s important to understand the scope of variables in Python to avoid naming conflicts and ensure that variables are used in the appropriate context.
- When a variable is defined in a local scope, it shadows any variable with the same name in the global scope, and the local variable is used instead.
Here are some additional examples that illustrate the difference between global scope and local scope:
Python Global Scope:
x = 10
def my_func():
print(x)
def another_func():
print(x * 2) my_func()
# Output: 10
another_func()
# Output: 20
In this example, x is defined in the global scope, so it can be accessed by both my_func() and another_func(). Both functions print the value of x or use it in an expression.
Python Local Scope:
def my_func(): x = 5 print(x) def another_func(): x = 10 print(x * 2) my_func() # Output: 5 another_func() # Output: 20
Naming Variables inside function and outside
here’s an example that illustrates the difference between naming variables inside a function and outside:
x = 10
def my_func():
x = 5
print(“Inside function: x =”, x)
my_func()
print(“Outside function: x =”, x)
In this example, we define a global variable x with a value of 10. We also define a function my_func(), which defines a local variable x with a value of 5. Inside the function, we print the value of x. Outside the function, we print the value of the global variable x.
When we run this code, it outputs:
Inside function: x = 5 Outside function: x = 10
- This shows that the local variable x inside the function shadows the global variable x outside the function.
- When we print x inside the function, we’re printing the value of the local variable.
- When we print x outside the function, we’re printing the value of the global variable.
It’s important to choose variable names carefully to avoid naming conflicts and to ensure that variables are used in the appropriate context.
Here are some more examples that illustrate the differences between local and global variables in Python:
Global variable modified inside a function:
x = 10
def my_func():
global x
x = 5
print(“Inside function: x =”, x)
my_func()
print(“Outside function: x =”, x)
- In this example, we define a global variable x with a value of 10.
- We also define a function my_func(), which uses the global keyword to modify the value of the global variable x.
- Inside the function, we set x to 5 and print its value.
- Outside the function, we print the value of the global variable x.
When we run this code, it outputs:
Inside function: x = 5
Outside function: x = 5
This shows that when a global variable is modified inside a function using the global keyword, its value is changed globally.
Local variable with the same name as a global variable:
Local variable with a different name than a global variable:
x = 10
def my_func():
y = 5
print(“Inside function:x =”, y)
my_func() print(“Outside function: x =”, x)
- In this example, we define a global variable x with a value of 10.
- We also define a function my_func(), which defines a local variable y with a value of 5.
- Inside the function, we print the value of the local variable y.
- Outside the function, we print the value of the global variable x.
When we run this code, it outputs:
Inside function: x = 5
Outside function: x = 10
This shows that when a variable is defined inside a function with a different name than a global variable, the global variable is not affected and retains its value.
Global Keyword with examples
In Python, the global keyword is used to indicate that a variable is a global variable, and should be accessed and modified globally, even if it is used inside a function. Here are some examples that illustrate the use of the global keyword:
Modifying a global variable inside a function:
x = 10
def my_func():
global x
x = 5
my_func() print(x)
- In this example, we define a global variable x with a value of 10.
- We also define a function my_func(), which uses the global keyword to modify the value of the global variable x.
- Inside the function, we set x to 5. Outside the function, we print the value of the global variable x.
When we run this code, it outputs:5
This shows that when we use the global keyword inside a function to modify a global variable, the value of the variable is changed globally.
Accessing a global variable inside a function:
x = 10
def my_func():
global x
print(x)
my_func()
In this example, we define a global variable x with a value of 10.
We also define a function my_func(), which uses the global keyword to access the value of the global variable x. Inside the function, we print the value of x.
When we run this code, it outputs:10
This shows that when we use the global keyword inside a function to access a global variable, we can access the value of the variable globally.
Shadowing a global variable with a local variable:
x = 10
def my_func():
x = 5
print(x) my_func()
print(x)
- In this example, we define a global variable x with a value of 10.
- We also define a function my_func(), which defines a local variable x with a value of 5.
- Inside the function, we print the value of the local variable x.
- Outside the function, we print the value of the global variable x.
When we run this code, it outputs:
5
10
- This shows that when we define a local variable with the same name as a global variable, the local variable shadows the global variable inside the function.
- If we want to access or modify the global variable, we need to use the global keyword inside the function.
Here are some more examples of using the global keyword in Python:
Modifying a global list variable inside a function:
my_list = [1, 2, 3]
def add_to_list(num):
global my_list
my_list.append(num)
add_to_list(4)
print(my_list)
- In this example, we define a global list variable my_list with values [1, 2, 3].
- We also define a function add_to_list() which uses the global keyword to modify the global variable my_list.
- Inside the function, we append a new number to the list. Outside the function, we print the value of the global variable my_list.
When we run this code, it outputs:
[1, 2, 3, 4]
This shows that we can modify a global list variable inside a function using the global keyword.
Using a global constant variable inside a function:
PI = 3.14159
def calculate_area(radius):
global PI area = PI * radius ** 2
return area
print(calculate_area(5))
- In this example, we define a global constant variable PI with a value of 3.14159.
- We also define a function calculate_area() which uses the global keyword to access the value of the global variable PI.
- Inside the function, we calculate the area of a circle using the formula PI * radius ** 2.
- Outside the function, we print the value of the area.
When we run this code, it outputs:78.53975
This shows that we can use a global constant variable inside a function by using the global keyword.
Shadowing a global variable with a local variable of the same name:
x = 10
def my_func():
x = 5
print(“Local variable x =”, x)
my_func() print(“Global variable x =”, x)
- In this example, we define a global variable x with a value of 10.
- We also define a function my_func() which defines a local variable x with a value of 5.
- Inside the function, we print the value of the local variable x.
- Outside the function, we print the value of the global variable x.
When we run this code, it outputs:
Local variable x = 5
Global variable x = 10
- This shows that when we define a local variable with the same name as a global variable, the local variable shadows the global variable inside the function.
- If we want to access or modify the global variable, we need to use the global keyword inside the function.
Multiple choice quiz about local and global scope in python
1-What is the scope of a variable in Python?
A) The part of the code where the variable is defined
B) The entire program where the variable is defined
C) The part of the code where the variable is used
D) None of the above
Answer: A
2-What is a global variable in Python?
A) A variable defined inside a function
B) A variable defined outside of any function
C) A variable defined inside a class
D) None of the above
Answer: B
3-What is a local variable in Python?
A) A variable defined inside a function
B) A variable defined outside of any function
C) A variable defined inside a class
D) None of the above
Answer: A
4-What is the difference between a local and a global variable in Python?
A) A local variable is defined inside a function, while a global variable is defined outside of any function
B) A local variable can only be accessed inside the function where it is defined, while a global variable can be accessed from any part of the program
C) A local variable has a shorter lifespan than a global variable
D) All of the above
Answer: B
5-What happens if a local variable has the same name as a global variable?
A) The local variable is ignored
B) The global variable is ignored
C) The local variable shadows the global variable inside the function where it is defined
D) Both variables are merged into a single variable
Answer: C
6-Which keyword is used to access a global variable inside a function in Python?
A) global
B) nonlocal
C) local
D) globalize
Answer: A
7-Which of the following statements is true about modifying a global variable inside a function in Python?
A) It is not allowed
B) It is allowed, but the changes made to the global variable will not be visible outside the function
C) It is allowed, and the changes made to the global variable will be visible outside the function
D) It depends on the type of the global variable
Answer: C
8-What happens if you try to access a local variable outside of the function where it was defined?
A) You can access it without any issues
B) You will get a syntax error
C) You will get a runtime error
D) None of the above
Answer: D
9-What is the lifetime of a local variable in Python?
A) It exists as long as the program is running
B) It exists as long as the function where it was defined is running
C) It exists as long as the variable is being used
D) None of the above
Answer: B
10-Which of the following is an example of a global variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: A
11-Which of the following is an example of a local variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: B
12-What is the purpose of the global keyword in Python?
A) To create a new variable
B) To access a global variable inside a function
C) To access a local variable outside of a function
D) None of the above
Answer: B
13-Can a function modify a global variable without using the global keyword?
A) Yes, it can modify it directly
B) No, it is not allowed
C) It depends on the type of the global variable
D) None of the above
Answer: A
14-What is the best practice for using global variables in Python?
A) Use them sparingly and only when necessary
B) Use them for all variables in the program
C) Use them only for local variables
D) None of the above
Answer: A
15-Which of the following is an example of a global variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: A
16-Which of the following is an example of a local variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: B
17-What is the purpose of the global keyword in Python?
A) To create a new variable
B) To access a global variable inside a function
C) To access a local variable outside of a function
D) None of the above
Answer: B
18-Can a function modify a global variable without using the global keyword?
A) Yes, it can modify it directly
B) No, it is not allowed
C) It depends on the type of the global variable
D) None of the above
Answer: A
19-What is the scope of a variable defined inside a function in Python?
A) Local
B) Global
C) Class
D) Instance
Answer: A
20-What is the scope of a variable defined outside of any function or class in Python?
A) Local
B) Global
C) Class
D) Instance
Answer: B
21-What happens if a local variable has the same name as a global variable?
A) The global variable is ignored
B) The local variable is ignored
C) The local variable shadows the global variable inside the function where it is defined
D) Both variables are merged into a single variable
Answer: C
22-What is the scope of a variable defined inside a function in Python?
A) Global
B) Local
C) Class
D) Instance
Answer: B
23-What is the scope of a variable defined outside of any function or class in Python?
A) Global
B) Local
C) Class
D) Instance
Answer: A
24-What happens if you try to access a local variable outside of the function where it was defined?
A) You can access it without any issues
B) You will get a syntax error
C) You will get a runtime error
D) None of the above
Answer: B
25-What happens if a local variable has the same name as a global variable?
A) The global variable is ignored
B) The local variable is ignored
C) The local variable shadows the global variable inside the function where it is defined
D) Both variables are merged into a single variable
Answer: C
26-Which of the following is an example of a global variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: A
27-Which of the following is an example of a local variable in Python?
A) x = 5
B) def my_function(): y = 10
C) class MyClass: z = 15
D) None of the above
Answer: B
28-What is the purpose of the global keyword in Python?
A) To create a new variable
B) To access a global variable inside a function
C) To access a local variable outside of a function
D) None of the above
Answer: B