def find_duplicates_brute(s):
    # Compare every character with every other character
    # If they match and we haven't recorded it yet, it's a duplicate
    duplicates = []
    for i in range(len(s)):
        for j in range(i + 1, len(s)):
            if s[i] == s[j] and s[i] not in duplicates:
                duplicates.append(s[i])
    return sorted(duplicates)

print(find_duplicates_brute("programming"))
# Output: ['g', 'm', 'r']

def find_duplicates_set(s):
    # Walk through the string one character at a time
    # Keep a 'seen' set — if a char is already in seen, it's a duplicate
    seen = set()
    duplicates = set()
    for char in s:
        if char in seen:
            duplicates.add(char)
        seen.add(char)
    return sorted(duplicates)

print(find_duplicates_set("programming"))
# Output: ['g', 'm', 'r']

from collections import Counter

def find_duplicates(s):
    # Step 1: Counter scans the string once and builds a dict of {char: count}
    counts = Counter(s)
    print("Counter output:", counts)
    # Output: Counter output: Counter({'g': 2, 'r': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1})
    # ↑ Now we can SEE: 'g', 'r', 'm' each appear 2 times, rest appear 1 time

    # Step 2: Filter — keep only chars where count > 1
    dupes = [char for char, count in counts.items() if count > 1]
    print("Before sorting:", dupes)
    # Output: Before sorting: ['g', 'r', 'm']

    # Step 3: Sort for consistent output (dicts don't guarantee order)
    return sorted(dupes)

print("Result:", find_duplicates("programming"))
# Output: Result: ['g', 'm', 'r']

def is_anagram_sort(s1, s2):
    # If both strings, when sorted, produce the same sequence
    # then they must have the same characters in the same frequency
    return sorted(s1.lower()) == sorted(s2.lower())

print(is_anagram_sort("listen", "silent"))  # Output: True
print(is_anagram_sort("hello", "world"))    # Output: False

def is_anagram_manual(s1, s2):
    # Build frequency maps for both strings manually
    # Then compare the two maps
    s1, s2 = s1.lower(), s2.lower()
    if len(s1) != len(s2):
        return False

    freq = {}
    for char in s1:
        freq[char] = freq.get(char, 0) + 1
    for char in s2:
        freq[char] = freq.get(char, 0) - 1

    # If all counts are zero, strings are anagrams
    return all(v == 0 for v in freq.values())

print(is_anagram_manual("listen", "silent"))  # Output: True
print(is_anagram_manual("hello", "world"))    # Output: False

from collections import Counter

def is_anagram(s1, s2):
    # Counter builds a frequency dict — comparing two Counters is O(n)
    c1 = Counter(s1.lower())
    c2 = Counter(s2.lower())
    print("Step 1 - Counter(s1):", c1)
    # Output: Step 1 - Counter(s1): Counter({'l': 1, 'i': 1, 's': 1, 't': 1, 'e': 1, 'n': 1})
    print("Step 2 - Counter(s2):", c2)
    # Output: Step 2 - Counter(s2): Counter({'s': 1, 'i': 1, 'l': 1, 'e': 1, 'n': 1, 't': 1})
    # ↑ Same keys, same counts — just different order. So they're equal!
    return c1 == c2

print(is_anagram("listen", "silent"))  # Output: True
print(is_anagram("hello", "world"))    # Output: False

def group_anagrams_brute(words):
    # For each word, compare with every other word to see if they're anagrams
    # Two words are anagrams if sorting their characters gives the same result
    used = [False] * len(words)
    result = []

    for i in range(len(words)):
        if used[i]:
            continue
        group = [words[i]]
        used[i] = True

        for j in range(i + 1, len(words)):
            if not used[j] and sorted(words[i].lower()) == sorted(words[j].lower()):
                group.append(words[j])
                used[j] = True

        result.append(sorted(group))

    print(sorted(result))
    # Output: [['ate', 'eat', 'tea'], ['bat'], ['nat', 'tan']]
    return sorted(result)

group_anagrams_brute(["eat", "tea", "tan", "ate", "nat", "bat"])

def group_anagrams_dict(words):
    # Same idea as brute force BUT smarter:
    # Sort each word → use it as a dictionary key → group words with same key
    groups = {}

    for word in words:
        key = ''.join(sorted(word.lower()))
        # Manual check: if key doesn't exist yet, create empty list
        if key not in groups:
            groups[key] = []
        groups[key].append(word)

    print("Groups dict:", groups)
    # Output: Groups dict: {'aet': ['eat', 'tea', 'ate'], 'ant': ['tan', 'nat'], 'abt': ['bat']}

    return sorted([sorted(g) for g in groups.values()])

print(group_anagrams_dict(["eat", "tea", "tan", "ate", "nat", "bat"]))
# Output: [['ate', 'eat', 'tea'], ['bat'], ['nat', 'tan']]

from collections import defaultdict

def group_anagrams(words):
    # defaultdict(list) auto-creates empty list for new keys — no if-check needed
    groups = defaultdict(list)

    for word in words:
        # Step 1: sorted() splits word into individual chars and sorts them
        sorted_chars = sorted(word.lower())
        print(f"  sorted('{word}') → {sorted_chars}")
        # Output:   sorted('eat') → ['a', 'e', 't']
        # Output:   sorted('tea') → ['a', 'e', 't']   ← same as 'eat'!
        # Output:   sorted('tan') → ['a', 'n', 't']
        # Output:   sorted('ate') → ['a', 'e', 't']   ← same as 'eat'!
        # Output:   sorted('nat') → ['a', 'n', 't']   ← same as 'tan'!
        # Output:   sorted('bat') → ['a', 'b', 't']

        # Step 2: join() glues the sorted chars back into one string — becomes dict KEY
        key = ''.join(sorted_chars)
        print(f"  ''.join({sorted_chars}) → '{key}'")
        # Output:   ''.join(['a', 'e', 't']) → 'aet'

        # Step 3: Words with the same key land in the same bucket
        groups[key].append(word)

    # Let's see what the groups dict looks like inside
    print("\nGroups dict:", dict(sorted(groups.items())))
    # Output: Groups dict: {'abt': ['bat'], 'aet': ['eat', 'tea', 'ate'], 'ant': ['tan', 'nat']}
    # ↑ 'eat', 'tea', 'ate' all sorted to 'aet' — so they grouped together!

    # Step 4: Extract the grouped lists, sort each group and the overall result
    result = sorted([sorted(g) for g in groups.values()])
    print("Final result:", result)
    # Output: Final result: [['ate', 'eat', 'tea'], ['bat'], ['nat', 'tan']]
    return result

group_anagrams(["eat", "tea", "tan", "ate", "nat", "bat"])

def longest_unique_brute(s):
    # Generate every possible substring
    # Check if it has all unique characters
    # Track the longest one
    max_len = 0
    for i in range(len(s)):
        for j in range(i + 1, len(s) + 1):
            substring = s[i:j]
            if len(substring) == len(set(substring)):
                max_len = max(max_len, len(substring))
    return max_len

print(longest_unique_brute("abcabcbb"))  # Output: 3
print(longest_unique_brute("bbbbb"))     # Output: 1
print(longest_unique_brute("pwwkew"))    # Output: 3

def longest_unique_set(s):
    # Use two pointers (left, right) to define a window
    # Expand right — if duplicate found, shrink from left
    char_set = set()
    left = 0
    max_len = 0

    for right in range(len(s)):
        # If char already in window, remove from left until it's gone
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)

    return max_len

print(longest_unique_set("abcabcbb"))  # Output: 3
print(longest_unique_set("bbbbb"))     # Output: 1
print(longest_unique_set("pwwkew"))    # Output: 3

def longest_unique_substring(s):
    # Store the last index of each character in a dict
    # When we see a duplicate, jump left pointer past the previous occurrence
    # This avoids the inner while-loop of Solution 2 — true O(n)
    char_index = {}
    left = 0
    max_len = 0

    for right, char in enumerate(s):
        if char in char_index and char_index[char] >= left:
            left = char_index[char] + 1
        char_index[char] = right
        max_len = max(max_len, right - left + 1)

    print("Step 1 - char_index map:", char_index)
    # Output: Step 1 - char_index map: {'a': 3, 'b': 7, 'c': 5}
    # ↑ Each char stores its LAST seen index — this is the jump-to table
    print("Step 2 - max window length:", max_len)
    # Output: Step 2 - max window length: 3

    return max_len

print(longest_unique_substring("abcabcbb"))  # Output: 3
print(longest_unique_substring("bbbbb"))     # Output: 1
print(longest_unique_substring("pwwkew"))    # Output: 3

def reverse_string_manual(s):
    # Convert to list since strings are immutable in Python
    # Swap characters from both ends moving inward
    chars = list(s)
    left, right = 0, len(chars) - 1
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    return ''.join(chars)

print(reverse_string_manual("hello"))
# Output: olleh

def reverse_words_manual(sentence):
    # Split into words, reverse the list, join back
    words = sentence.split()
    reversed_words = []
    for i in range(len(words) - 1, -1, -1):
        reversed_words.append(words[i])
    return ' '.join(reversed_words)

print(reverse_words_manual("Data Engineering is fun"))
# Output: fun is Engineering Data

def reverse_string_builtin(s):
    # reversed() returns an iterator — join it back into a string
    return ''.join(reversed(s))

print(reverse_string_builtin("hello"))
# Output: olleh

def reverse_words_builtin(sentence):
    # Split into words, reverse the list with reversed(), rejoin
    return ' '.join(reversed(sentence.split()))

print(reverse_words_builtin("Data Engineering is fun"))
# Output: fun is Engineering Data

# Reverse characters — [::-1] is the idiomatic Python way
s = "hello"
print("Step 1 - Original:", s)
# Output: Step 1 - Original: hello
print("Step 2 - Reversed:", s[::-1])
# Output: Step 2 - Reversed: olleh

# Reverse words in a sentence
sentence = "Data Engineering is fun"
words = sentence.split()
print("Step 1 - split():", words)
# Output: Step 1 - split(): ['Data', 'Engineering', 'is', 'fun']
print("Step 2 - Reversed:", words[::-1])
# Output: Step 2 - Reversed: ['fun', 'is', 'Engineering', 'Data']
print("Step 3 - Joined:", ' '.join(words[::-1]))
# Output: Step 3 - Joined: fun is Engineering Data

# Bonus: reverse each word individually (keep word order)
print(' '.join(word[::-1] for word in sentence.split()))
# Output: ataD gnireenignE si nuf

def char_frequency_manual(s):
    # Walk through each character, tally in a dictionary
    # Skip spaces since we only care about letters
    freq = {}
    for char in s:
        if char != ' ':
            freq[char] = freq.get(char, 0) + 1
    return dict(sorted(freq.items()))

print(char_frequency_manual("data engineering"))
# Output: {'a': 2, 'd': 1, 'e': 2, 'g': 2, 'i': 2, 'n': 2, 'r': 1, 't': 1}

# Find most common character manually
def most_common_manual(s):
    freq = char_frequency_manual(s)
    return sorted(freq.items(), key=lambda x: (-x[1], x[0]))[0]

print(most_common_manual("data engineering"))
# Output: ('a', 2)

from collections import defaultdict

def char_frequency_dd(s):
    # defaultdict(int) initializes missing keys to 0
    # Cleaner than using .get() with a default
    freq = defaultdict(int)
    for char in s:
        if char != ' ':
            freq[char] += 1
    return dict(sorted(freq.items()))

