message = "Global message"  # Global variable

def print_message():
    message = "Local message"  # Local variable shadows the global one
    print(message)  # Accesses local variable

print_message()  # Output: Local message
print(message)   # Output: Global message

def outer_function():
    count = 0  # Variable in enclosing scope
    
    def inner_function():
        print(f"Count from inner: {count}")  # Can access enclosing variable
    
    inner_function()  # Output: Count from inner: 0
    count += 1
    inner_function()  # Output: Count from inner: 1

outer_function()

counter = 0  # Global variable

def increment():
    # Using the global keyword
    global counter
    counter += 1
    print(f"Counter: {counter}")

increment()  # Output: Counter: 1
increment()  # Output: Counter: 2
print(counter)  # Output: 2

def counter_function():
    count = 0  # Variable in enclosing scope
    
    def increment():
        nonlocal count  # Use nonlocal to modify the enclosing variable
        count += 1
        return count
    
    return increment  # Return the inner function

# Create a counter
counter = counter_function()
print(counter())  # Output: 1
print(counter())  # Output: 2
print(counter())  # Output: 3

# Testing immutability of integers
x = 10
id_before = id(x)  # Get memory address
x += 5             # This operation creates a new integer object
id_after = id(x)   # Get new memory address

print(f"Same integer object? {id_before == id_after}")  # False - different objects

# Testing mutability of lists
my_list = [1, 2, 3]
id_before = id(my_list)
my_list.append(4)     # This modifies the existing list
id_after = id(my_list)

print(f"Same list object? {id_before == id_after}")  # True - same object

import copy

# Creating shallow copies
original_list = [1, 2, 3]
shallow_copy1 = original_list.copy()  # List method
shallow_copy2 = list(original_list)   # Type constructor
shallow_copy3 = original_list[:]      # Slicing
shallow_copy4 = copy.copy(original_list)  # copy module

# Shallow copies work for simple lists
shallow_copy1.append(4)
print(f"original_list: {original_list}")  # [1, 2, 3] - unchanged
print(f"shallow_copy1: {shallow_copy1}")  # [1, 2, 3, 4] - changed

# But shallow copies don't work for nested mutable objects
nested_list = [[1, 2], [3, 4]]
shallow = nested_list.copy()
shallow[0].append(5)  # Modifies the inner list
print(f"nested_list: {nested_list}")  # [[1, 2, 5], [3, 4]] - changed!

# Deep copies handle nested mutable objects
deep = copy.deepcopy(nested_list)
deep[0].append(6)  # Only modifies the copy
print(f"nested_list: {nested_list}")  # [[1, 2, 5], [3, 4]] - unchanged
print(f"deep: {deep}")  # [[1, 2, 5, 6], [3, 4]] - changed

# Program configuration constants
PI = 3.14159
MAX_CONNECTIONS = 100
DATABASE_URL = "postgresql://user:password@localhost/mydb"
TIMEOUT_SECONDS = 30
DEFAULT_LANGUAGE = "en-US"

# Usage example
circle_area = PI * radius * radius

# Example with type hints and documentation
from typing import Final, Dict, List

# Maximum number of login attempts before account lockout
MAX_LOGIN_ATTEMPTS: Final[int] = 5

# Supported languages with their display names
# Keys are ISO language codes, values are display names
SUPPORTED_LANGUAGES: Final[Dict[str, str]] = {
    "en": "English",
    "es": "Spanish",
    "fr": "French",
    "de": "German",
    "ja": "Japanese"
}

# List of restricted usernames that cannot be registered
RESTRICTED_USERNAMES: Final[List[str]] = [
    "admin", "system", "root", "superuser", "administrator"
]

# Variable assignment creates references to objects
x = [1, 2, 3]  # Creates a list object and makes x reference it
y = x          # y now references the same list object
z = [1, 2, 3]  # Creates a different list object with the same values

print(f"x id: {id(x)}")  # e.g., 140243462795272
print(f"y id: {id(y)}")  # Same as x's id
print(f"z id: {id(z)}")  # Different id

# Changing an object through one reference affects all references
y.append(4)
print(f"x: {x}")  # [1, 2, 3, 4] - x sees the change made through y
print(f"y: {y}")  # [1, 2, 3, 4]
print(f"z: {z}")  # [1, 2, 3] - z is a different object

# Object lifetime example
def process_data():
    # Large temporary data
    temp_data = [n for n in range(1000000)]  # Large list created
    result = sum(temp_data)
    return result  # temp_data is now unreferenced and can be freed

# Call the function
total = process_data()  # Memory is reclaimed after function exits

# Basic multiple assignment
x, y, z = 10, 20, 30
print(x, y, z)  # 10 20 30

# Swapping variables without a temporary variable
a, b = 5, 10
a, b = b, a
print(a, b)  # 10 5

# Unpacking collections
coordinates = (3, 4, 5)
x, y, z = coordinates
print(x, y, z)  # 3 4 5

# Unpacking with * operator
first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# Variable annotations (Python 3.6+)
name: str = "Alice"
age: int = 30
height: float = 5.9
active: bool = True
numbers: list[int] = [1, 2, 3]
user: dict[str, str] = {"name": "Bob", "role": "admin"}

