Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
3.3. Global and Local Variables
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Today, we will discuss global variables. Can anyone tell me what a global variable is?
Isn't it a variable that can be accessed from anywhere in the program?
Exactly! Global variables are defined outside of functions and can be accessed from any point in the code. For example, if I say x = 10 outside any function, I can use print(x) inside any function to get 10. Great memory aid to remember this: the letter G for Global reminds us that it's 'General' and can be accessed anywhere!
Got it! So, can we modify a global variable inside a function?
Good question! We will cover that shortly, but you have to use the global keyword to modify it inside a function.
What happens if you try to use a global variable that wasn't defined yet?
If you attempt to access a global variable before defining it, you will face a NameError. Remember that variables must be defined before use!
In summary, global variables are those defined in the general scope, and their accessibility is extensive throughout the program.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Now, let’s talk about local variables. Who can tell me what they are?
Are they the ones you define inside functions only?
Exactly! Local variables are created when a function is called and are destroyed once the function exits. For example, def func(): x = 5 will make x local to func(). You can’t access x outside that function.
So, what happens if I try to print x outside the function?
You will receive an error because x is not defined in the global scope. So always remember: Local is Localized!
To summarize, local variables only exist within the function scope and cannot be accessed elsewhere.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free accountLet's discuss the global and nonlocal keywords. Why do you think they're important?
Are they used to control access to variables across functions and scopes?
Perfect! The global keyword tells Python to use the global variable instead of creating a new one. For example, if I have global x in my function, it modifies the global x.
What about nonlocal?
Great that you asked! If you have nested functions, nonlocal allows you to modify a variable from the enclosing function without declaring it global. So, just remember: Global for globals, Nonlocal for neighbors!
Can you give an example of nonlocal in action?
Certainly! If you have a nested function, you can modify the variable of the outer function using nonlocal! That way, we respect the scope rules while allowing flexibility. To recap, global changes globals, and nonlocal deals with outer function scopes.
Overview
Short Summary
This section explains global and local variables in Python, highlighting their scopes and uses within functions.
Medium Summary
In this section, we explore the distinction between global and local variables in Python, how they are declared, and the implications of their scopes in programming. The use of global and nonlocal keywords to modify variables across different scopes is also discussed.
Detailed Summary
Global and Local Variables
In programming, the concept of variable scope is crucial as it determines where and how variables can be accessed within the code. Specifically, local variables are defined within a function and are only accessible inside it, while global variables are defined outside of any function and can be accessed throughout the entire program.
Key Points:
- Global Variable: A variable defined outside any function, like
x = 10, which is accessible in any function as shown in the example whereprint(x)will output 10 when called from thedisplay()function. - Local Variable: A variable defined within a function, such as
x = 5infunc(), which cannot be accessed outside that function, leading to a potential error if trying to printxelsewhere. - Keywords
globalandnonlocal: Theglobalkeyword allows modification of global variables from within a function, whilenonlocalis used in nested functions to reference variables from an enclosing function.
Understanding these concepts is essential for managing variable visibility and preventing errors in Python programming.
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountx = 10
def display():
print(x)
display()Detailed Explanation
In this example, a global variable 'x' is defined with a value of 10. It is defined outside of any function, which means it has global scope and can be accessed anywhere in the program. The function 'display' is defined, and inside this function, the value of 'x' is printed. When we call 'display()', it outputs the value of 'x' which is 10, demonstrating how global variables can be accessed within a function.
Examples & Analogies
Think of a global variable like a public notice board in a classroom. Everyone in the classroom (all the functions in the program) can see and interact with the notices (the global variable) posted on that board.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountdef func():
x = 5
print(x)
func()
print(x) # This will give an error if x is not defined globallyDetailed Explanation
Here, 'func' is defined with a local variable 'x' set to 5. This variable is only accessible within the function 'func'. When we call 'func()', it prints the value of 'x' which is 5. However, if we try to print 'x' outside of the function after the function call, we will receive an error if 'x' is not defined globally, because 'x' is local to 'func' and cannot be accessed outside of it.
Examples & Analogies
Imagine a local variable as a secret held by a friend in a group. Only that friend knows it and can talk about it while the others (the rest of the program) cannot access it unless it's shared explicitly.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountLocal variables are defined inside functions and have a limited scope, whereas global variables are defined outside any function and are accessible throughout the program.
Detailed Explanation
The key difference between global and local variables lies in their scope. A global variable can be accessed from any part of the program, while a local variable is confined to the function in which it is defined. This distinction is crucial because it helps manage the namespace in larger programs where different parts might have variables of the same name.
Examples & Analogies
Think of the local variable like a clubhouse where only certain friends can enter (the function), whereas the global variable is like a neighborhood where everyone can roam freely. If everyone started using the same name for their clubhouses (variables) without the local scope, it would create confusion about whose is whose.
--
Key Concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
Global Variables: Defined outside any function; accessible everywhere in the code.
Local Variables: Defined inside functions; restricted to that function's scope.
Global Keyword: Modifies a global variable within a function.
Nonlocal Keyword: Accesses and modifies a variable in the outer (non-global) scope.
Examples
Memory Aids
Interactive tools to help you remember key concepts
Rhymes
Stories
Memory Tools
Flash Cards
Glossary
Global Variable
A variable that is defined outside of any function and accessible throughout the program.
Local Variable
A variable defined within a function, only accessible within that function's scope.
global keyword
A keyword used in a function to refer to a global variable.
nonlocal keyword
A keyword used in nested functions to refer to variables in the enclosing scopes.