print(char_frequency_dd("data engineering"))
# Output: {'a': 2, 'd': 1, 'e': 2, 'g': 2, 'i': 2, 'n': 2, 'r': 1, 't': 1}

from collections import Counter

s = "data engineering"
counts = Counter(s.replace(' ', ''))
print("Step 1 - Raw Counter:", counts)
# Output: Step 1 - Raw Counter: Counter({'a': 2, 'n': 2, 'e': 2, 'g': 2, 'i': 2, 'd': 1, 't': 1, 'r': 1})
# ↑ Now we can SEE which chars appear once vs multiple times

# Full frequency sorted by key
print("Step 2 - Sorted:", dict(sorted(counts.items())))
# Output: Step 2 - Sorted: {'a': 2, 'd': 1, 'e': 2, 'g': 2, 'i': 2, 'n': 2, 'r': 1, 't': 1}

# Top 3 most common characters
print("Step 3 - Top 3:", counts.most_common(3))
# Output: Step 3 - Top 3: [('a', 2), ('n', 2), ('e', 2)]

# First non-repeating character
# Iterate the original string (preserves order) but look up counts in Counter
first_unique = next((c for c in s.replace(' ', '') if counts[c] == 1), None)
print("Step 4 - First unique:", first_unique)
# Output: Step 4 - First unique: d

def is_palindrome_loop(s):
    # First strip out anything that isn't a letter or digit
    # Then compare character by character from both ends
    cleaned = ''
    for c in s:
        if c.isalnum():
            cleaned += c.lower()

    for i in range(len(cleaned) // 2):
        if cleaned[i] != cleaned[len(cleaned) - 1 - i]:
            return False
    return True

print(is_palindrome_loop("A man, a plan, a canal: Panama"))  # Output: True
print(is_palindrome_loop("race a car"))                      # Output: False

def is_palindrome_twoptr(s):
    # Use two pointers from both ends, skip non-alphanumeric chars
    # This avoids creating a cleaned copy of the string
    left, right = 0, len(s) - 1
    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        if s[left].lower() != s[right].lower():
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome_twoptr("A man, a plan, a canal: Panama"))  # Output: True
print(is_palindrome_twoptr("race a car"))                      # Output: False

def is_palindrome(s):
    # Clean: keep only alphanumeric, lowercase everything
    # Then compare string with its reverse using slicing
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    print("Step 1 - Cleaned:", cleaned)
    # Output: Step 1 - Cleaned: amanaplanacanalpanama
    print("Step 2 - Reversed:", cleaned[::-1])
    # Output: Step 2 - Reversed: amanaplanacanalpanama
    # ↑ Same forwards and backwards — it's a palindrome!
    return cleaned == cleaned[::-1]

print(is_palindrome("A man, a plan, a canal: Panama"))  # Output: True
print(is_palindrome("race a car"))                      # Output: False

def compress_basic(s):
    if not s:
        return s
    # Walk through string comparing each char with the next
    # When the character changes, record the char and its count
    result = ""
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i - 1]:
            count += 1
        else:
            result += s[i - 1] + str(count)
            count = 1
    # Don't forget the last group of characters
    result += s[-1] + str(count)
    return result if len(result) < len(s) else s

print(compress_basic("aabcccccaaa"))  # Output: a2b1c5a3
print(compress_basic("abcdef"))       # Output: abcdef

def compress_list(s):
    if not s:
        return s
    # String concatenation in a loop creates a new string each time — O(n^2)
    # Using a list and joining at the end is O(n)
    result = []
    count = 1

    for i in range(1, len(s)):
        if s[i] == s[i - 1]:
            count += 1
        else:
            result.append(f"{s[i - 1]}{count}")
            count = 1
    result.append(f"{s[-1]}{count}")

    compressed = ''.join(result)
    return compressed if len(compressed) < len(s) else s

print(compress_list("aabcccccaaa"))  # Output: a2b1c5a3
print(compress_list("abcdef"))       # Output: abcdef

from itertools import groupby

def compress(s):
    if not s:
        return s
    # groupby clusters consecutive identical characters together
    # Each group gives us the character and an iterator of occurrences
    groups = [(char, sum(1 for _ in group)) for char, group in groupby(s)]
    print("Step 1 - Groups:", groups)
    # Output: Step 1 - Groups: [('a', 2), ('b', 1), ('c', 5), ('a', 3)]
    # ↑ Each tuple = (character, consecutive count)

    compressed = ''.join(f"{char}{count}" for char, count in groups)
    print("Step 2 - Compressed:", compressed)
    # Output: Step 2 - Compressed: a2b1c5a3

    return compressed if len(compressed) < len(s) else s

print(compress("aabcccccaaa"))  # Output: a2b1c5a3
print(compress("abcdef"))       # Output: abcdef

def two_sum_brute(nums, target):
    # Try every possible pair of numbers
    # If their sum equals the target, return both indices
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

print(two_sum_brute([2, 7, 11, 15], 9))  # Output: [0, 1]
print(two_sum_brute([3, 2, 4], 6))        # Output: [1, 2]

def two_sum_sorted(nums, target):
    # Create index-value pairs, sort by value
    # Use two pointers from both ends
    indexed = sorted(enumerate(nums), key=lambda x: x[1])
    left, right = 0, len(indexed) - 1

    while left < right:
        current_sum = indexed[left][1] + indexed[right][1]
        if current_sum == target:
            # Return original indices, sorted for consistency
            return sorted([indexed[left][0], indexed[right][0]])
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

print(two_sum_sorted([2, 7, 11, 15], 9))  # Output: [0, 1]
print(two_sum_sorted([3, 2, 4], 6))        # Output: [1, 2]

def two_sum(nums, target):
    # For each number, compute its complement (target - num)
    # If the complement is already in our hash map, we found the pair
    # Otherwise, store this number's index for future lookups
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        print(f"Step {i+1} - num={num}, complement={complement}, seen={seen}")
        # Output (iteration 1): Step 1 - num=2, complement=7, seen={}
        # Output (iteration 2): Step 2 - num=7, complement=2, seen={2: 0}
        # ↑ complement 2 IS in seen — match found! Return [0, 1]
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

print(two_sum([2, 7, 11, 15], 9))  # Output: [0, 1]
print(two_sum([3, 2, 4], 6))        # Output: [1, 2]

def fizzbuzz_basic(n):
    # Check divisibility in the right order:
    # 15 first (both 3 and 5), then 3, then 5, then plain number
    result = []
    for i in range(1, n + 1):
        if i % 15 == 0:
            result.append("FizzBuzz")
        elif i % 3 == 0:
            result.append("Fizz")
        elif i % 5 == 0:
            result.append("Buzz")
        else:
            result.append(str(i))
    return result

print(fizzbuzz_basic(15))
# Output: ['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

def fizzbuzz_concat(n):
    # Build the output string by concatenating "Fizz" and "Buzz" separately
    # This scales better if new rules are added (e.g., "Jazz" for 7)
    result = []
    for i in range(1, n + 1):
        output = ""
        if i % 3 == 0:
            output += "Fizz"
        if i % 5 == 0:
            output += "Buzz"
        result.append(output if output else str(i))
    return result

print(fizzbuzz_concat(15))
# Output: ['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

def fizzbuzz(n):
    # One-liner using conditional expressions in a list comprehension
    # Compact but still readable — shows Python fluency
    result = [
        'FizzBuzz' if i % 15 == 0
        else 'Fizz' if i % 3 == 0
        else 'Buzz' if i % 5 == 0
        else str(i)
        for i in range(1, n + 1)
    ]
    print("Step 1 - First 5:", result[:5])
    # Output: Step 1 - First 5: ['1', '2', 'Fizz', '4', 'Buzz']
    print("Step 2 - Last 3:", result[-3:])
    # Output: Step 2 - Last 3: ['13', '14', 'FizzBuzz']
    # ↑ 15 hits both % 3 and % 5, so it becomes 'FizzBuzz'
    return result

print(fizzbuzz(15))
# Output: ['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

def remove_dupes_basic(lst):
    # Walk through the list and only add items we haven't seen yet
    result = []
    for item in lst:
        if item not in result:
            result.append(item)
    return result

print(remove_dupes_basic([1, 3, 2, 3, 1, 5, 2]))
# Output: [1, 3, 2, 5]

def remove_dupes_set(lst):
    # 'item not in result' in Solution 1 is O(n) — making overall O(n^2)
    # Using a set for lookups makes each check O(1) — overall O(n)
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

print(remove_dupes_set([1, 3, 2, 3, 1, 5, 2]))
# Output: [1, 3, 2, 5]

def remove_dupes(lst):
    # dict.fromkeys preserves insertion order (Python 3.7+)
    # Keys are unique by definition, so duplicates are dropped
    as_dict = dict.fromkeys(lst)
    print("Step 1 - dict.fromkeys:", as_dict)
    # Output: Step 1 - dict.fromkeys: {1: None, 3: None, 2: None, 5: None}
    # ↑ Duplicates gone! Keys kept first-occurrence order. Values are None.
    print("Step 2 - Extract keys:", list(as_dict))
    # Output: Step 2 - Extract keys: [1, 3, 2, 5]
    return list(as_dict)

print(remove_dupes([1, 3, 2, 3, 1, 5, 2]))
# Output: [1, 3, 2, 5]

def flatten_recursive(lst):
    # Walk through each element
    # If it's a list, recursively flatten it and add all elements
    # If it's not a list, just add it directly
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten_recursive(item))
        else:
            result.append(item)
    return result

print(flatten_recursive([1, [2, [3, 4], 5], 6]))
# Output: [1, 2, 3, 4, 5, 6]

def flatten_iterative(lst):
    # Use a stack to avoid recursion (avoids stack overflow on deep nesting)
    # Process from right to left so output is in correct order
    stack = list(lst)
    result = []
    while stack:
        item = stack.pop(0)
        if isinstance(item, list):
            # Insert sub-items at the front of the stack to preserve order
            stack = item + stack
        else:
            result.append(item)
    return result

print(flatten_iterative([1, [2, [3, 4], 5], 6]))
# Output: [1, 2, 3, 4, 5, 6]

def flatten(lst):
    # Generator function yields items one at a time
    # Uses 'yield from' for recursive flattening — clean and memory-efficient
    for item in lst:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

data = [1, [2, [3, 4], 5], 6]
gen = flatten(data)
print("Step 1 - Generator object:", gen)
# Output: Step 1 - Generator object: <generator object flatten at 0x...>
# ↑ Nothing computed yet — it's lazy!
result = list(gen)
print("Step 2 - Consumed:", result)
# Output: Step 2 - Consumed: [1, 2, 3, 4, 5, 6]

# Bonus: one-level flatten with list comprehension (when depth = 1)
nested = [[1, 2], [3, 4], [5, 6]]
flat = [x for sublist in nested for x in sublist]
print(flat)
# Output: [1, 2, 3, 4, 5, 6]

def find_missing_sort(nums, n):
    # Sort the list, then walk through looking for a gap
    # When nums[i] doesn't match expected value (i+1), that's the missing one
    nums_sorted = sorted(nums)
    for i in range(len(nums_sorted)):
        if nums_sorted[i] != i + 1:
            return i + 1
    # If no gap found, the missing number is n (the last one)
    return n

print(find_missing_sort([1, 2, 4, 5, 6], 6))
# Output: 3

def find_missing_math(nums, n):
    # The sum of 1 to n = n*(n+1)/2
    # Subtract the actual sum of the list — the difference is the missing number
    expected = n * (n + 1) // 2
    actual = sum(nums)
    return expected - actual