# Function with type annotations
def greet(name: str, age: int) -> str:
    return f"Hello {name}, you are {age} years old!"

message = greet("Alice", 30)
print(message)

# List comprehension
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# List comprehension with condition
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

# Dictionary comprehension
square_dict = {x: x**2 for x in range(5)}
print(square_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Set comprehension
unique_letters = {letter for letter in "mississippi"}
print(unique_letters)  # {'i', 'm', 'p', 's'}

# Generator expression (like a list comprehension but creates a generator)
sum_of_squares = sum(x**2 for x in range(10))
print(sum_of_squares)  # 285

name = "Alice"
age = 30

# f-strings (Python 3.6+, recommended)
message1 = f"Hello, {name}! You are {age} years old."

# format() method
message2 = "Hello, {}! You are {} years old.".format(name, age)

# format() with named parameters
message3 = "Hello, {n}! You are {a} years old.".format(n=name, a=age)

# Old-style % formatting
message4 = "Hello, %s! You are %d years old." % (name, age)

print(message1)  # Hello, Alice! You are 30 years old.

# Without walrus operator
data = [1, 2, 3, 4, 5]
n = len(data)
if n > 3:
    print(f"List has {n} items, which is more than 3")

# With walrus operator
data = [1, 2, 3, 4, 5]
if (n := len(data)) > 3:
    print(f"List has {n} items, which is more than 3")

# Another example - finding first even number
numbers = [1, 3, 5, 6, 7, 8]
if (even := next((x for x in numbers if x % 2 == 0), None)):
    print(f"First even number: {even}")

# Poor variable naming
def calc(a, lst, n, flg):
    r = []
    for i in range(n):
        if flg:
            r.append(lst[i] * a)
        else:
            r.append(lst[i] + a)
    return r

# Better variable naming
def transform_elements(multiplier, input_list, num_elements, use_multiplication=True):
    result = []
    for index in range(num_elements):
        if use_multiplication:
            result.append(input_list[index] * multiplier)
        else:
            result.append(input_list[index] + multiplier)
    return result

# Poor practice: Using global variables
total = 0

def add_to_total(value):
    global total
    total += value
    return total

add_to_total(10)  # 10
add_to_total(20)  # 30

# Better practice: Using parameters and return values
def add_values(current_total, value):
    return current_total + value

result = 0
result = add_values(result, 10)  # 10
result = add_values(result, 20)  # 30

# config.py
DATABASE_URL = "postgresql://user:password@localhost/mydb"
API_KEY = "your_api_key"
MAX_CONNECTIONS = 100
TIMEOUT_SECONDS = 30

# app.py
import config

def connect_to_database():
    # Use configuration variables
    connection = establish_connection(
        config.DATABASE_URL,
        max_connections=config.MAX_CONNECTIONS,
        timeout=config.TIMEOUT_SECONDS
    )
    return connection

# Poor: Many separate variables
user_name = "alice"
user_email = "alice@example.com"
user_age = 30
user_is_active = True

# Better: Using a class to organize related variables
class User:
    def __init__(self, name, email, age, is_active=True):
        self.name = name
        self.email = email
        self.age = age
        self.is_active = is_active
    
    def deactivate(self):
        self.is_active = False
    
    def __str__(self):
        status = "active" if self.is_active else "inactive"
        return f"{self.name} ({self.email}), {self.age} years old, {status}"

user = User("alice", "alice@example.com", 30)
print(user)  # alice (alice@example.com), 30 years old, active

# Poor: Manually managing file resource
file = open("data.txt", "w")
file.write("Hello, World!")
file.close()  # Might not be called if an exception occurs

# Better: Using context manager
with open("data.txt", "w") as file:
    file.write("Hello, World!")
# File is automatically closed when the block exits

def get_user_stats(user_id):
    # Fetch user data from database
    # ...
    return ("Alice", 30, ["Python", "JavaScript"], True)

# Poor: Using index positions
user_data = get_user_stats(123)
name = user_data[0]
age = user_data[1]
skills = user_data[2]
is_active = user_data[3]

# Better: Unpacking the tuple
name, age, skills, is_active = get_user_stats(123)

# Even better: Using a namedtuple or dataclass
from collections import namedtuple

UserStats = namedtuple("UserStats", ["name", "age", "skills", "is_active"])

def get_user_stats_improved(user_id):
    # ...
    return UserStats("Alice", 30, ["Python", "JavaScript"], True)

stats = get_user_stats_improved(123)
print(stats.name)     # Alice
print(stats.skills)   # ['Python', 'JavaScript']

# Poor: Using string literals scattered throughout the code
def process_order(status):
    if status == "pending":
        # ...
    elif status == "shipped":
        # ...
    elif status == "delivered":
        # ...

# Better: Using Enum
from enum import Enum, auto

class OrderStatus(Enum):
    PENDING = auto()
    SHIPPED = auto()
    DELIVERED = auto()
    CANCELLED = auto()

def process_order_improved(status):
    if status == OrderStatus.PENDING:
        # ...
    elif status == OrderStatus.SHIPPED:
        # ...
    elif status == OrderStatus.DELIVERED:
        # ...

# Usage
current_status = OrderStatus.PENDING
process_order_improved(current_status)