Tuples & Sets

# Creating tuples
point = (3, 4)
rgb = (255, 128, 0)
single = (42,)          # trailing comma required for single-element tuple!
empty = ()
mixed = ("hello", 3.14, True)

# Parentheses are optional (it's the commas that make a tuple)
coords = 10, 20, 30
print(type(coords))  # <class 'tuple'>

# From other iterables
t = tuple([1, 2, 3])     # from list
t2 = tuple("hello")      # ('h', 'e', 'l', 'l', 'o')

colors = ("red", "green", "blue", "yellow")

print(colors[0])      # "red"
print(colors[-1])     # "yellow"
print(colors[1:3])    # ("green", "blue")
print(len(colors))    # 4
print("red" in colors)  # True

t = (1, 2, 3)

# These all raise TypeError:
# t[0] = 99
# t.append(4)
# del t[1]

# But! If a tuple CONTAINS a mutable object, that object can change:
tricky = ([1, 2], [3, 4])
tricky[0].append(99)
print(tricky)  # ([1, 2, 99], [3, 4]) — the list inside changed!

# Packing — assigning multiple values creates a tuple
coordinates = 4, 5, 6

# Unpacking — assign tuple elements to separate variables
x, y, z = coordinates
print(x, y, z)  # 4 5 6

# Swap values (uses tuple packing/unpacking under the hood)
a, b = 1, 2
a, b = b, a
print(a, b)  # 2 1

# Star unpacking
first, *rest = (1, 2, 3, 4, 5)
print(first)  # 1
print(rest)   # [2, 3, 4, 5]  ← note: rest is a list

# Ignore values with _
_, y, _ = (10, 20, 30)
print(y)  # 20

# Functions can return multiple values as a tuple
def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([4, 8, 1, 9])
print(lo, hi)  # 1 9

from collections import namedtuple

# Define a named tuple type
Point = namedtuple("Point", ["x", "y"])
Color = namedtuple("Color", "r g b")

# Create instances
p = Point(3, 4)
c = Color(255, 128, 0)

# Access by name (much clearer than index)
print(p.x, p.y)      # 3 4
print(c.r, c.g, c.b) # 255 128 0

# Still works like a regular tuple
print(p[0])       # 3
x, y = p          # unpacking works
print(len(c))     # 3

# Creating sets
fruits = {"apple", "banana", "cherry"}
numbers = {1, 2, 3, 2, 1}    # duplicates removed
print(numbers)  # {1, 2, 3}

# Empty set — must use set(), NOT {} (that's an empty dict!)
empty = set()

# From other iterables
from_list = set([1, 2, 2, 3, 3, 3])   # {1, 2, 3}
from_string = set("hello")             # {'h', 'e', 'l', 'o'}

# Sets can only contain HASHABLE (immutable) items
valid = {1, "hi", (1, 2), True}
# invalid = {[1, 2]}  ← TypeError: unhashable type: 'list'

s = {1, 2, 3}

# Add a single element
s.add(4)           # {1, 2, 3, 4}
s.add(2)           # no effect — already present

# Remove elements
s.remove(3)        # {1, 2, 4} — raises KeyError if missing
s.discard(99)      # no error if missing
popped = s.pop()   # removes & returns an arbitrary element
s.clear()          # empty set

# Add multiple elements
s = {1, 2}
s.update([3, 4, 5])     # {1, 2, 3, 4, 5}
s.update("abc")          # adds 'a', 'b', 'c'

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

print(a | b)   # {1, 2, 3, 4, 5, 6, 7, 8}  — union
print(a & b)   # {4, 5}                      — intersection
print(a - b)   # {1, 2, 3}                   — difference
print(b - a)   # {6, 7, 8}                   — difference (other way)
print(a ^ b)   # {1, 2, 3, 6, 7, 8}         — symmetric difference

# Subset / superset checks
small = {1, 2}
big = {1, 2, 3, 4, 5}
print(small <= big)    # True  (small is a subset of big)
print(big >= small)    # True  (big is a superset of small)
print(small < big)     # True  (proper subset — not equal)

# Disjoint check — no common elements
print({1, 2}.isdisjoint({3, 4}))  # True

# Remove duplicates from a list (fast but loses order)
items = [1, 3, 2, 3, 1, 4, 2]
unique = list(set(items))
print(unique)  # order not guaranteed

# Preserve order while removing duplicates (Python 3.7+)
unique_ordered = list(dict.fromkeys(items))
print(unique_ordered)  # [1, 3, 2, 4]

# Fast membership testing (O(1) vs O(n) for lists)
valid_codes = {"US", "UK", "CA", "AU", "DE", "FR"}
user_code = "CA"
if user_code in valid_codes:
    print("Valid country")

# Find common friends
alice_friends = {"Bob", "Charlie", "Dave", "Eve"}
bob_friends = {"Alice", "Charlie", "Eve", "Frank"}
mutual = alice_friends & bob_friends
print(mutual)  # {'Charlie', 'Eve'}

# Find skills a candidate is missing
required = {"python", "sql", "git", "docker"}
candidate = {"python", "git", "javascript"}
missing = required - candidate
print(f"Missing: {missing}")  # {'sql', 'docker'}

fs = frozenset([1, 2, 3, 4])

# All read operations work
print(3 in fs)      # True
print(fs | {5, 6}) # frozenset({1, 2, 3, 4, 5, 6})

# Mutation is not allowed
# fs.add(5)  ← AttributeError

# Can be used as a dict key or set element
cache = {frozenset({1, 2}): "result_a"}
nested_sets = {frozenset({1, 2}), frozenset({3, 4})}

💻 Exercises

def stats(numbers):
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

data = [23, 45, 12, 67, 34, 89, 2]
lo, hi, avg = stats(data)
print(f"Min: {lo}, Max: {hi}, Avg: {avg:.2f}")
# Min: 2, Max: 89, Avg: 38.86

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

set_a = set(list_a)
set_b = set(list_b)

common = set_a & set_b
only_a = set_a - set_b
all_unique = set_a | set_b

print(f"In both:      {sorted(common)}")     # [4, 5, 6]
print(f"Only in A:    {sorted(only_a)}")     # [1, 2, 3]
print(f"All unique:   {sorted(all_unique)}") # [1, 2, 3, 4, 5, 6, 7, 8, 9]

text = "the cat sat on the mat the cat"
words = text.split()
unique_words = set(words)

print(f"Total words:  {len(words)}")          # 8
print(f"Unique words: {len(unique_words)}")   # 5
print(f"Sorted:       {sorted(unique_words)}")
# ['cat', 'mat', 'on', 'sat', 'the']