print(find_missing_math([1, 2, 4, 5, 6], 6))
# Output: 3

def find_missing_xor(nums, n):
    # XOR has the property: a ^ a = 0 and a ^ 0 = a
    # XOR all numbers from 1 to n, then XOR with all numbers in the list
    # Every number that appears in both cancels out, leaving only the missing one
    xor = 0
    for i in range(1, n + 1):
        xor ^= i
    print("Step 1 - XOR of 1..n:", xor)
    # Output: Step 1 - XOR of 1..n: 7
    # ↑ 1^2^3^4^5^6 = 7

    for num in nums:
        xor ^= num
    print("Step 2 - After XOR with list:", xor)
    # Output: Step 2 - After XOR with list: 3
    # ↑ All paired numbers cancelled out, only 3 (the missing one) remains

    return xor

print(find_missing_xor([1, 2, 4, 5, 6], 6))
# Output: 3

def find_missing_set(nums, n):
    # Create the full set and subtract the given numbers
    return (set(range(1, n + 1)) - set(nums)).pop()

print(find_missing_set([1, 2, 4, 5, 6], 6))
# Output: 3

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Transpose: swap rows and columns using nested loops
def transpose_manual(m):
    rows, cols = len(m), len(m[0])
    # Create a new matrix where result[j][i] = m[i][j]
    result = []
    for j in range(cols):
        new_row = []
        for i in range(rows):
            new_row.append(m[i][j])
        result.append(new_row)
    return result

print(transpose_manual(matrix))
# Output: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# Flatten: just iterate all rows and all elements
def flatten_manual(m):
    result = []
    for row in m:
        for val in row:
            result.append(val)
    return result

print(flatten_manual(matrix))
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Rotate 90 CW: transpose then reverse each row
def rotate_manual(m):
    t = transpose_manual(m)
    return [row[::-1] for row in t]

print(rotate_manual(matrix))
# Output: [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Transpose using list comprehension
transposed = [[matrix[i][j] for i in range(len(matrix))]
              for j in range(len(matrix[0]))]
print(transposed)
# Output: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# Flatten using list comprehension
flat = [x for row in matrix for x in row]
print(flat)
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Transpose: zip(*matrix) unpacks each row as an argument to zip
# zip groups the first elements, second elements, etc.
print("Step 1 - Raw zip tuples:", list(zip(*matrix)))
# Output: Step 1 - Raw zip tuples: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
# ↑ zip returns tuples — we convert each to a list
transposed = [list(row) for row in zip(*matrix)]
print("Step 2 - Transposed:", transposed)
# Output: Step 2 - Transposed: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# Flatten
flat = [x for row in matrix for x in row]
print(flat)
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Rotate 90 clockwise: reverse the rows first, then transpose
print("Step 1 - Reversed rows:", matrix[::-1])
# Output: Step 1 - Reversed rows: [[7, 8, 9], [4, 5, 6], [1, 2, 3]]
# matrix[::-1] reverses row order, then zip groups columns
rotated = [list(row) for row in zip(*matrix[::-1])]
print("Step 2 - Rotated 90 CW:", rotated)
# Output: Step 2 - Rotated 90 CW: [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

# Merge: copy d1, then update with d2
def merge_manual(d1, d2):
    # Start with a copy of d1 so we don't mutate the original
    # Then add/overwrite with all key-value pairs from d2
    result = {}
    for k, v in d1.items():
        result[k] = v
    for k, v in d2.items():
        result[k] = v
    return result

print(merge_manual({'a': 1, 'b': 2}, {'b': 3, 'c': 4}))
# Output: {'a': 1, 'b': 3, 'c': 4}

# Invert: swap keys and values
def invert_manual(d):
    result = {}
    for k, v in d.items():
        result[v] = k
    return result

print(invert_manual({'a': 1, 'b': 2, 'c': 3}))
# Output: {1: 'a', 2: 'b', 3: 'c'}

# Sort by value descending
def sort_by_value_manual(d):
    # Convert to list of tuples, sort by second element, rebuild dict
    pairs = list(d.items())
    pairs.sort(key=lambda x: x[1], reverse=True)
    return dict(pairs)

print(sort_by_value_manual({'alice': 85, 'bob': 92, 'charlie': 78}))
# Output: {'bob': 92, 'alice': 85, 'charlie': 78}

# Merge with update()
def merge_update(d1, d2):
    # dict.update modifies in place, so copy first
    result = d1.copy()
    result.update(d2)
    return result

print(merge_update({'a': 1, 'b': 2}, {'b': 3, 'c': 4}))
# Output: {'a': 1, 'b': 3, 'c': 4}

# Invert with dict comprehension
original = {'a': 1, 'b': 2, 'c': 3}
inverted = {v: k for k, v in original.items()}
print(inverted)
# Output: {1: 'a', 2: 'b', 3: 'c'}

# Sort by value with sorted()
scores = {'alice': 85, 'bob': 92, 'charlie': 78}
sorted_scores = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))
print(sorted_scores)
# Output: {'bob': 92, 'alice': 85, 'charlie': 78}

# Merge with | operator (Python 3.9+)
d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
print("Step 1 - d1:", d1, "| d2:", d2)
# Output: Step 1 - d1: {'a': 1, 'b': 2} | d2: {'b': 3, 'c': 4}
merged = d1 | d2  # d2 values overwrite d1 on key conflict
print("Step 2 - Merged:", merged)
# Output: Step 2 - Merged: {'a': 1, 'b': 3, 'c': 4}
# ↑ Key 'b' conflict: d2's value (3) wins over d1's value (2)

# For Python 3.5+, use unpacking
merged_compat = {**d1, **d2}
print(merged_compat)
# Output: {'a': 1, 'b': 3, 'c': 4}

# Invert with comprehension
original = {'a': 1, 'b': 2, 'c': 3}
print("Step 1 - original.items():", list(original.items()))
# Output: Step 1 - original.items(): [('a', 1), ('b', 2), ('c', 3)]
inverted = {v: k for k, v in original.items()}
print("Step 2 - Inverted:", inverted)
# Output: Step 2 - Inverted: {1: 'a', 2: 'b', 3: 'c'}

# Sort by value
scores = {'alice': 85, 'bob': 92, 'charlie': 78}
print("Step 1 - Unsorted items:", list(scores.items()))
# Output: Step 1 - Unsorted items: [('alice', 85), ('bob', 92), ('charlie', 78)]
sorted_scores = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))
print("Step 2 - Sorted desc:", sorted_scores)
# Output: Step 2 - Sorted desc: {'bob': 92, 'alice': 85, 'charlie': 78}

# Bonus: Group by value using defaultdict
from collections import defaultdict
data = [('a', 1), ('b', 2), ('a', 3), ('b', 4)]
grouped = defaultdict(list)
for key, val in data:
    grouped[key].append(val)
print(dict(sorted(grouped.items())))
# Output: {'a': [1, 3], 'b': [2, 4]}

import sys

# List comprehension: uses square brackets []
# Creates the ENTIRE list in memory at once
squares_list = [x ** 2 for x in range(1000000)]
list_size = sys.getsizeof(squares_list)
print(f"List size: {list_size} bytes")
# Output: List size: 8448728 bytes

# Generator expression: uses parentheses ()
# Produces items ONE AT A TIME, on demand — lazy evaluation
squares_gen = (x ** 2 for x in range(1000000))
gen_size = sys.getsizeof(squares_gen)
print(f"Generator size: {gen_size} bytes")
# Output: Generator size: 200 bytes

# Both produce the same values
small_list = [x ** 2 for x in range(5)]
small_gen = (x ** 2 for x in range(5))
print(small_list)
# Output: [0, 1, 4, 9, 16]
print(list(small_gen))
# Output: [0, 1, 4, 9, 16]

# Generators are LAZY — they compute values only when asked
def noisy_square(x):
    # This function prints when called, so we can see when computation happens
    print(f"  Computing {x}^2")
    return x ** 2

# List comprehension: ALL computations happen immediately
print("List comprehension (eager):")
result_list = [noisy_square(x) for x in range(3)]
# Output:
#   Computing 0^2
#   Computing 1^2
#   Computing 2^2
print(f"Result: {result_list}")
# Output: Result: [0, 1, 4]

print()

# Generator: computations happen only when you iterate
print("Generator expression (lazy):")
result_gen = (noisy_square(x) for x in range(3))
print("Generator created, nothing computed yet.")
# Output: Generator created, nothing computed yet.
print("Now iterating:")
# Output: Now iterating:
for val in result_gen:
    print(f"  Got: {val}")
# Output:
#   Computing 0^2
#   Got: 0
#   Computing 1^2
#   Got: 1
#   Computing 2^2
#   Got: 4

import sys

# WHEN TO USE LIST: need random access, len(), or iterate multiple times
data_list = [x ** 2 for x in range(10)]
print(data_list[5])     # Random access works
# Output: 25
print(len(data_list))   # len() works
# Output: 10

# WHEN TO USE GENERATOR: huge data, single pass, memory matters
# Real data engineering use: processing a large CSV without loading it all
def process_large_file(filepath):
    """Process a file line by line without loading it all into memory."""
    with open(filepath) as f:
        # Generator — yields one cleaned line at a time
        # Only 1 line in memory at any point
        valid_lines = (line.strip() for line in f
                       if not line.startswith('#'))
        for line in valid_lines:
            pass  # process each line here

# Key difference: generators are single-use
gen = (x for x in range(5))
first_pass = list(gen)
second_pass = list(gen)
print(f"First pass: {first_pass}")
# Output: First pass: [0, 1, 2, 3, 4]
print(f"Second pass: {second_pass}")
# Output: Second pass: []

# Chaining generators for ETL pipelines — each stage is lazy
raw_data = range(1, 11)
print("Step 1 - Raw data:", list(raw_data))
# Output: Step 1 - Raw data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Step 2 - After double:", [x * 2 for x in raw_data])
# Output: Step 2 - After double: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
print("Step 3 - After filter >10:", [x * 2 for x in raw_data if x * 2 > 10])
# Output: Step 3 - After filter >10: [12, 14, 16, 18, 20]
# ↑ These prints show each stage — but in production, use generators:

step1 = (x * 2 for x in raw_data)        # transform: double
step2 = (x for x in step1 if x > 10)     # filter: keep > 10
step3 = (f"val={x}" for x in step2)       # format: add label
# Nothing has been computed yet — only when we consume:
print(list(step3))
# Output: ['val=12', 'val=14', 'val=16', 'val=18', 'val=20']

def add_item(item, lst=[]):
    lst.append(item)
    return lst

print(add_item("a"))
print(add_item("b"))
print(add_item("c"))

# Output:
# ['a']
# ['a', 'b']
# ['a', 'b', 'c']

def add_item(item, lst=None):
    if lst is None:  # Create a NEW list each time — None is immutable, safe as default
        lst = []
    lst.append(item)
    return lst

# Output:
# ['a']
# ['b']
# ['c']

a = [1, 2, 3]
b = a            # b is NOT a copy — it is the SAME object
b.append(4)
print(a)
print(b)

# Output:
# [1, 2, 3, 4]
# [1, 2, 3, 4]

a = [1, 2, 3]
b = a[:]          # Shallow copy via slicing — creates a NEW list
b.append(4)
print(a)          # Output: [1, 2, 3]   — original unchanged
print(b)          # Output: [1, 2, 3, 4]

