lesson1Title

lesson2Title

lesson3Title

lesson4Title

lesson5Title

lesson6Title

lesson7Title

lesson8Title

lesson9Title

lesson10Title

lesson11Title

lesson12Title

lesson13Title

lesson14Title

lesson15Title

lesson16Title

lesson17Title

lesson18Title

lesson19Title

lesson20Title

lesson21Title

lesson22Title

pythonDataAnalysisBasicChapter2Title

pythonDataAnalysisBasicChapter1Title

pythonDataAnalysisBasicChapter3Title

pythonDataAnalysisBasicChapter4Title

# Example 1: Local vs Global
name = "Olivia"  # Global variable

def greet():
    name = "Liam"  # Local variable
    print("Hello,", name)

greet()
print("Outside function:", name)

# Variable Scope and Nested Functions

In Python, where a variable is defined determines **where it can be accessed** — this concept is called *scope*.

Functions can also be *nested*, meaning one function is defined within another.

<br/>

## 1. Local vs Global Scope

Variables defined **inside a function** are *local* — they only exist while the function is running.

Variables defined **outside any function** are *global* and can be accessed throughout the entire script.


```python title="Local vs Global Scope"
message = "Hello from global scope"

def show_message():
    message = "Hello from local scope"
    print(message)

show_message()
print(message)
```

* Inside the function, a new `message` variable is created.
* The global variable remains unchanged.

<br/>

## 2. Using `global` Keyword

To modify a global variable from inside a function, use the `global` keyword.

```python title="Using global Keyword"
counter = 0

def increase():
    global counter
    counter += 1

increase()
print("Counter:", counter)
```

* Without `global`, Python treats `counter` as a new local variable.
* With `global`, it updates the variable outside the function.

<br/>

## 3. Nested Functions

A function can be defined **inside another** — this is called a *nested* function.
The inner function is local to the outer function and cannot be called directly from outside.

```python title="Nested Functions"
def outer():
    print("Outer function")

    def inner():
        print("Inner function")

    inner()

outer()
```

* `inner()` can only be called inside `outer()`.
* Nested functions help organize logic and **encapsulate behavior**.

<br/>

## Summary

| Concept          | Description                                        |
| ---------------- | -------------------------------------------------- |
| Local Scope      | Variables inside a function                        |
| Global Scope     | Variables outside all functions                    |
| `global` keyword | Allows modifying global variables inside functions |
| Nested Functions | Functions defined inside other functions           |

In Python, to modify a global variable inside a function, you should use the global keyword. This tells Python that the variable being referenced is not local to the function, but rather exists outside of it in the global scope. Without using global, Python will treat the variable as a new local variable.

Concept	Description
Local Scope	Variables inside a function
Global Scope	Variables outside all functions
`global` keyword	Allows modifying global variables inside functions
Nested Functions	Functions defined inside other functions

Variable Scope and Nested Functions

1. Local vs Global Scope

2. Using global Keyword

3. Nested Functions

Summary

What is the correct way to modify a global variable inside a function in Python?

2. Using `global` Keyword