Python append() — Silent None Broke a Payment Batch

# io.thecodeforge — Python tutorial

# Real scenario: collecting incoming webhook events before bulk-inserting into a database.
# We receive events one at a time and batch them up to reduce DB round-trips.

def collect_webhook_events(raw_event_stream):
    """
    Accepts an iterable of raw event dicts from a webhook receiver.
    Returns a list of validated event payloads ready for bulk insert.
    """
    validated_events = []  # Start with an empty list — our 'receipt'

    for raw_event in raw_event_stream:
        # Basic validation — skip anything malformed rather than crashing the whole batch
        if not isinstance(raw_event, dict):
            continue
        if "event_type" not in raw_event or "timestamp" not in raw_event:
            continue

        # Build a clean payload — only the fields we actually need
        clean_payload = {
            "event_type": raw_event["event_type"],
            "timestamp": raw_event["timestamp"],
            "user_id": raw_event.get("user_id", "anonymous"),  # default if missing
        }

        # append() mutates validated_events IN PLACE and returns None.
        # Do NOT write: validated_events = validated_events.append(clean_payload)
        # That would replace your list with None immediately.
        validated_events.append(clean_payload)

    return validated_events


# --- Simulate incoming webhook data ---
incoming_stream = [
    {"event_type": "page_view", "timestamp": "2024-01-15T10:00:01Z", "user_id": "usr_001"},
    {"event_type": "button_click", "timestamp": "2024-01-15T10:00:03Z", "user_id": "usr_002"},
    "this_is_malformed",                         # Will be skipped by our type check
    {"event_type": "checkout", "timestamp": "2024-01-15T10:00:07Z"},  # Missing user_id — defaulted
    {"timestamp": "2024-01-15T10:00:09Z"},       # Missing event_type — will be skipped
]

batch = collect_webhook_events(incoming_stream)

print(f"Collected {len(batch)} valid events for bulk insert:")
for event in batch:
    print(event)

# Prove the return value of append() itself is None
proof_list = [1, 2, 3]
return_value = proof_list.append(4)
print(f"\nappend() returned: {return_value}")   # None
print(f"But the list is now: {proof_list}")      # [1, 2, 3, 4]

# io.thecodeforge — Python tutorial

# Scenario: An e-commerce checkout service merges a guest cart (session-based)
# with a logged-in user's saved cart when they authenticate.

guest_cart_items = ["wireless_mouse", "usb_hub"]
saved_cart_items = ["mechanical_keyboard", "monitor_stand", "webcam"]

# --- Scenario 1: WRONG — using append() to merge two lists ---
# This is the exact mistake that produces nested lists in production
wrong_merged_cart = []
wrong_merged_cart.append(guest_cart_items)   # Adds the entire list as ONE item
wrong_merged_cart.append(saved_cart_items)   # Same — another nested list

print("WRONG (append to merge lists):")
print(wrong_merged_cart)
print(f"Item count: {len(wrong_merged_cart)}")  # 2 — not 5!
print()

# --- Scenario 2: CORRECT — using extend() to merge two lists ---
correct_merged_cart = []
correct_merged_cart.extend(guest_cart_items)   # Adds each item individually
correct_merged_cart.extend(saved_cart_items)   # Same — now flat, merged list

print("CORRECT (extend to merge lists):")
print(correct_merged_cart)
print(f"Item count: {len(correct_merged_cart)}")  # 5 — correct
print()

# --- Scenario 3: append() is RIGHT when adding a single new item ---
# Customer adds one more item to their cart after merging
correct_merged_cart.append("laptop_stand")   # One item — append is exactly right here

print("After adding one more item with append():")
print(correct_merged_cart)
print()

# --- Scenario 4: insert() — when ORDER matters and append() isn't enough ---
# A priority item (same-day delivery eligible) must be placed at the front
priority_item = "express_delivery"
correct_merged_cart.insert(0, priority_item)  # index 0 = front of list — O(n) cost

print("After insert() at index 0 for priority item:")
print(correct_merged_cart)
print(f"First item: {correct_merged_cart[0]}")  # express_delivery

# io.thecodeforge — Python tutorial

# Scenario: A log ingestion service reads raw log lines from a file,
# filters out noise (DEBUG level), enriches each line with a severity score,
# and returns a clean batch ready for forwarding to an alerting system.

def process_log_batch(raw_log_lines):
    """
    Filters and enriches a batch of raw log strings.
    Returns only WARNING and above, with a numeric severity attached.
    The accumulator list is LOCAL — no bleed between calls.
    """
    severity_map = {
        "DEBUG": 1,
        "INFO": 2,
        "WARNING": 3,
        "ERROR": 4,
        "CRITICAL": 5,
    }

    # Accumulator defined INSIDE the function — resets to empty on every call.
    # Defining this outside the function is the classic shared-state trap.
    processed_entries = []

    for raw_line in raw_log_lines:
        # Guard: skip blank lines or anything that isn't a string
        if not isinstance(raw_line, str) or not raw_line.strip():
            continue

        parts = raw_line.strip().split(" ", 2)  # Split into max 3 parts: timestamp, level, message
        if len(parts) < 3:
            continue  # Malformed line — skip rather than crash

        timestamp, level, message = parts

        # Only forward WARNING and above to the alerting system
        if level not in severity_map or severity_map[level] < 3:
            continue

        enriched_entry = {
            "timestamp": timestamp,
            "level": level,
            "message": message,
            "severity_score": severity_map[level],  # Numeric score for downstream sorting
        }

        # append() adds this one enriched dict to the end of our accumulator
        processed_entries.append(enriched_entry)

    # Sort by severity descending so CRITICAL bubbles to the top of the alert queue
    processed_entries.sort(key=lambda entry: entry["severity_score"], reverse=True)

    return processed_entries