# Other ways to shallow copy:
b = a.copy()      # Shallow copy via method
b = list(a)       # Shallow copy via constructor

# WARNING: shallow copy is NOT enough for nested lists!
import copy
a = [[1, 2], [3, 4]]
b = a.copy()          # Shallow copy — inner lists are still shared
b[0].append(5)
print(a)              # Output: [[1, 2, 5], [3, 4]] — CHANGED!
b = copy.deepcopy(a)  # Deep copy — everything is independent

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)       # Comparing VALUES

print(a is b)       # Comparing IDENTITY (same object in memory?)

x = 256
y = 256
print(x is y)       # Integer caching range: -5 to 256

p = int("257")      # int() forces a new object creation
q = int("257")      # Another new object
print(p is q)       # Outside caching range

# Output:
# True    ← same values
# False   ← different objects in memory
# True    ← 256 is cached by Python (range -5 to 256)
# False   ← 257 is outside cache range, so two separate objects

# ALWAYS use == for value comparison
if a == b:         # Correct — compares values
    print("equal")

# ONLY use 'is' for None checks
if x is None:      # Correct — None is a singleton
    print("missing")

# NEVER do this:
if x is 257:       # Wrong — identity check on integers is unreliable
    print("match")

s = "abc"
try:
    s[0] = "x"         # Strings are IMMUTABLE — cannot change in place
except TypeError as e:
    print(f"Error: {e}")

# Now the nested list trap:
matrix = [[0] * 3] * 3   # This creates 3 references to the SAME inner list
matrix[0][0] = 1
print(matrix)

# Output:
# Error: 'str' object does not support item assignment
# [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

# Fix for string mutation:
s = "abc"
s = "x" + s[1:]           # Output: "xbc" — creates a NEW string

# Fix for matrix — use list comprehension to create INDEPENDENT rows:
matrix = [[0] * 3 for _ in range(3)]  # Each row is a separate list object
matrix[0][0] = 1
print(matrix)
# Output: [[1, 0, 0], [0, 0, 0], [0, 0, 0]] — only first row changed

functions = []
for i in range(5):
    functions.append(lambda: i)  # lambda captures the VARIABLE i, not its current value

print([f() for f in functions])

# Output:
# [4, 4, 4, 4, 4]

# Fix 1: Default argument captures current value at definition time
functions = []
for i in range(5):
    functions.append(lambda i=i: i)  # i=i binds the current value as a default

print([f() for f in functions])
# Output: [0, 1, 2, 3, 4]

# Fix 2: Use functools.partial
from functools import partial
functions = [partial(lambda x: x, i) for i in range(5)]
print([f() for f in functions])
# Output: [0, 1, 2, 3, 4]

a = (1)       # Parentheses around an integer — just grouping
b = (1,)      # Trailing comma makes it a tuple
c = ()        # Empty tuple — no ambiguity here

print(type(a))
print(type(b))
print(type(c))

# Output:
# <class 'int'>
# <class 'tuple'>
# <class 'tuple'>

# Always use trailing comma for single-element tuples
single = (1,)         # Correct — this is a tuple
print(type(single))   # Output: <class 'tuple'>

# You can even omit parentheses — the comma is what matters
also_tuple = 1,
print(type(also_tuple))  # Output: <class 'tuple'>

# Multi-element tuples do not need trailing comma (but it is good style)
multi = (1, 2, 3)     # Output: tuple
multi = (1, 2, 3,)    # Also valid — trailing comma is optional

d = {
    True: 'yes',       # True has hash same as 1
    1: 'one',          # 1 == True, so this OVERWRITES the value
    1.0: 'float_one'   # 1.0 == 1 == True, overwrites again
}
print(d)
print(len(d))

# Output:
# {True: 'float_one'}
# 1

# If you need them as separate keys, use different types or wrappers
d = {
    'bool_true': 'yes',
    'int_one': 'one',
    'float_one': 'float_one'
}
# Or be aware that True/1/1.0 collide and design accordingly

print(1 < 2 < 3)                  # Chained: (1 < 2) and (2 < 3)
print(1 < 2 > 0)                  # Chained: (1 < 2) and (2 > 0)
print(1 < 3 > 2)                  # Chained: (1 < 3) and (3 > 2)
print(False == False in [False])   # Tricky chaining with 'in' operator

# Output:
# True
# True
# True
# True

# Use explicit parentheses to make intent clear
result = (False == False) in [False]   # True in [False] → True
# vs
result = False == (False in [False])   # False == True → False

# Chaining is great for range checks though:
x = 5
if 0 <= x <= 10:    # Clean and Pythonic — instead of: if x >= 0 and x <= 10
    print("valid")
# Output: valid

