Python Walrus Operator (:=) Explained — Real-World Use Cases and Pitfalls

# --- Regular assignment vs assignment expression ---

# TRADITIONAL approach: compute, store, then check separately
user_input = input('Enter a command: ')
if user_input:                          # user_input already evaluated above
    print(f'You typed: {user_input}')   # use the already-stored value

print('---')

# WALRUS approach: assign AND check in a single expression
# The value from input() is stored in 'command' AND tested for truthiness
if command := input('Enter a command: '):
    print(f'You typed: {command}')      # 'command' is already bound here

print('---')

# Demonstrate that := returns the assigned value
# This shows assignment expressions work inside any expression context
sample_list = [1, 2, 3, 4, 5]

# last_item gets assigned AND the condition is evaluated in one step
if last_item := sample_list[-1]:
    print(f'Last item is: {last_item}')  # last_item is 5, which is truthy

# You can also use it inline to inspect intermediate values
numbers = [10, 20, 30]
print(total := sum(numbers))  # prints 60 AND binds 'total' to 60
print(f'Stored total is still: {total}')  # 'total' persists after the print call

import re
import math

# ============================================================
# PATTERN 1: While-loop chunk reading
# ============================================================

# Simulating a data stream with a list (pretend it's a socket/file)
data_chunks = [b'hello', b'world', b'', b'this_is_ignored']
chunk_index = 0

def read_next_chunk():
    """Simulates reading from a data stream — returns empty bytes when done."""
    global chunk_index
    if chunk_index < len(data_chunks):
        chunk = data_chunks[chunk_index]
        chunk_index += 1
        return chunk
    return b''

print('=== Pattern 1: Streaming Read ===')
# WITHOUT walrus: read() appears twice (or you need a sentinel variable)
# chunk = read_next_chunk()
# while chunk:
#     process(chunk)
#     chunk = read_next_chunk()   # easy to forget this line!

# WITH walrus: one read call per iteration, condition and assignment combined
while received_chunk := read_next_chunk():   # assign AND check truthiness
    print(f'Processing chunk: {received_chunk.decode()}')  # received_chunk is ready

print()

# ============================================================
# PATTERN 2: Comprehension filtering with computed values
# ============================================================

def expensive_transform(value):
    """Simulates a CPU-heavy transformation — we want to call this ONCE per item."""
    result = math.sqrt(value) * 100
    return round(result, 2)

raw_scores = [4, 9, 1, 16, 25, 0, 36]
threshold = 150.0

print('=== Pattern 2: Comprehension with Single Computation ===')

# WITHOUT walrus: expensive_transform() called TWICE for items that pass the filter
results_old = [
    expensive_transform(score)       # called again here for output
    for score in raw_scores
    if expensive_transform(score) >= threshold  # called here for filtering
]
print(f'Old way (double-calls): {results_old}')

# WITH walrus: expensive_transform() called ONCE — result reused in filter AND output
results_new = [
    transformed                      # reuse the already-computed value
    for score in raw_scores
    if (transformed := expensive_transform(score)) >= threshold  # assign AND filter
]
print(f'Walrus way (single-call): {results_new}')

print()

# ============================================================
# PATTERN 3: Regex match in a conditional
# ============================================================

log_lines = [
    '2024-01-15 ERROR: Disk quota exceeded for user admin',
    '2024-01-15 INFO: Backup completed successfully',
    '2024-01-16 ERROR: Connection timeout on port 5432',
    '2024-01-16 DEBUG: Cache warmed in 42ms',
]

error_pattern = re.compile(r'(\d{4}-\d{2}-\d{2}) ERROR: (.+)')

print('=== Pattern 3: Regex Match in Conditional ===')

# WITHOUT walrus: two lines needed before we can use the match object
# for line in log_lines:
#     match_result = error_pattern.search(line)
#     if match_result:
#         date, message = match_result.groups()

# WITH walrus: match and check happen simultaneously
for log_line in log_lines:
    if match_result := error_pattern.search(log_line):   # assign match AND check if it's not None
        error_date, error_message = match_result.groups()
        print(f'[ALERT] Date: {error_date} | Issue: {error_message}')

# ============================================================
# SCOPE RULE: Variables assigned with := inside a comprehension
# LEAK into the enclosing scope (unlike iteration variables)
# ============================================================

temperature_readings = [18.5, 23.1, 35.7, 29.4, 41.2, 15.0]
heat_threshold = 30.0

