Parameters, Arguments and Scope

def create_user_profile(username, user_id, user_role):
    """Creates a user profile formatting string."""
    return f"ID: {user_id} | Name: {username} | Role: {user_role}"

# Positional Arguments: Must match header order exactly
profile1 = create_user_profile("alice_dev", 101, "Admin")
print("Positional Mapping:", profile1)

# Keyword Arguments: Order can be completely customized
profile2 = create_user_profile(user_role="Editor", username="bob_writer", user_id=102)
print("Keyword Mapping   :", profile2)

Positional Mapping: ID: 101 | Name: alice_dev | Role: Admin
Keyword Mapping   : ID: 102 | Name: bob_writer | Role: Editor

def calculate_invoice_total(subtotal, tax_rate=0.18, discount=0.0):
    """Calculates final invoice total with optional tax and discount parameters."""
    discounted_subtotal = subtotal - discount
    tax_amount = discounted_subtotal * tax_rate
    final_total = discounted_subtotal + tax_amount
    return final_total

# Case 1: Uses default tax_rate (0.18) and default discount (0.0)
inv1 = calculate_invoice_total(1000.0)
print(f"Standard Invoice Total  : ${inv1:,.2f}")

# Case 2: Overrides discount, keeps default tax_rate
inv2 = calculate_invoice_total(1000.0, discount=100.0)
print(f"Discounted Invoice Total: ${inv2:,.2f}")

# Case 3: Overrides both tax_rate and discount
inv3 = calculate_invoice_total(1000.0, tax_rate=0.05, discount=50.0)
print(f"Custom Tax/Discount Total: ${inv3:,.2f}")

Standard Invoice Total  : $1,180.00
Discounted Invoice Total: $1,062.00
Custom Tax/Discount Total: $997.50

# INCORRECT (DANGEROUS):
def add_item_bad(item, item_list=[]):  # Shared list across all calls!
    item_list.append(item)
    return item_list

print("Bad Call 1:", add_item_bad("Apple"))
print("Bad Call 2:", add_item_bad("Banana"))  # Unexpectedly contains 'Apple'!

# CORRECT (PYTHONIC STANDARD):
def add_item_clean(item, item_list=None):
    if item_list is None:
        item_list = []  # Instantiate a fresh list inside function scope
    item_list.append(item)
    return item_list

print("\nClean Call 1:", add_item_clean("Apple"))
print("Clean Call 2:", add_item_clean("Banana"))  # Clean fresh list!

Bad Call 1: ['Apple']
Bad Call 2: ['Apple', 'Banana']

Clean Call 1: ['Apple']
Clean Call 2: ['Banana']

def flexible_financial_summary(account_name, *transactions, **metadata):
    """
    Demonstrates combining standard parameters, *args, and **kwargs.
    *transactions packs positional numbers into a Tuple.
    **metadata packs keyword settings into a Dictionary.
    """
    total_balance = sum(transactions)
    print(f"=== Account: {account_name} ===")
    print(f"Transactions Processed ({len(transactions)}): {transactions}")
    print(f"Calculated Net Total Balance : ${total_balance:,.2f}")
    
    print("--- Additional Metadata ---")
    for key, value in metadata.items():
        print(f"  -> {key.upper()}: {value}")

# Invoking function with arbitrary positional and keyword values
flexible_financial_summary(
    "Primary Checking",
    100.0, -25.50, 500.0, -120.00,  # Packed into *transactions tuple
    currency="USD",
    branch_code="NY_901",
    verified=True                 # Packed into **metadata dict
)

=== Account: Primary Checking ===
Transactions Processed (4): (100.0, -25.5, 500.0, -120.0)
Calculated Net Total Balance : $454.50
--- Additional Metadata ---
  -> CURRENCY: USD
  -> BRANCH_CODE: NY_901
  -> VERIFIED: True

# Global Scope
system_status = "GLOBAL: SYSTEM_ONLINE"

def outer_function():
    # Enclosing Scope
    system_status = "ENCLOSING: WORKER_ACTIVE"
    
    def inner_function():
        # Local Scope
        system_status = "LOCAL: TASK_PROCESSING"
        print("Inside Inner Function :", system_status)  # Finds Local (L)
        
    inner_function()
    print("Inside Outer Function :", system_status)      # Finds Enclosing (E)

outer_function()
print("Top-Level Script Scope :", system_status)          # Finds Global (G)

Inside Inner Function : LOCAL: TASK_PROCESSING
Inside Outer Function : ENCLOSING: WORKER_ACTIVE
Top-Level Script Scope : GLOBAL: SYSTEM_ONLINE

global_counter = 0

def increment_counter():
    global global_counter  # Grants permission to modify global scope variable
    global_counter += 1
    print(f"Counter incremented to: {global_counter}")

increment_counter()
increment_counter()
print(f"Final Global State Value: {global_counter}")

Counter incremented to: 1
Counter incremented to: 2
Final Global State Value: 2

def execute_system_action(action_type, **options):
    """
    Parses dynamic kwargs options using match-case pattern matching.
    Demonstrates handling flexible user parameters.
    """
    print(f"Action Requested: '{action_type}'")
    
    match options:
        case {"mode": "FAST", "timeout": timeout_val}:
            print(f"Executing in High-Speed mode with timeout={timeout_val}s.")
            
        case {"mode": "SECURE", "key": secret_key} if len(secret_key) >= 8:
            print("Executing in Encrypted Secure mode with validated key.")
            
        case {"mode": "SECURE", "key": _}:
            print("SECURITY ALERT: Cryptographic key too short!")
            
        case {"retry": retry_count} if isinstance(retry_count, int):
            print(f"Executing standard mode with {retry_count} retries.")
            
        case _:
            print("Executing default fallback system parameters.")

# Testing function calls with varying keyword configurations
execute_system_action("EXPORT_DATA", mode="FAST", timeout=5)
execute_system_action("UPDATE_AUTH", mode="SECURE", key="SecretKey_99")
execute_system_action("SYNC_FILES", retry=3)

Action Requested: 'EXPORT_DATA'
Executing in High-Speed mode with timeout=5s.
Action Requested: 'UPDATE_AUTH'
Executing in Encrypted Secure mode with validated key.
Action Requested: 'SYNC_FILES'
Executing standard mode with 3 retries.