def show(a, b, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")                     # Extra positional → tuple
    print(f"kwargs={sorted(kwargs.items())}")  # Extra keyword → dict (sorted for determinism)

show(1, 2, 3, 4, 5, x=10, y=20)

# Output:
# a=1, b=2
# args=(3, 4, 5)
# kwargs=[('x', 10), ('y', 20)]

# Unpacking in function calls — the reverse operation
def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
print(add(*nums))         # Output: 6 — unpacks list as positional args

config = {'a': 1, 'b': 2, 'c': 3}
print(add(**config))      # Output: 6 — unpacks dict as keyword args

# Full signature order in Python 3.8+:
# def f(pos_only, /, normal, *, kw_only, **kwargs)

x = 10               # Global scope

def outer():
    x = 20            # Enclosing scope
    def inner():
        x = 30        # Local scope — shadows outer and global
        print("inner:", x)
    inner()
    print("outer:", x)  # Still 20 — inner's x was local to inner

outer()
print("global:", x)    # Still 10 — nothing modified global x

# Output:
# inner: 30
# outer: 20
# global: 10

x = 10

def outer():
    x = 20
    def inner():
        nonlocal x    # Now refers to outer's x — not a new local
        x = 30
    inner()
    print("outer:", x)  # Output: 30 — changed by inner via nonlocal

outer()

def change_global():
    global x          # Now refers to module-level x
    x = 99

change_global()
print("global:", x)   # Output: 99 — changed by global keyword

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

# enumerate starts at 0 by default — but you can change it
for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

print("---")

# zip pairs elements from multiple iterables
for name, score in zip(names, scores):
    print(f"{name}: {score}")

print("---")

# Unzip trick — zip(*iterable) transposes rows and columns
pairs = [('a', 1), ('b', 2), ('c', 3)]
letters, numbers = zip(*pairs)   # zip(('a',1), ('b',2), ('c',3))
print(letters)
print(numbers)

# Output:
# 1. Alice
# 2. Bob
# 3. Charlie
# ---
# Alice: 85
# Bob: 92
# Charlie: 78
# ---
# ('a', 'b', 'c')
# (1, 2, 3)

# If iterables have different lengths, zip silently truncates:
a = [1, 2, 3]
b = [10, 20]
print(list(zip(a, b)))    # Output: [(1, 10), (2, 20)] — 3 is dropped!

# Use itertools.zip_longest to keep all elements:
from itertools import zip_longest
print(list(zip_longest(a, b, fillvalue=0)))
# Output: [(1, 10), (2, 20), (3, 0)]

# Walrus operator assigns AND returns the value in one expression
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Without walrus — you compute x**2 twice (once to filter, once to keep)
results_old = [x**2 for x in numbers if x**2 > 25]

# With walrus — compute once, use twice
results_new = [y for x in numbers if (y := x**2) > 25]

print(results_old)
print(results_new)
print(results_old == results_new)

# Output:
# [36, 49, 64, 81, 100]
# [36, 49, 64, 81, 100]
# True

# Classic use case — avoid calling a function twice
import re
text = "Today is 2026-03-27"
if (match := re.search(r'\d{4}-\d{2}-\d{2}', text)):  # Assign and test in one line
    print(f"Found date: {match.group()}")
# Output: Found date: 2026-03-27

# While loop — cleaner than the two-call pattern
# Without walrus:
# line = input()
# while line != "quit":
#     process(line)
#     line = input()

# With walrus:
# while (line := input()) != "quit":
#     process(line)

print(any([0, '', None, False, 42]))   # Is ANY element truthy?
print(all([1, 'a', True, [1]]))        # Are ALL elements truthy?
print(all([1, 'a', True, []]))         # [] is falsy!
print(any([]))                          # any of nothing?
print(all([]))                          # all of nothing?

# Output:
# True     ← 42 is truthy, so any() returns True
# True     ← all elements are truthy
# False    ← [] is falsy, so all() returns False
# False    ← no elements to be truthy
# True     ← vacuous truth! no elements to be falsy

# Guard against vacuous truth if it matters in your logic:
items = []
if items and all(validate(x) for x in items):  # Short-circuits on empty
    print("All valid")
else:
    print("No items or some invalid")
# Output: No items or some invalid

# Practical use in data engineering:
import os
files = ['data.csv', 'config.yaml']
if all(os.path.exists(f) for f in files):
    print("All files ready")

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Error!")
        return -1
    else:
        print("Success!")       # Only runs if NO exception
        return result
    finally:
        print("Cleanup!")       # ALWAYS runs — even after return!

print(divide(10, 2))
print("---")
print(divide(10, 0))

# Output:
# Success!
# Cleanup!
# 5.0
# ---
# Error!
# Cleanup!
# -1

# DANGER: What if finally also has a return?
def tricky():
    try:
        return 1        # Return value is determined as 1
    finally:
        return 2        # But finally OVERRIDES it!

print(tricky())
# Output: 2  ← finally's return REPLACES try's return!

# Rule: NEVER put return in finally — it silently swallows exceptions too
def swallowed():
    try:
        raise ValueError("important error!")
    finally:
        return "oops"   # Exception is silently swallowed!

print(swallowed())
# Output: oops  ← the ValueError is gone!

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Functional style — map + filter
evens_squared_func = list(
    map(lambda x: x**2,                    # Step 2: square each
        filter(lambda x: x % 2 == 0,       # Step 1: keep evens
               numbers))
)

# Pythonic style — list comprehension (reads left to right)
evens_squared_comp = [x**2 for x in numbers if x % 2 == 0]

print(evens_squared_func)
print(evens_squared_comp)
print(evens_squared_func == evens_squared_comp)

# reduce — must be imported in Python 3
from functools import reduce
total = reduce(lambda a, b: a + b, numbers)  # Accumulates: ((((1+2)+3)+4)+...+10)
print(total)
print(total == sum(numbers))

# Output:
# [4, 16, 36, 64, 100]
# [4, 16, 36, 64, 100]
# True
# 55
# True

# When to use map/filter — passing an EXISTING function (no lambda needed)
names = ['alice', 'bob', 'charlie']
upper_names = list(map(str.upper, names))   # Cleaner than [x.upper() for x in names]
print(upper_names)
# Output: ['ALICE', 'BOB', 'CHARLIE']

# When to use comprehension — when you need a lambda anyway
squared = [x**2 for x in range(10)]        # Cleaner than list(map(lambda x: x**2, range(10)))

# Generator expression for memory efficiency with large data
total = sum(x**2 for x in range(1000000))   # No list created in memory

team_a = {"Alice", "Bob", "Charlie", "Diana"}
team_b = {"Bob", "Diana", "Eve", "Frank"}

# Find common members by checking each member of A in B
common = []
for member in team_a:
    if member in team_b:
        common.append(member)
print("Common:", sorted(common))
# Output: Common: ['Bob', 'Diana']

# Find members only in team A
only_a = []
for member in team_a:
    if member not in team_b:
        only_a.append(member)
print("Only in A:", sorted(only_a))
# Output: Only in A: ['Alice', 'Charlie']

# Find symmetric difference (in one but not both)
sym_diff = []
for member in team_a:
    if member not in team_b:
        sym_diff.append(member)
for member in team_b:
    if member not in team_a:
        sym_diff.append(member)
print("Symmetric difference:", sorted(sym_diff))
# Output: Symmetric difference: ['Alice', 'Charlie', 'Eve', 'Frank']

# Combine all members using a helper set
all_members = set()
for member in team_a:
    all_members.add(member)
for member in team_b:
    all_members.add(member)
print("All members:", sorted(all_members))
# Output: All members: ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']

team_a = {"Alice", "Bob", "Charlie", "Diana"}
team_b = {"Bob", "Diana", "Eve", "Frank"}

# Use list comprehensions instead of explicit loops
common = sorted([m for m in team_a if m in team_b])
print("Common:", common)
# Output: Common: ['Bob', 'Diana']

only_a = sorted([m for m in team_a if m not in team_b])
print("Only in A:", only_a)
# Output: Only in A: ['Alice', 'Charlie']

sym_diff = sorted([m for m in team_a if m not in team_b] +
                  [m for m in team_b if m not in team_a])
print("Symmetric difference:", sym_diff)
# Output: Symmetric difference: ['Alice', 'Charlie', 'Eve', 'Frank']

all_members = sorted(set(list(team_a) + list(team_b)))
print("All members:", all_members)
# Output: All members: ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']

team_a = {"Alice", "Bob", "Charlie", "Diana"}
team_b = {"Bob", "Diana", "Eve", "Frank"}

# Step 1: Let's SEE what these sets look like
print("Team A:", sorted(team_a))
# Output: Team A: ['Alice', 'Bob', 'Charlie', 'Diana']
print("Team B:", sorted(team_b))
# Output: Team B: ['Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
# ↑ Sets are unordered — sorted() just makes output readable

# Step 2: & operator = intersection (common members)
common = team_a & team_b
print("Common (A & B):", sorted(common))
# Output: Common (A & B): ['Bob', 'Diana']
# ↑ Only Bob and Diana are in BOTH sets

# Step 3: - operator = difference (only in A, not in B)
only_a = team_a - team_b
print("Only in A (A - B):", sorted(only_a))
# Output: Only in A (A - B): ['Alice', 'Charlie']
# ↑ Alice and Charlie are in A but NOT in B — this is like a LEFT ANTI JOIN

# Step 4: ^ operator = symmetric difference (in one but not both)
sym_diff = team_a ^ team_b
print("In one but not both (A ^ B):", sorted(sym_diff))
# Output: In one but not both (A ^ B): ['Alice', 'Charlie', 'Eve', 'Frank']
# ↑ Excludes Bob and Diana (they're in both) — like a FULL OUTER minus INNER

# Step 5: | operator = union (all combined, deduplicated)
all_members = team_a | team_b
print("All members (A | B):", sorted(all_members))
# Output: All members (A | B): ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
# ↑ 6 unique members — Bob and Diana appear once, not twice

# Bonus: Subset check
small = {"Bob", "Diana"}
print("Is small ⊆ team_a?", small <= team_a)
# Output: Is small ⊆ team_a? True
# ↑ <= checks if every element in small exists in team_a

words = ["hello", "world", "hello", "foo", "world", "hello"]

# Count words using a plain dict with key existence check
word_count = {}
for word in words:
    if word not in word_count:
        word_count[word] = 0   # initialize key if missing
    word_count[word] += 1

print("Word counts:", dict(sorted(word_count.items())))
# Output: Word counts: {'foo': 1, 'hello': 3, 'world': 2}

# Group transactions using plain dict
transactions = [("food", 50), ("transport", 30), ("food", 25),
                ("entertainment", 100), ("transport", 45)]

by_category = {}
for category, amount in transactions:
    if category not in by_category:
        by_category[category] = []   # initialize empty list
    by_category[category].append(amount)

print("Grouped:", dict(sorted(by_category.items())))
# Output: Grouped: {'entertainment': [100], 'food': [50, 25], 'transport': [30, 45]}

from collections import defaultdict

words = ["hello", "world", "hello", "foo", "world", "hello"]

# defaultdict(int) auto-creates missing keys with value 0
word_count = defaultdict(int)
for word in words:
    word_count[word] += 1   # no need to check if key exists

print("Word counts:", dict(sorted(word_count.items())))
# Output: Word counts: {'foo': 1, 'hello': 3, 'world': 2}

# defaultdict(list) auto-creates missing keys with empty list
transactions = [("food", 50), ("transport", 30), ("food", 25),
                ("entertainment", 100), ("transport", 45)]

by_category = defaultdict(list)
for category, amount in transactions:
    by_category[category].append(amount)   # no init needed

print("Grouped:", dict(sorted(by_category.items())))
# Output: Grouped: {'entertainment': [100], 'food': [50, 25], 'transport': [30, 45]}

from collections import Counter

words = ["hello", "world", "hello", "foo", "world", "hello"]

# Step 1: Counter scans the list once and builds {element: count}
word_count = Counter(words)
print("Step 1 - Raw Counter:", word_count)
# Output: Step 1 - Raw Counter: Counter({'hello': 3, 'world': 2, 'foo': 1})
# ↑ Counter is a dict subclass — keys are elements, values are their counts

# Step 2: Sort by key for consistent display
print("Step 2 - Sorted:", dict(sorted(word_count.items())))
# Output: Step 2 - Sorted: {'foo': 1, 'hello': 3, 'world': 2}
# ↑ dict(sorted(...)) gives us alphabetical order for readability

# Step 3: most_common(n) returns top n as list of (element, count) tuples
top_2 = word_count.most_common(2)
print("Step 3 - Top 2:", top_2)
# Output: Step 3 - Top 2: [('hello', 3), ('world', 2)]
# ↑ Already sorted by count descending — no need to sort manually!

# Step 4: Counter arithmetic — useful for comparing frequency distributions
c1 = Counter("aabbc")
c2 = Counter("abbcc")
print("Step 4a - c1:", c1)
# Output: Step 4a - c1: Counter({'a': 2, 'b': 2, 'c': 1})
print("Step 4b - c2:", c2)
# Output: Step 4b - c2: Counter({'b': 2, 'c': 2, 'a': 1})

print("c1 + c2:", c1 + c2)   # add counts element-wise
# Output: c1 + c2: Counter({'b': 4, 'a': 3, 'c': 3})
# ↑ 'b' had 2+2=4, 'a' had 2+1=3, 'c' had 1+2=3

print("c1 - c2:", c1 - c2)   # subtract, drops zero/negative
# Output: c1 - c2: Counter({'a': 1})
# ↑ Only 'a' has more in c1 (2) than c2 (1) → keeps 2-1=1

print("c1 & c2:", c1 & c2)   # min of each count (intersection)
# Output: c1 & c2: Counter({'b': 2, 'a': 1, 'c': 1})
# ↑ min(2,1)=1 for 'a', min(2,2)=2 for 'b', min(1,2)=1 for 'c'

students = [("Alice", 85), ("Bob", 85), ("Charlie", 92), ("Diana", 78)]

# Copy the list so we do not mutate original
result = students[:]

# Bubble sort: compare grade desc, then name asc
for i in range(len(result)):
    for j in range(i + 1, len(result)):
        name_i, grade_i = result[i]
        name_j, grade_j = result[j]
        # Swap if j should come before i
        should_swap = False
        if grade_j > grade_i:               # higher grade first
            should_swap = True
        elif grade_j == grade_i and name_j < name_i:  # same grade, alpha by name
            should_swap = True
        if should_swap:
            result[i], result[j] = result[j], result[i]

print(result)
# Output: [('Charlie', 92), ('Alice', 85), ('Bob', 85), ('Diana', 78)]

students = [("Alice", 85), ("Bob", 85), ("Charlie", 92), ("Diana", 78)]

# Sort by grade descending using reverse=True
by_grade_desc = sorted(students, key=lambda x: x[1], reverse=True)
print(by_grade_desc)
# Output: [('Charlie', 92), ('Alice', 85), ('Bob', 85), ('Diana', 78)]
# Note: Alice and Bob both have 85, but order may not be alphabetical

students = [("Alice", 85), ("Bob", 85), ("Charlie", 92), ("Diana", 78)]

# Step 1: Let's see what the lambda key produces for each student
for s in students:
    print(f"  {s[0]:>8} → key = ({-s[1]}, '{s[0]}') = {(-s[1], s[0])}")
# Output:     Alice → key = (-85, 'Alice') = (-85, 'Alice')
# Output:       Bob → key = (-85, 'Bob') = (-85, 'Bob')
# Output:   Charlie → key = (-92, 'Charlie') = (-92, 'Charlie')
# Output:     Diana → key = (-78, 'Diana') = (-78, 'Diana')
# ↑ Negating the grade means -92 < -85 < -78, so highest grade sorts FIRST

# Step 2: Python compares tuples left to right
# -92 comes first (smallest). For tied grades (-85), 'Alice' < 'Bob' alphabetically
result = sorted(students, key=lambda x: (-x[1], x[0]))
print("Step 2 - Sorted:", result)
# Output: Step 2 - Sorted: [('Charlie', 92), ('Alice', 85), ('Bob', 85), ('Diana', 78)]
# ↑ Charlie (92) first, then Alice before Bob (both 85, but A < B alphabetically)

# Bonus: Sort a dict by values
scores = {'alice': 85, 'bob': 92, 'charlie': 78}
print("Step 3 - Dict keys:", list(scores.keys()))
# Output: Step 3 - Dict keys: ['alice', 'bob', 'charlie']
# ↑ sorted(scores) iterates over KEYS, but sorts them by scores.get (the values)

sorted_names = sorted(scores, key=scores.get, reverse=True)
print("Step 4 - Sorted by value desc:", sorted_names)
# Output: Step 4 - Sorted by value desc: ['bob', 'alice', 'charlie']
# ↑ bob(92) > alice(85) > charlie(78) — keys sorted by their values!

def is_balanced(s):
    # Keep removing innermost pairs until nothing is left
    while "()" in s or "[]" in s or "{}" in s:
        s = s.replace("()", "")
        s = s.replace("[]", "")
        s = s.replace("{}", "")
    # If empty, all brackets were matched
    return len(s) == 0

print(is_balanced("({[]})"))   # Output: True
print(is_balanced("({[})"))    # Output: False
print(is_balanced("((()))"))   # Output: True

def is_balanced(s):
    stack = []
    # Map each closing bracket to its opening counterpart
    pairs = {')': '(', ']': '[', '}': '{'}

    for char in s:
        if char in '([{':
            stack.append(char)         # push opening bracket
        elif char in ')]}':
            if not stack:              # nothing to match against
                return False
            if stack[-1] != pairs[char]:  # top of stack must match
                return False
            stack.pop()                # matched — remove from stack

    return len(stack) == 0             # stack must be empty at end

print(is_balanced("({[]})"))   # Output: True
print(is_balanced("({[})"))    # Output: False
print(is_balanced("((()))"))   # Output: True

from collections import deque

def is_balanced(s):
    # deque gives O(1) append and pop from both ends
    stack = deque()
    pairs = {')': '(', ']': '[', '}': '{'}
    openers = set('([{')

    for char in s:
        if char in openers:
            stack.append(char)
        elif char in pairs:
            # If stack empty or top does not match, it is unbalanced
            if not stack or stack[-1] != pairs[char]:
                return False
            stack.pop()

    return len(stack) == 0

print(is_balanced("({[]})"))   # Output: True
print(is_balanced("({[})"))    # Output: False
print(is_balanced("((()))"))   # Output: True

# Bonus: Stack vs Queue demonstration
# Stack = LIFO (Last In, First Out) — use append/pop
stack = []
stack.append(1); stack.append(2); stack.append(3)
print(stack.pop())   # Output: 3

# Queue = FIFO (First In, First Out) — use deque with append/popleft
queue = deque()
queue.append(1); queue.append(2); queue.append(3)
print(queue.popleft())  # Output: 1

numbers = [-3, -1, 0, 2, 4, 7]

result = []
for x in numbers:
    if x > 0:             # filter: keep only positive numbers
        result.append(x ** 2)  # transform: square each one

print(result)
# Output: [4, 16, 49]

numbers = [-3, -1, 0, 2, 4, 7]

# filter() keeps elements where the lambda returns True
# map() applies the lambda to each remaining element
result = list(map(lambda x: x ** 2,
                  filter(lambda x: x > 0, numbers)))

print(result)
# Output: [4, 16, 49]

# Other useful lambda patterns:
names = ["alice", "BOB", "Charlie"]
normalized = list(map(str.title, names))
print(normalized)
# Output: ['Alice', 'Bob', 'Charlie']

# Sort dicts with lambda
data = [{"name": "Alice", "age": 30},
        {"name": "Bob", "age": 25}]
sorted_data = sorted(data, key=lambda d: d["age"])
print(sorted_data)
# Output: [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}]

numbers = [-3, -1, 0, 2, 4, 7]

# Combines filter and transform in one readable expression
result = [x ** 2 for x in numbers if x > 0]

print(result)
# Output: [4, 16, 49]

# More one-liner patterns:
# Conditional expression in comprehension
classified = ["even" if x % 2 == 0 else "odd" for x in range(5)]
print(classified)
# Output: ['even', 'odd', 'even', 'odd', 'even']

# Filter even numbers
evens = [x for x in range(20) if x % 2 == 0]
print(evens)
# Output: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Use a dict — flexible but no field validation
emp = {
    "name": "Alice",
    "department": "Data Engineering",
    "salary": 95000
}

print(f"Name: {emp['name']}, Dept: {emp['department']}, Salary: {emp['salary']}")
# Output: Name: Alice, Dept: Data Engineering, Salary: 95000

# Mutable — just update the key
emp["salary"] = 100000
print(f"Updated salary: {emp['salary']}")
# Output: Updated salary: 100000

# Downside: no field validation, typos are silent
emp["salry"] = 99999  # typo creates a NEW key, no error

from collections import namedtuple

# Define the structure — fields are fixed at creation
Employee = namedtuple('Employee', ['name', 'department', 'salary'])

emp = Employee("Alice", "Data Engineering", 95000)
print(f"Immutable: {emp}")
# Output: Immutable: Employee(name='Alice', department='Data Engineering', salary=95000)

# Access by name or index
print(emp.name)    # Output: Alice
print(emp[0])      # Output: Alice

# Immutable — cannot change after creation
# emp.salary = 100000  # Raises: AttributeError: can't set attribute

# To "update", use _replace() which returns a NEW namedtuple
updated = emp._replace(salary=100000)
print(f"Mutable after update: {updated}")
# Output: Mutable after update: Employee(name='Alice', department='Data Engineering', salary=100000)

from dataclasses import dataclass, asdict, astuple

@dataclass
class Employee:
    name: str
    department: str
    salary: float = 50000.0   # default value

# Step 1: Create instance — @dataclass auto-generates __init__ from type hints
emp = Employee("Alice", "Data Engineering", 95000)
print("Step 1 - Created:", emp)
# Output: Step 1 - Created: Employee(name='Alice', department='Data Engineering', salary=95000)
# ↑ __repr__ is auto-generated too — no need to write it yourself!

# Step 2: Mutable by default — direct field assignment works
emp.salary = 100000
print("Step 2 - After mutation:", emp)
# Output: Step 2 - After mutation: Employee(name='Alice', department='Data Engineering', salary=100000)
# ↑ Unlike namedtuple, you CAN modify fields in-place

# Step 3: Convert to dict/tuple — useful for serialization and DB inserts
print("Step 3a - As dict:", asdict(emp))
# Output: Step 3a - As dict: {'name': 'Alice', 'department': 'Data Engineering', 'salary': 100000}
print("Step 3b - As tuple:", astuple(emp))
# Output: Step 3b - As tuple: ('Alice', 'Data Engineering', 100000)
# ↑ asdict() is perfect for JSON serialization or DataFrame row creation

# Step 4: Auto-generated __eq__ compares all fields
emp2 = Employee("Alice", "Data Engineering", 100000)
print("Step 4 - emp == emp2:", emp == emp2)
# Output: Step 4 - emp == emp2: True
# ↑ Compares by value, not identity — no need to write __eq__ yourself

# Step 5: For immutable dataclass, use frozen=True
@dataclass(frozen=True)
class ImmutableEmployee:
    name: str
    department: str
    salary: float

frozen_emp = ImmutableEmployee("Bob", "Analytics", 80000)
# frozen_emp.salary = 90000  # Raises: FrozenInstanceError
print("Step 5 - Frozen:", frozen_emp)
# Output: Step 5 - Frozen: ImmutableEmployee(name='Bob', department='Analytics', salary=80000)
# ↑ frozen=True also makes it hashable — can use as dict key or set member

import time

def slow_function():
    time.sleep(1)
    return "done"

# Manually measure time around the function call
start = time.time()
result = slow_function()
elapsed = time.time() - start
print(f"slow_function took {elapsed:.3f}s")
# Output: slow_function took 1.001s

# Fibonacci without cache — exponential time
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.time()
print(f"fibonacci(10) = {fibonacci(10)}")
elapsed = time.time() - start
print(f"Took {elapsed:.6f}s")
# Output: fibonacci(10) = 55
# Output: Took 0.000XXXs (small n is fast, but try n=35 and it crawls)

import time
from functools import wraps

# A decorator is a function that takes a function and returns a wrapper
def timer(func):
    @wraps(func)  # preserves original function's name and docstring
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)   # call the original function
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.3f}s")
        return result
    return wrapper