# After this comprehension, 'peak_temp' will be accessible outside it
hot_days = [
    peak_temp                                           # use the walrus-assigned value
    for reading in temperature_readings                 # 'reading' is scoped to the comprehension
    if (peak_temp := reading) >= heat_threshold        # := assigns AND filters
]

print(f'Hot readings: {hot_days}')          # [35.7, 29.4, 41.2] — wait, 29.4 < 30.0!
# Actually: 35.7, 41.2 pass, 29.4 does NOT pass — let me show correctly:
hot_days_correct = [
    captured                                            
    for reading in temperature_readings
    if (captured := reading) >= heat_threshold          # only 35.7 and 41.2 pass
]
print(f'Hot readings (correct): {hot_days_correct}')   # [35.7, 41.2]

# KEY DEMO: 'captured' is accessible HERE, outside the comprehension
# It holds the LAST value that was assigned by :=, regardless of whether it passed the filter
print(f'Last value captured (even if it did not pass filter): {captured}')  # 15.0 — the last reading

print()

# ============================================================
# SCOPING IN NESTED FUNCTIONS vs MODULE LEVEL
# ============================================================

def process_user_commands(command_queue):
    """Shows walrus scope staying inside the enclosing function, not leaking to module."""
    valid_commands = ['start', 'stop', 'pause', 'resume']

    # := inside a while loop — 'current_command' is scoped to the function
    while (current_command := command_queue.pop(0) if command_queue else '') != '':
        if current_command in valid_commands:
            print(f'Executing: {current_command}')
        else:
            print(f'Unknown command ignored: {current_command}')

    print(f'Last command seen was: {current_command}')  # accessible inside function

command_queue = ['start', 'pause', 'unknown_cmd', 'stop']
process_user_commands(command_queue)

# ============================================================
# ILLEGAL: You cannot use := to assign to the loop variable itself
# ============================================================
# This would raise SyntaxError — uncomment to see the error:
# bad_example = [reading := reading * 2 for reading in temperature_readings]
# SyntaxError: assignment expression cannot rebind comprehension iteration variable

print()
print('Scope demo complete — notice captured leaked out of the comprehension above.')

import hashlib

def hash_password(raw_password):
    """Simulates a slow hashing operation (bcrypt in production)."""
    return hashlib.sha256(raw_password.encode()).hexdigest()

def validate_password_strength(password):
    """Returns True if password meets basic strength requirements."""
    return len(password) >= 8 and any(char.isdigit() for char in password)

# ============================================================
# GOOD USE: Walrus genuinely removes duplication
# ============================================================

password_candidates = ['weak', 'str0ngPass', 'bad', 'S3cureP@ss', '1234abcd']

print('=== GOOD: Walrus prevents double hash computation ===')
# hash_password() is expensive — walrus ensures we call it once and reuse the result
valid_hashes = [
    computed_hash                                          # reuse what we already computed
    for candidate in password_candidates
    if validate_password_strength(candidate)               # filter first (cheap check)
    and (computed_hash := hash_password(candidate))        # then hash once (expensive)
]
for hashed in valid_hashes:
    print(f'  Stored hash: {hashed[:16]}...')             # show first 16 chars only

print()

# ============================================================
# BAD USE: Walrus used where a plain assignment is clearer
# ============================================================

print('=== BAD: Unnecessary walrus — plain = is better here ===')

# DON'T do this — := adds no value when you're not reusing inside an expression
if (user_count := len(password_candidates)) > 0:          # the len() result is trivially cheap
    print(f'Processing {user_count} candidates')          # same result as plain assignment below

# DO this instead — cleaner, same intent, no cleverness required
user_count = len(password_candidates)
if user_count > 0:
    print(f'Processing {user_count} candidates')

print()

# ============================================================
# UGLY: Stacking multiple walrus assignments — avoid
# ============================================================

print('=== UGLY: Over-stacked walrus — never write this ===')
sample_text = 'Python3.8walrus'

# Technically valid but genuinely unreadable:
if (text_length := len(sample_text)) > 5 and (upper_text := sample_text.upper()) and (starts_with_p := upper_text.startswith('P')):
    print(f'Length: {text_length}, Upper: {upper_text}, StartsWithP: {starts_with_p}')

# The readable version — no walrus needed at all:
text_length = len(sample_text)
upper_text = sample_text.upper()
starts_with_p = upper_text.startswith('P')

if text_length > 5 and upper_text and starts_with_p:
    print(f'Length: {text_length}, Upper: {upper_text}, StartsWithP: {starts_with_p}')