In Python, the concept of scope determines where a variable can be accessed within the code. A variable’s scope defines its visibility and lifespan, and it is crucial to understand these boundaries to manage variables effectively.
Local Scope
A variable defined inside a function is said to have local scope. This means that the variable is only accessible within the function where it was created.
def myfunc():
x = "The Hobbit"
print(x)
myfunc()
# Expected output: The Hobbit
In the example above, the variable x
is local to myfunc
and cannot be accessed outside of this function. However, it can be accessed by any nested functions within myfunc
.
Function Inside Function
Local variables can be accessed by functions defined within the function where the variable is declared:
def myfunc():
x = "1984"
def myinnerfunc():
print(x)
myinnerfunc()
myfunc()
# Expected output: 1984
Here, the variable x
is accessible within myinnerfunc
because it is defined in the enclosing function myfunc
.
Global Scope
A variable defined outside of all functions is referred to as a global variable. Global variables are accessible from anywhere within the script, including within functions.
x = "Brave New World"
def myfunc():
print(x)
myfunc()
print(x)
# Expected output:
# Brave New World
# Brave New World
In this example, the variable x
is declared globally and can be accessed both inside and outside the myfunc
function.
Naming Variables
If you use the same variable name in both a global and local context, Python treats them as distinct variables. The local variable overshadows the global one within its scope:
x = "To Kill a Mockingbird"
def myfunc():
x = "War and Peace"
print(x)
myfunc()
print(x)
# Expected output:
# War and Peace
# To Kill a Mockingbird
Here, myfunc
prints the local x
(“War and Peace”), while the global x
(“To Kill a Mockingbird”) is printed outside the function.
Using the global
Keyword
To modify a global variable from within a function, you can use the global
keyword to declare that you are working with the global variable, not creating a new local one:
def myfunc():
global x
x = "Moby Dick"
myfunc()
print(x)
# Expected output: Moby Dick
Using global
ensures that changes to the variable are applied globally. This keyword is also necessary if you want to update a global variable within a function:
x = "Pride and Prejudice"
def myfunc():
global x
x = "Ulysses"
myfunc()
print(x)
# Expected output: Ulysses
The variable x
is changed globally from “Pride and Prejudice” to “Ulysses” by the function myfunc
.
Using the nonlocal
Keyword
The nonlocal
keyword is used to work with variables in nested functions. It allows you to refer to a variable in the nearest enclosing scope that is not global:
def myfunc1():
x = "The Catcher in the Rye"
def myfunc2():
nonlocal x
x = "The Great Gatsby"
myfunc2()
return x
print(myfunc1())
# Expected output: The Great Gatsby
In this example, nonlocal
allows myfunc2
to modify x
in myfunc1
, so the returned value is “The Great Gatsby”.