# Apply decorator with @ syntax — equivalent to: slow_function = timer(slow_function)
@timer
def slow_function():
    time.sleep(1)
    return "done"

slow_function()
# Output: slow_function took 1.001s

# The function's identity is preserved thanks to @wraps
print(slow_function.__name__)
# Output: slow_function  (without @wraps, it would say "wrapper")

from functools import lru_cache

# @lru_cache memoizes results — stores return values for given arguments
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# Step 1: Call fibonacci(10) — internally computes fib(0) through fib(10)
print(f"Step 1 - fibonacci(10) = {fibonacci(10)}")
# Output: Step 1 - fibonacci(10) = 55

# Step 2: Inspect the cache — see what's stored
print(f"Step 2 - Cache info: {fibonacci.cache_info()}")
# Output: Step 2 - Cache info: CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)
# ↑ 11 unique calls (fib(0)..fib(10)), 8 cache hits (fib reuses previous results)
# Without cache: fib(10) would make 177 recursive calls. With cache: only 11!

# Step 3: Now call fibonacci(100) — fib(0)..fib(10) are already cached!
print(f"Step 3 - fibonacci(100) = {fibonacci(100)}")
# Output: Step 3 - fibonacci(100) = 354224848179261915075

print(f"Step 4 - Cache after fib(100): {fibonacci.cache_info()}")
# Output: Step 4 - Cache after fib(100): CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)
# ↑ Only 90 new computations (fib(11)..fib(100)) — the first 11 were cache hits!

# Step 5: You can clear the cache if needed
fibonacci.cache_clear()
print(f"Step 5 - After clear: {fibonacci.cache_info()}")
# Output: Step 5 - After clear: CacheInfo(hits=0, misses=0, maxsize=128, currsize=0)

# Common built-in decorators to know:
# @staticmethod — no self/cls, just a function inside a class
# @classmethod  — gets cls instead of self, used for factory methods
# @property     — makes a method look like an attribute (getter)
# @lru_cache    — memoization (caches return values by arguments)

import time

# Without a context manager, you must handle cleanup manually
start = time.time()
try:
    time.sleep(1)   # simulate work
finally:
    elapsed = time.time() - start
    print(f"Elapsed: {elapsed:.3f}s")
# Output: Elapsed: 1.001s

# Same pattern for file handling
f = open("example.txt", "w")
try:
    f.write("hello")
finally:
    f.close()   # must close manually, even if exception occurs

import time

class Timer:
    def __enter__(self):
        # Setup: record the start time
        self.start = time.time()
        return self   # the object bound to "as" variable

    def __exit__(self, exc_type, exc_val, exc_tb):
        # Cleanup: calculate and print elapsed time
        self.elapsed = time.time() - self.start
        print(f"Elapsed: {self.elapsed:.3f}s")
        return False   # False = do not suppress exceptions

with Timer() as t:
    time.sleep(1)
# Output: Elapsed: 1.001s

# File handling — the classic context manager use case
with open("example.txt", "w") as f:
    f.write("hello")
# File is automatically closed, even if exception occurs

import time
from contextlib import contextmanager

@contextmanager
def timer(label="Block"):
    # Everything before yield is __enter__
    start = time.time()
    yield   # control passes to the with-block here
    # Everything after yield is __exit__
    elapsed = time.time() - start
    print(f"{label} elapsed: {elapsed:.3f}s")

with timer("My task"):
    time.sleep(1)
# Output: My task elapsed: 1.001s

# Real-world example: database connection manager
@contextmanager
def database_connection(db_url):
    conn = connect(db_url)   # setup: open connection
    try:
        yield conn           # give connection to the with-block
    finally:
        conn.close()         # cleanup: always close, even on error

# Usage:
# with database_connection("postgres://...") as conn:
#     conn.execute("SELECT * FROM users")
# Connection is automatically closed

# Merge multiple lists manually
list_a, list_b, list_c = [1, 2], [3, 4], [5, 6]
merged = []
for lst in [list_a, list_b, list_c]:
    for item in lst:
        merged.append(item)
print("Chained:", merged)
# Output: Chained: [1, 2, 3, 4, 5, 6]

# Group by key manually (data must be sorted by key)
data = [("NY", 100), ("NY", 200), ("CA", 300), ("CA", 400)]
groups = {}
for state, value in data:
    if state not in groups:
        groups[state] = []
    groups[state].append((state, value))
for state in sorted(groups):
    print(f"  {state} -> {groups[state]}")
# Output:
#   CA -> [('CA', 300), ('CA', 400)]
#   NY -> [('NY', 100), ('NY', 200)]

# Cartesian product manually
sizes = ['S', 'M', 'L']
colors = ['red', 'blue']
combos = []
for s in sizes:
    for c in colors:
        combos.append((s, c))
print("Product:", combos)
# Output: Product: [('S', 'red'), ('S', 'blue'), ('M', 'red'), ('M', 'blue'), ('L', 'red'), ('L', 'blue')]

# Merge with unpacking
list_a, list_b, list_c = [1, 2], [3, 4], [5, 6]
merged = [*list_a, *list_b, *list_c]
print("Chained:", merged)
# Output: Chained: [1, 2, 3, 4, 5, 6]