# --- Simulate a raw log batch from a web server ---
raw_logs = [
    "2024-01-15T10:00:01Z DEBUG  Health check passed",
    "2024-01-15T10:00:03Z INFO   User usr_042 logged in",
    "2024-01-15T10:00:05Z WARNING  Database connection pool at 80% capacity",
    "2024-01-15T10:00:06Z ERROR   Payment gateway timeout after 30s",
    "2024-01-15T10:00:07Z DEBUG  Cache hit ratio: 0.94",
    "2024-01-15T10:00:08Z CRITICAL  Disk usage at 99% on /var/log — writes failing",
    "",                          # Blank line — will be skipped
    "malformed_no_spaces",       # Malformed — will be skipped
]

alerts = process_log_batch(raw_logs)

print(f"Forwarding {len(alerts)} alerts to alerting system (sorted by severity):\n")
for alert in alerts:
    print(f"[{alert['severity_score']}] {alert['level']:8s} | {alert['timestamp']} | {alert['message']}")

# io.thecodeforge — Python tutorial

import copy  # For deep copying nested structures

# ============================================================
# TRAP 1: Mutable default argument — the most infamous Python gotcha
# ============================================================

# WRONG: default argument [] is created ONCE at function definition time
def add_to_order_broken(item, order_items=[]):
    order_items.append(item)
    return order_items

print("=== Mutable Default Argument Trap ===")
order_one = add_to_order_broken("coffee")
order_two = add_to_order_broken("muffin")   # Should start fresh — but it won't
print(f"Order 1 (expected: ['coffee'])   : {order_one}")   # ['coffee', 'muffin'] — WRONG
print(f"Order 2 (expected: ['muffin'])   : {order_two}")   # ['coffee', 'muffin'] — same object!
print()

# CORRECT: use None as sentinel, initialise inside the function
def add_to_order_correct(item, order_items=None):
    if order_items is None:
        order_items = []   # Fresh list on every call that doesn't pass one in
    order_items.append(item)
    return order_items

order_three = add_to_order_correct("coffee")
order_four  = add_to_order_correct("muffin")
print("=== Fixed Version ===")
print(f"Order 3 (expected: ['coffee'])   : {order_three}")  # ['coffee'] — correct
print(f"Order 4 (expected: ['muffin'])   : {order_four}")
print()

# ============================================================
# TRAP 2: Reference aliasing — two names, one list
# ============================================================

print("=== Reference Aliasing Trap ===")

user_a_cart = ["laptop", "mouse"]
user_b_cart = user_a_cart          # NOT a copy — both point to the same list in memory

user_b_cart.append("keyboard")     # Intending to only modify user B's cart

print(f"User A cart (expected unchanged): {user_a_cart}")  # ['laptop', 'mouse', 'keyboard'] — WRONG
print(f"User B cart                     : {user_b_cart}")  # ['laptop', 'mouse', 'keyboard']
print()

# CORRECT: shallow copy for a flat list
user_c_cart = ["laptop", "mouse"]
user_d_cart = user_c_cart.copy()   # Independent copy of the top-level list
user_d_cart.append("keyboard")

print("=== Fixed with .copy() ===")
print(f"User C cart (untouched) : {user_c_cart}")  # ['laptop', 'mouse'] — correct
print(f"User D cart             : {user_d_cart}")  # ['laptop', 'mouse', 'keyboard']
print()

# CORRECT: deep copy when list contains nested mutable objects (e.g. dicts)
user_e_cart = [{"sku": "laptop", "qty": 1}, {"sku": "mouse", "qty": 2}]
user_f_cart = copy.deepcopy(user_e_cart)   # Full independent clone, including nested dicts
user_f_cart[0]["qty"] = 99                 # Change only user F's quantity

print("=== Deep Copy for Nested Objects ===")
print(f"User E laptop qty (untouched): {user_e_cart[0]['qty']}")  # 1 — correct
print(f"User F laptop qty            : {user_f_cart[0]['qty']}")  # 99

# io.thecodeforge — Python tutorial

import time
from collections import deque

# Scenario: Build a list of 1 million integers using different strategies
N = 1_000_000

# --- Strategy 1: append() in loop (the common pattern) ---
start = time.perf_counter()
result = []
for i in range(N):
    result.append(i)
append_time = time.perf_counter() - start
print(f"append() loop: {append_time:.3f}s")

# --- Strategy 2: Preallocate with [None]*N and assign ---
start = time.perf_counter()
result = [None] * N
for i in range(N):
    result[i] = i
prealloc_time = time.perf_counter() - start
print(f"Preallocate + assign: {prealloc_time:.3f}s")

# --- Strategy 3: list comprehension (most Pythonic) ---
start = time.perf_counter()
result = [i for i in range(N)]
lc_time = time.perf_counter() - start
print(f"List comprehension: {lc_time:.3f}s")

# --- Strategy 4: insert(0, item) for building a queue (the wrong way) ---
start = time.perf_counter()
result = []
for i in range(N):
    result.insert(0, i)
insert_time = time.perf_counter() - start
print(f"insert(0, i) loop: {insert_time:.3f}s (avoid! ~ O(n^2))")

# --- Strategy 5: deque appendleft for building a queue ---
start = time.perf_counter()
d = deque()
for i in range(N):
    d.appendleft(i)
deque_time = time.perf_counter() - start
print(f"deque appendleft: {deque_time:.3f}s")

print()
print(f"append() vs preallocate ratio: {append_time / prealloc_time:.2f}x")
print(f"insert(0) vs deque ratio: {insert_time / deque_time:.2f}x — always use deque for left-side adds")