checkmark

Python

Basics of Python

Installing Python Setting up a Development Environment Writing and Running Your First Python Program Python's Syntax and Indentation

Variables and Data Types

Variables in python Numeric Data Types (int, float) Text Data Type (str) Boolean Data Type (bool) Type Conversion (Casting) Dynamic Typing in Python

Control Flow

Conditional Statements (if, elif, else) Comparison Operators Logical Operators Loops (for and while) Loop Control Statements (break and continue)

Functions

Defining Functions Function Parameters and Arguments Return Statements Scope and Lifetime of Variables Lambda Functions Recursion

Data Structures

Lists and List Operations Dictionaries and Dictionary Operations Tuples Sets List Comprehensions Dictionary Comprehensions

File Handling

Opening and Closing Files Reading and Writing Text Files Handling Exceptions in File Operations

Modules and Libraries

Importing Modules Commonly Used Standard Libraries External Libraries: NumPy and Pandas Installing and Managing Libraries with pip

Error Handling

Exceptions in Python Handling Exceptions with try and except Custom Exceptions
menu Back to Edkool

Scope and Lifetime of Variables

Scope and Lifetime of Variables

In Python, the scope of a variable determines where in your code that variable can be accessed and modified. Understanding variable scope is crucial for writing clean and maintainable code.

1. Local Scope

A variable declared inside a function has local scope. This means it can only be accessed within that function. Once the function execution is complete, the variable goes out of scope and is no longer accessible.

For example:

def my_function():
    x = 10  # x has local scope
    print(x)

my_function()
print(x)  # This will raise a NameError as x is not defined in this scope

2. Enclosing (Non-local) Scope

Variables declared in an outer function can be accessed by inner functions within the same scope. This is known as enclosing or non-local scope.

For example:

def outer_function():
    x = 10  # x has enclosing scope
    
    def inner_function():
        print(x)  # inner_function can access x from outer_function
    
    inner_function()

outer_function()

3. Global Scope

A variable declared at the top level of a Python script or module has global scope. This means it can be accessed and modified from anywhere in the script.

For example:

x = 10  # x has global scope

def my_function():
    print(x)  # my_function can access x from global scope

my_function()

4. Built-in Scope

Python has a built-in scope containing pre-defined variables and functions that are available for use in any script or module. These are built-in functions like print(), len(), and variables like True, False, and None.

For example:

print(len("Hello, world!"))  # len is a built-in function

5. Lifetime of Variables

The lifetime of a variable is the duration it exists in memory during program execution. In Python:

  • Local variables have a short lifetime, existing only during the execution of the function in which they are defined.
  • Global variables have a longer lifetime, existing as long as the script or module is in memory.
  • Built-in variables and functions have the longest lifetime, available throughout the entire program execution.

Understanding variable scope and lifetime is important for preventing naming conflicts and memory management. It helps you write code that is easier to maintain and debug.

Previous Return Statements
Next Lambda Functions