# Cartesian product with nested comprehension
sizes = ['S', 'M', 'L']
colors = ['red', 'blue']
combos = [(s, c) for s in sizes for c in colors]
print("Product:", combos)
# Output: Product: [('S', 'red'), ('S', 'blue'), ('M', 'red'), ('M', 'blue'), ('L', 'red'), ('L', 'blue')]

# Combinations with comprehension
items = [1, 2, 3]
pairs = [(items[i], items[j]) for i in range(len(items)) for j in range(i + 1, len(items))]
print("Combos:", pairs)
# Output: Combos: [(1, 2), (1, 3), (2, 3)]

from itertools import chain, groupby, islice, product, combinations

# chain — merge multiple iterables lazily
merged = list(chain([1, 2], [3, 4], [5, 6]))
print("Chained:", merged)
# Output: Chained: [1, 2, 3, 4, 5, 6]

# groupby — group CONSECUTIVE items by a key (data must be sorted!)
data = [("CA", 300), ("CA", 400), ("NY", 100), ("NY", 200)]  # sorted by state
for state, group in groupby(data, key=lambda x: x[0]):
    print(f"  {state} -> {list(group)}")
# Output:
#   CA -> [('CA', 300), ('CA', 400)]
#   NY -> [('NY', 100), ('NY', 200)]

# product — cartesian product (replaces nested loops)
combos = list(product(['S', 'M', 'L'], ['red', 'blue']))
print("Product:", combos)
# Output: Product: [('S', 'red'), ('S', 'blue'), ('M', 'red'), ('M', 'blue'), ('L', 'red'), ('L', 'blue')]

# combinations — choose k items from n without replacement
print("Combos:", list(combinations([1, 2, 3], 2)))
# Output: Combos: [(1, 2), (1, 3), (2, 3)]

# islice — slice an iterator lazily (no memory for huge files)
# with open("huge_file.csv") as f:
#     first_10 = list(islice(f, 10))  # reads only first 10 lines

def convert(value):
    try:
        return int(value)
    except ValueError:
        # Raised when the string cannot be parsed as int
        return f"Error: '{value}' is not a valid number"
    except TypeError:
        # Raised when value is None or non-string type
        return f"Error: Input cannot be None"

print(convert("42"))
# Output: 42
print(convert("abc"))
# Output: Error: 'abc' is not a valid number
print(convert(None))
# Output: Error: Input cannot be None

class DataValidationError(Exception):
    """Custom exception for data validation failures."""
    def __init__(self, column, value, message):
        self.column = column
        self.value = value
        # Call parent __init__ with a formatted message
        super().__init__(f"Column '{column}': {message} (got: {value})")

def validate_age(data):
    age = data.get("age")
    if age is None:
        raise DataValidationError("age", age, "must not be None")
    if not isinstance(age, int):
        raise DataValidationError("age", age, "must be an integer")
    if age < 0:
        raise DataValidationError("age", age, "must be positive")
    return age

# Test with valid data
try:
    result = validate_age({"age": 25})
    print(f"Valid age: {result}")
except DataValidationError as e:
    print(f"Validation failed: {e}")
# Output: Valid age: 25

# Test with invalid data
try:
    result = validate_age({"age": -5})
    print(f"Valid age: {result}")
except DataValidationError as e:
    print(f"Validation failed: {e}")
# Output: Validation failed: Column 'age': must be positive (got: -5)

class DataValidationError(Exception):
    def __init__(self, column, value, message):
        self.column = column
        self.value = value
        super().__init__(f"Column '{column}': {message} (got: {value})")

def safe_convert(value):
    try:
        return int(value)
    except (ValueError, TypeError) as e:
        # Chain exceptions with "from e" to preserve the original traceback
        raise DataValidationError("input", value, "must be a valid integer") from e

# Test
try:
    result = safe_convert("abc")
except DataValidationError as e:
    print(f"Error: {e}")
    print(f"  Column: {e.column}")
    print(f"  Value: {e.value}")
# Output: Error: Column 'input': must be a valid integer (got: abc)
# Output:   Column: input
# Output:   Value: abc

# Anti-patterns to AVOID:

# BAD — bare except catches EVERYTHING including KeyboardInterrupt
# try:
#     result = process(data)
# except:
#     pass

# BAD — too broad, hides real bugs
# try:
#     result = process(data)
# except Exception:
#     print("something went wrong")

# GOOD — always catch SPECIFIC exceptions
try:
    result = int("abc")
except ValueError:
    print("Caught specific ValueError")
# Output: Caught specific ValueError

name = "Alice"
age = 30
salary = 95432.567

# Basic substitution with %s (string) and %d (integer)
print("%s is %d years old" % (name, age))
# Output: Alice is 30 years old

# Float formatting with %.2f (2 decimal places)
print("Salary: $%.2f" % salary)
# Output: Salary: $95432.57
# Note: %-formatting does NOT support comma separators easily

name = "Alice"
age = 30
salary = 95432.567

# Positional arguments
print("{} is {} years old".format(name, age))
# Output: Alice is 30 years old

# Named arguments
print("{name} is {age} years old".format(name=name, age=age))
# Output: Alice is 30 years old

# Format spec: comma separator and 2 decimal places
print("Salary: ${:,.2f}".format(salary))
# Output: Salary: $95,432.57

# Alignment: < left, ^ center, > right (within 20 chars)
print("{:<20}|{:^20}|{:>20}".format("left", "center", "right"))
# Output: left                |       center       |               right

name = "Alice"
age = 30
salary = 95432.567

# Basic f-string — variables directly in curly braces
print(f"{name} is {age} years old")
# Output: Alice is 30 years old

# Format spec after colon: comma separator, 2 decimals
print(f"Salary: ${salary:,.2f}")
# Output: Salary: $95,432.57

# Alignment: < left, ^ center, > right
print(f"{'left':<20}|{'center':^20}|{'right':>20}")
# Output: left                |       center       |               right

# Zero-padded numbers
print(f"{age:05d}")
# Output: 00030

# Debug syntax (Python 3.8+) — shows variable name AND value
x = 42
print(f"{x = }")
# Output: x = 42
print(f"{x**2 = }")
# Output: x**2 = 1764

# Flatten nested list
nested = [[1, 2], [3, 4], [5, 6]]
flat = []
for sublist in nested:
    for item in sublist:
        flat.append(item)
print("Flat:", flat)
# Output: Flat: [1, 2, 3, 4, 5, 6]

# Transpose matrix
matrix = [[1, 2, 3], [4, 5, 6]]
transposed = []
for col in range(len(matrix[0])):
    row = []
    for r in range(len(matrix)):
        row.append(matrix[r][col])
    transposed.append(tuple(row))
print("Transposed:", transposed)
# Output: Transposed: [(1, 4), (2, 5), (3, 6)]

# Unique items preserving order
items = [3, 1, 2, 1, 3, 4]
seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)
print("Unique:", unique)
# Output: Unique: [3, 1, 2, 4]

# Merge two dicts
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = {}
for k, v in dict1.items():
    merged[k] = v
for k, v in dict2.items():
    merged[k] = v      # dict2 values overwrite dict1
print("Merged:", merged)
# Output: Merged: {'a': 1, 'b': 3, 'c': 4}

# Dict from two lists
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = {}
for i in range(len(keys)):
    d[keys[i]] = values[i]
print("Zipped:", d)
# Output: Zipped: {'a': 1, 'b': 2, 'c': 3}

from itertools import chain
from collections import Counter

# Flatten with itertools.chain
nested = [[1, 2], [3, 4], [5, 6]]
flat = list(chain.from_iterable(nested))
print("Flat:", flat)
# Output: Flat: [1, 2, 3, 4, 5, 6]

# Transpose with zip and unpacking
matrix = [[1, 2, 3], [4, 5, 6]]
transposed = list(zip(*matrix))
print("Transposed:", transposed)
# Output: Transposed: [(1, 4), (2, 5), (3, 6)]

# Unique preserving order with dict.fromkeys
items = [3, 1, 2, 1, 3, 4]
unique = list(dict.fromkeys(items))
print("Unique:", unique)
# Output: Unique: [3, 1, 2, 4]

# Merge dicts with unpacking (Python 3.5+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = {**dict1, **dict2}
print("Merged:", merged)
# Output: Merged: {'a': 1, 'b': 3, 'c': 4}

# Dict from two lists with zip
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
print("Zipped:", d)
# Output: Zipped: {'a': 1, 'b': 2, 'c': 3}

from collections import Counter

# Flatten — list comprehension (no import needed)
nested = [[1, 2], [3, 4], [5, 6]]
flat = [x for sub in nested for x in sub]
print("Flat:", flat)
# Output: Flat: [1, 2, 3, 4, 5, 6]

# Transpose — zip unpacking (cleanest)
matrix = [[1, 2, 3], [4, 5, 6]]
transposed = list(zip(*matrix))
print("Transposed:", transposed)
# Output: Transposed: [(1, 4), (2, 5), (3, 6)]

# Unique preserving order — dict.fromkeys (3.7+ guarantees order)
items = [3, 1, 2, 1, 3, 4]
unique = list(dict.fromkeys(items))
print("Unique:", unique)
# Output: Unique: [3, 1, 2, 4]

# Merge dicts — pipe operator (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = dict1 | dict2
print("Merged:", merged)
# Output: Merged: {'a': 1, 'b': 3, 'c': 4}

# Dict from two lists
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
print("Zipped:", d)
# Output: Zipped: {'a': 1, 'b': 2, 'c': 3}

# Bonus one-liners:
# Swap two variables
a, b = 1, 2
a, b = b, a
print(a, b)
# Output: 2 1

# Most common element
items = ["a", "b", "a", "c", "a", "b"]
most_common = Counter(items).most_common(1)[0][0]
print("Most common:", most_common)
# Output: Most common: a

# Check all items satisfy a condition
numbers = [1, 2, 3, 4, 5]
all_positive = all(x > 0 for x in numbers)
print("All positive:", all_positive)
# Output: All positive: True

# Conditional assignment
x = 42 if True else 0
print(x)
# Output: 42

# Example 1: Mutability difference
my_list = [1, 2, 3]
my_list[0] = 99        # Works fine — lists are mutable
print(my_list)
# Output: [99, 2, 3]

my_tuple = (1, 2, 3)
# my_tuple[0] = 99     # Raises: TypeError: 'tuple' object does not support item assignment
print(my_tuple)
# Output: (1, 2, 3)

# Example 2: Tuples as dictionary keys (lists cannot do this)
# Tuples are hashable because they are immutable
coords = {(10, 20): "New York", (40, 50): "London"}
print(coords[(10, 20)])
# Output: New York

# Lists are NOT hashable — this would fail:
# bad_dict = {[10, 20]: "New York"}
# Raises: TypeError: unhashable type: 'list'

# Example 3: Memory and performance comparison
import sys

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(f"List size:  {sys.getsizeof(my_list)} bytes")
# Output: List size:  120 bytes
print(f"Tuple size: {sys.getsizeof(my_tuple)} bytes")
# Output: Tuple size: 80 bytes
# Tuples use less memory because they don't need resize overhead

# Example 1: List comprehension — entire list stored in memory
squares_list = [x ** 2 for x in range(6)]
print(squares_list)
# Output: [0, 1, 4, 9, 16, 25]
print(type(squares_list))
# Output: <class 'list'>

# Example 2: Generator expression — lazy, one value at a time
squares_gen = (x ** 2 for x in range(6))
print(type(squares_gen))
# Output: <class 'generator'>

