What are the four scopes in python with examples

Luke 63 Published: 12/21/2024

What are the four scopes in python with examples

I'm glad you asked! In Python, the term "scopes" refers to the regions where a variable is defined and can be accessed. There are four main types of scopes: Local, Enclosing, Global, and Built-in.

Local Scope

A local scope is created when a function is called. A variable declared inside a function has its own local scope. The variable is only accessible within that function and is destroyed once the function returns.

Example:

def outer():

x = 10


def inner():


y = 20


print(x)  # Accessible because x is in the enclosing scope


print(y)  # Only accessible here, not outside this inner scope


inner()


print(x)  # Still accessible here, but not outside outer()


outer()


print(x)  # Not accessible here, local scope is gone

In this example, x has a local scope within the outer function. The inner function also has its own local scope. When inner returns, its local scope (and variable y) are destroyed.

Enclosing Scope

When a function is defined inside another function, it inherits the outer function's local scope as its enclosing scope. This means that variables from the outer function can be accessed within the inner function.

Example:

def outer(x):

print("Outer scope:", x)


def inner(y):


print("Inner scope:", y)


print("Outer scope variable:", x)  # Accessible because of enclosing scope


return inner


outer_func = outer(10)


inner_func = outer_func()


inner_func()  # Prints "Outer scope: 10" and then "Inner scope: None"

In this example, the inner function has an enclosing scope that is the outer function's local scope. This allows us to access the x variable from within the inner function.

Global Scope

Variables declared outside of any function have a global scope and can be accessed anywhere in your code. These variables are retained even after functions return.

Example:

g = 100

def func():


print("Global scope variable:", g)


func()


print(g)  # Still accessible

In this example, g has a global scope and can be accessed from anywhere in the code, including within the func function.

Built-in Scope

Python has several built-in functions and variables that are always available. These have their own scope and cannot be overwritten by local or global variables.

Example:

print(len("Hello"))  # Accesses the len() function

print(int("123"))  # Accesses the int() function


print(dir())  # Returns a list of built-in functions and variables

In this example, we're accessing built-in functions like len() and int(), as well as using the dir() function to inspect the built-in scope.

Remember: understanding scopes is crucial for writing efficient, readable, and maintainable Python code. Mastering these concepts will help you write better programs!

What are the four scopes in python w3schools

I'm happy to help you with that! However, I must inform you that W3Schools is a website focused on web development and programming languages like HTML, CSS, JavaScript, and PHP, but not Python.

Python is a high-level, interpreted programming language created by Guido van Rossum. It's widely used for various purposes such as scientific computing, data analysis, artificial intelligence, and more.

Now, regarding the scopes in Python, there are four main types of scope:

Global Scope: The global scope refers to the topmost level of your Python program. Variables defined at this level can be accessed from anywhere within the program. For example: 
x = 5

print(x) # prints 5

In this case, x is a global variable and can be accessed anywhere in the program.

Module Scope: When you define a function or variable inside a Python module (a file that contains Python code), it has its own scope. This scope is specific to that particular module. Variables defined within a module can only be accessed within that module. For instance: 
# mymodule.py

def foo():


x = 10


foo()


print(x) # will raise a NameError: name 'x' is not defined

In this example, x is defined within the foo() function and has its own scope specific to that module. You can't access it outside of that module.

Class Scope: In object-oriented programming (OOP) in Python, classes have their own scope as well. Variables defined inside a class can only be accessed within that class or its instances. For example: 
class MyClass:

def init(self):


self.x = 20


my_obj = MyClass()


print(my_obj.x) # prints 20


print(x) # raises a NameError: name 'x' is not defined

In this case, x is an instance variable of the MyClass class and can only be accessed within that class or its instances.

Local Scope: Local scope refers to the immediate block of code where a variable is defined. Variables defined within a function or a block of code (like an if statement or a loop) have local scope and are only accessible within that specific block. For example: 
x = 5

if x > 10:


y = 20


print(y) # raises a NameError: name 'y' is not defined

In this case, y has local scope and can only be accessed within the if statement.

These four scopes are essential in Python programming as they help you organize your code, avoid naming conflicts, and make it easier to understand and maintain.

Related Articles