# Must iterate or convert to see values
print(next(squares_gen))
# Output: 0
print(next(squares_gen))
# Output: 1
print(list(squares_gen))   # Remaining values
# Output: [4, 9, 16, 25]

# Example 3: Memory comparison — generators win for large data
import sys

list_comp = [x for x in range(10000)]
gen_expr = (x for x in range(10000))

print(f"List memory:      {sys.getsizeof(list_comp)} bytes")
# Output: List memory:      87624 bytes
print(f"Generator memory: {sys.getsizeof(gen_expr)} bytes")
# Output: Generator memory: 200 bytes
# Generator uses constant memory regardless of data size

# Example 1: Lambda vs regular function — equivalent code
# Lambda version
square = lambda x: x ** 2
print(square(5))
# Output: 25

# Equivalent regular function
def square_func(x):
    return x ** 2

print(square_func(5))
# Output: 25

# Example 2: Lambda with sorted() — most common real-world use
# Sort list of dicts by a specific key
employees = [
    {"name": "Charlie", "salary": 75000},
    {"name": "Alice", "salary": 90000},
    {"name": "Bob", "salary": 60000},
]

# Sort by salary ascending
by_salary = sorted(employees, key=lambda emp: emp["salary"])
for emp in by_salary:
    print(f"{emp['name']}: {emp['salary']}")
# Output: Bob: 60000
# Output: Charlie: 75000
# Output: Alice: 90000

# Sort by name descending
by_name_desc = sorted(employees, key=lambda emp: emp["name"], reverse=True)
for emp in by_name_desc:
    print(emp["name"])
# Output: Charlie
# Output: Bob
# Output: Alice

# Example 3: Lambda with map() and filter()
numbers = [1, 2, 3, 4, 5, 6, 7, 8]

# filter: keep only even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
# Output: [2, 4, 6, 8]

# map: double each number
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)
# Output: [2, 4, 6, 8, 10, 12, 14, 16]

# Note: List comprehensions are usually more Pythonic
evens_lc = [x for x in numbers if x % 2 == 0]
doubled_lc = [x * 2 for x in numbers]
print(evens_lc)
# Output: [2, 4, 6, 8]
print(doubled_lc)
# Output: [2, 4, 6, 8, 10, 12, 14, 16]

# Example 1: append() adds ONE item — even if that item is a list
a = [1, 2]
a.append([3, 4])       # Adds the entire list as a single element
print(a)
# Output: [1, 2, [3, 4]]
print(len(a))
# Output: 3             (the inner list counts as one element)

# Example 2: extend() unpacks the iterable and adds each element
b = [1, 2]
b.extend([3, 4])       # Adds 3 and 4 individually
print(b)
# Output: [1, 2, 3, 4]
print(len(b))
# Output: 4

# extend works with any iterable, not just lists
c = [1, 2]
c.extend("abc")        # Strings are iterable — adds each character
print(c)
# Output: [1, 2, 'a', 'b', 'c']

# Example 3: += is equivalent to extend() (not append!)
d = [1, 2]
d += [3, 4]             # Same as d.extend([3, 4])
print(d)
# Output: [1, 2, 3, 4]

# Comparison side by side
append_result = [1, 2]
extend_result = [1, 2]
pluseq_result = [1, 2]

append_result.append([3, 4])
extend_result.extend([3, 4])
pluseq_result += [3, 4]

print(f"append: {append_result}")
# Output: append: [1, 2, [3, 4]]
print(f"extend: {extend_result}")
# Output: extend: [1, 2, 3, 4]
print(f"+=:     {pluseq_result}")
# Output: +=:     [1, 2, 3, 4]

# Example 1: Simple generator with yield
def count_up_to(n):
    """Generator that yields numbers from 1 to n"""
    i = 1
    while i <= n:
        yield i          # Pause here, return value, resume on next call
        i += 1

gen = count_up_to(5)
print(next(gen))
# Output: 1
print(next(gen))
# Output: 2
print(list(gen))        # Remaining values
# Output: [3, 4, 5]

# Example 2: Generator for processing data in chunks
def chunked_range(start, end, chunk_size):
    """Yield data in chunks — simulates batch processing"""
    for i in range(start, end, chunk_size):
        chunk = list(range(i, min(i + chunk_size, end)))
        yield chunk       # Only one chunk in memory at a time

for batch in chunked_range(0, 10, 3):
    print(f"Processing batch: {batch}")
# Output: Processing batch: [0, 1, 2]
# Output: Processing batch: [3, 4, 5]
# Output: Processing batch: [6, 7, 8]
# Output: Processing batch: [9]

# Example 3: Generator pipeline — chaining generators for ETL
def generate_rows():
    """Extract: produce raw rows"""
    data = [
        {"name": "Alice", "score": 85},
        {"name": "Bob", "score": 45},
        {"name": "Charlie", "score": 92},
    ]
    for row in data:
        yield row

def filter_passing(rows, threshold=60):
    """Transform: keep only passing scores"""
    for row in rows:
        if row["score"] >= threshold:
            yield row

def format_output(rows):
    """Transform: format for display"""
    for row in rows:
        yield f"{row['name']}: {row['score']}"

# Chain generators — no intermediate lists created
pipeline = format_output(filter_passing(generate_rows()))
for record in pipeline:
    print(record)
# Output: Alice: 85
# Output: Charlie: 92

# Example 1: Basic dict comprehension — creating a mapping
# Square mapping
squares = {x: x ** 2 for x in range(6)}
print(squares)
# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Equivalent loop (more verbose)
squares_loop = {}
for x in range(6):
    squares_loop[x] = x ** 2
print(squares_loop)
# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Example 2: Filtering with dict comprehension
scores = {"Alice": 85, "Bob": 55, "Charlie": 92, "Diana": 48}

# Keep only passing scores (>= 60)
passed = {k: v for k, v in sorted(scores.items()) if v >= 60}
print(passed)
# Output: {'Alice': 85, 'Charlie': 92}

# Invert a dictionary (swap keys and values)
inverted = {v: k for k, v in sorted(scores.items())}
print(inverted)
# Output: {48: 'Diana', 55: 'Bob', 85: 'Alice', 92: 'Charlie'}

# Example 3: Real-world use — transforming data structures
# Convert list of tuples to dict
raw_data = [("host", "localhost"), ("port", "5432"), ("db", "analytics")]
config = {k: v for k, v in raw_data}
print(config)
# Output: {'host': 'localhost', 'port': '5432', 'db': 'analytics'}

# Create a lookup table from a list of records
employees = [
    {"id": 101, "name": "Alice"},
    {"id": 102, "name": "Bob"},
    {"id": 103, "name": "Charlie"},
]
lookup = {emp["id"]: emp["name"] for emp in employees}
print(lookup)
# Output: {101: 'Alice', 102: 'Bob', 103: 'Charlie'}
print(lookup[102])
# Output: Bob

# Example 1: Bad vs Good — manual index vs enumerate
names = ["Alice", "Bob", "Charlie"]

# BAD — manual indexing with range(len(...))
for i in range(len(names)):
    print(f"{i}: {names[i]}")
# Output: 0: Alice
# Output: 1: Bob
# Output: 2: Charlie

# GOOD — enumerate is cleaner and more Pythonic
for i, name in enumerate(names):
    print(f"{i}: {name}")
# Output: 0: Alice
# Output: 1: Bob
# Output: 2: Charlie

# Example 2: Custom start index
tasks = ["Extract", "Transform", "Load"]

# Start counting from 1 instead of 0
for step, task in enumerate(tasks, start=1):
    print(f"Step {step}: {task}")
# Output: Step 1: Extract
# Output: Step 2: Transform
# Output: Step 3: Load

# Example 3: Practical use — finding positions of matching elements
scores = [72, 85, 91, 45, 88, 55, 93]
threshold = 80

# Find indices of scores above threshold
high_scorers = [(i, score) for i, score in enumerate(scores) if score > threshold]
print(high_scorers)
# Output: [(1, 85), (2, 91), (4, 88), (6, 93)]

# Convert enumerate to a dict
index_map = dict(enumerate(["zero", "one", "two", "three"]))
print(index_map)
# Output: {0: 'zero', 1: 'one', 2: 'two', 3: 'three'}

# Example 1: Basic zip — pairing two lists
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

paired = list(zip(names, scores))
print(paired)
# Output: [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

# Create a dict from two lists
score_map = dict(zip(names, scores))
print(score_map)
# Output: {'Alice': 85, 'Bob': 92, 'Charlie': 78}

# Example 2: Unzipping with zip(*)
pairs = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]

# Unzip — separate back into individual tuples
names_back, scores_back = zip(*pairs)
print(names_back)
# Output: ('Alice', 'Bob', 'Charlie')
print(scores_back)
# Output: (85, 92, 78)

# Convert back to lists if needed
print(list(names_back))
# Output: ['Alice', 'Bob', 'Charlie']

# Example 3: Unequal lengths and zip_longest
from itertools import zip_longest

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92]                      # Shorter!

# Regular zip — stops at shortest
print(list(zip(names, scores)))
# Output: [('Alice', 85), ('Bob', 92)]
# Charlie is DROPPED silently!

# zip_longest — fills missing values with a default
print(list(zip_longest(names, scores, fillvalue=0)))
# Output: [('Alice', 85), ('Bob', 92), ('Charlie', 0)]

# Practical use: iterate multiple lists in parallel
columns = ["id", "name", "score"]
values = [101, "Alice", 85]

for col, val in zip(columns, values):
    print(f"  {col} = {val}")
# Output:   id = 101
# Output:   name = Alice
# Output:   score = 85

a = [1, 2, 3]
b = [1, 2, 3]
a == b     # True  — values are equal
a is b     # False — different objects in memory!

c = a
c is a     # True  — same object (c is a reference)

if x is None:       # ✅ correct — None is a singleton
    ...
if x == None:       # ❌ works but discouraged (triggers __eq__)
    ...

a = 256
b = 256
a is b     # True (CPython caches -5 to 256)

a = 257
b = 257
a is b     # False! (or True, depending on context — DO NOT RELY ON THIS)

def add_item(item, target=[]):      # ❌ DANGEROUS
    target.append(item)
    return target

print(add_item(1))   # [1]
print(add_item(2))   # [1, 2]       ← WAIT WHAT?
print(add_item(3))   # [1, 2, 3]    ← default is SHARED across calls!

def add_item(item, target=None):
    if target is None:              # ✅ create a fresh list each call
        target = []
    target.append(item)
    return target

import copy

original = [[1, 2], [3, 4]]

shallow = copy.copy(original)    # or original[:] or list(original)
deep    = copy.deepcopy(original)

# Modify inner list
original[0].append(99)

print(original)   # [[1, 2, 99], [3, 4]]
print(shallow)    # [[1, 2, 99], [3, 4]]  ← ALSO changed! (inner list is shared)
print(deep)       # [[1, 2], [3, 4]]      ← independent copy

a = [3, 1, 2]

a.sort()           # MUTATES a in place, returns None
print(a)           # [1, 2, 3]
result = a.sort()  # ❌ result is None!

b = [3, 1, 2]
result = sorted(b) # RETURNS new list, b unchanged
print(b)           # [3, 1, 2]
print(result)      # [1, 2, 3]

squares_list = [x*x for x in range(1000000)]    # list — all values in memory
squares_gen  = (x*x for x in range(1000000))    # generator — lazy, one at a time

import sys
sys.getsizeof(squares_list)   # ~8 MB
sys.getsizeof(squares_gen)    # ~200 bytes ← generator is tiny!