Python Data Structures

Tuples are like lists, but with one crucial difference: they cannot be changed after creation. This immutability makes them perfect for data that should stay constant.

What is a Tuple?

Think of a tuple as a "frozen list." Once you create it, you can't add, remove, or change its elements. This might seem like a limitation, but it's actually a powerful feature. In programming, there are many situations where you want data to be unchangeable - like GPS coordinates, RGB color values, days of the week, or database records that should remain intact.

The word "tuple" comes from mathematics, where it describes a finite ordered sequence. You might have heard of "triple" (3 items) or "quadruple" (4 items) - "tuple" is the generic term for any number of items.

Creating Tuples

Creating a tuple is similar to creating a list, but you use parentheses () instead of square brackets. Interestingly, the parentheses are actually optional in most cases - it's the commas that define a tuple. However, using parentheses makes your code clearer and is recommended practice.

There's one important gotcha: to create a tuple with a single element, you must include a trailing comma. Without it, Python interprets the parentheses as just grouping, not as tuple creation.

# Creating tuples - use parentheses ()
coordinates = (10, 20)
rgb_color = (255, 128, 0)  # Orange color
person = ("Priya", 30, "Engineer")

print(coordinates)  # (10, 20)
print(rgb_color)    # (255, 128, 0)

# Actually, parentheses are optional!
another_tuple = 1, 2, 3
print(another_tuple)  # (1, 2, 3)
print(type(another_tuple))  # 

# Empty tuple
empty = ()
empty2 = tuple()

# IMPORTANT: Single-element tuple needs a comma!
not_a_tuple = (42)    # This is just the integer 42
print(type(not_a_tuple))  # 

actual_tuple = (42,)  # Note the comma!
print(type(actual_tuple))  # 

# Without parentheses, still need comma
also_tuple = 42,
print(type(also_tuple))  # 

Accessing Tuple Elements

Good news! Accessing elements in a tuple works exactly like lists - you use the same indexing and slicing syntax you already learned. The zero-based indexing rules apply, negative indices work from the end, and slicing extracts portions of the tuple.

The only difference is that when you slice a tuple, you get back another tuple (not a list). And since tuples are immutable, any operation that would modify them will raise an error.

# Indexing - same as lists
fruits = ("apple", "banana", "cherry", "date")

print(fruits[0])   # 'apple'
print(fruits[-1])  # 'date'
print(fruits[1:3]) # ('banana', 'cherry') - returns a tuple!

# Length
print(len(fruits))  # 4

# Check membership
print("banana" in fruits)  # True
print("grape" in fruits)   # False

# Count and index
numbers = (1, 2, 2, 3, 2, 4)
print(numbers.count(2))  # 3
print(numbers.index(3))  # 3 (first occurrence at index 3)

Why Use Immutable Tuples?

You might wonder: "Why would I want a list I can't change?" This is a great question, and the answer reveals some important programming concepts. Immutability has several powerful advantages:

# Attempting to modify a tuple raises an error
coordinates = (10, 20)
# coordinates[0] = 15  # TypeError: 'tuple' object does not support item assignment

# Tuples as dictionary keys (lists can't do this!)
locations = {
    (40.7128, -74.0060): "New York City",
    (34.0522, -118.2437): "Los Angeles",
    (51.5074, -0.1278): "London"
}
print(locations[(40.7128, -74.0060)])  # 'New York City'

# This would fail with a list:
# locations[[40.7128, -74.0060]] = "NYC"  # TypeError: unhashable type: 'list'

Tuple Unpacking

One of Python's most elegant features is tuple unpacking - extracting multiple values from a tuple into separate variables in one line.

# Basic unpacking
coordinates = (10, 20, 30)
x, y, z = coordinates
print(x)  # 10
print(y)  # 20
print(z)  # 30

Unpacking works beautifully in loops:

# Unpacking in a loop
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f"x={x}, y={y}")
# x=1, y=2
# x=3, y=4
# x=5, y=6

The classic Python trick for swapping variables:

# Swapping variables (classic Python trick!)
a = 10
b = 20
a, b = b, a  # Swap in one line!
print(a, b)  # 20 10

Use * for extended unpacking:

# Extended unpacking with * (Python 3+)
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4] - note: it's a list!
print(last)    # 5

Use underscore _ to ignore values:

# Ignore values with underscore
data = ("Priya", 30, "Engineer", "India")
name, age, _, country = data  # Ignore profession
print(f"{name}, {age}, from {country}")  # Priya, 30, from India

Named Tuples: Tuples with Field Names

Regular tuples access elements by index, which can be confusing. Named tuples let you access elements by name, making your code more readable.

With regular tuples, you access elements by index - which can be confusing:

# Regular tuple - hard to remember what each position means
person = ("Priya", 30, "Engineer")
print(person[0])  # What is index 0? Name? Age?

Named tuples let you access elements by name, making your code self-documenting:

# Named tuple - self-documenting!
from collections import namedtuple

# Define a named tuple type
Person = namedtuple('Person', ['name', 'age', 'job'])

# Create instances
priya = Person("Priya", 30, "Engineer")
rahul = Person(name="Rahul", age=25, job="Designer")

Access values by name (much clearer!), but they still work like regular tuples:

# Access by name (much clearer!)
print(priya.name)  # 'Priya'
print(priya.age)   # 30
print(rahul.job)   # 'Designer'

# Still works like a regular tuple
print(priya[0])    # 'Priya'
print(len(priya))  # 3

Named tuples are perfect for representing "records" or structured data:

# Useful for data that represents a "record"
Point = namedtuple('Point', ['x', 'y'])
p1 = Point(10, 20)
print(f"Point at ({p1.x}, {p1.y})")  # Point at (10, 20)

When to Use Tuples vs Lists

# Example: Function returning multiple values
def get_statistics(numbers):
    """Calculate and return multiple statistics as a tuple."""
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    minimum = min(numbers)
    maximum = max(numbers)
    return minimum, maximum, average  # Returns a tuple

# Unpack the returned tuple
data = [10, 20, 30, 40, 50]
min_val, max_val, avg_val = get_statistics(data)
print(f"Min: {min_val}, Max: {max_val}, Avg: {avg_val}")
# Min: 10, Max: 50, Avg: 30.0

coordinates = (40.7128, -74.0060)

Latitude: 40.7128
Longitude: -74.006

coordinates = (40.7128, -74.0060)

latitude, longitude = coordinates

print(f"Latitude: {latitude}")
print(f"Longitude: {longitude}")

grades = (85, 90, 78, 90, 92, 88, 90)

grades = (85, 90, 78, 90, 92, 88, 90)

first_90_index = grades.index(90)
count_90 = grades.count(90)

print(first_90_index)  # 1
print(count_90)        # 3

# Test:
data = (10, 25, 3, 47, 18)
result = get_stats(data)
print(result)  # Expected: (3, 47, 20.6)

def get_stats(numbers):
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return (minimum, maximum, average)

data = (10, 25, 3, 47, 18)
result = get_stats(data)
print(result)  # (3, 47, 20.6)

# Unpack the result
min_val, max_val, avg_val = get_stats(data)
print(f"Min: {min_val}, Max: {max_val}, Avg: {avg_val}")

a = 100
b = 200

a = 100
b = 200

a, b = b, a

print(a)  # 200
print(b)  # 100

# Given:
points = [(3, 4), (1, 1), (5, 12), (2, 3)]

# Expected result: (5, 12) because √(5² + 12²) = √169 = 13

import math

def furthest_from_origin(points):
    max_distance = 0
    furthest_point = None
    
    for point in points:
        x, y = point  # Tuple unpacking
        distance = math.sqrt(x**2 + y**2)
        
        if distance > max_distance:
            max_distance = distance
            furthest_point = point
    
    return furthest_point

points = [(3, 4), (1, 1), (5, 12), (2, 3)]
result = furthest_from_origin(points)
print(result)  # (5, 12)

# Alternative using max() with key function
furthest = max(points, key=lambda p: p[0]**2 + p[1]**2)
print(furthest)  # (5, 12)

Dictionaries store data as key-value pairs, like a real dictionary where you look up a word (key) to find its definition (value). They're incredibly fast for lookups!

What is a Dictionary?

Imagine a phone book: you look up a person's name (the key) to find their phone number (the value). Python dictionaries work exactly the same way - they map unique keys to values, allowing lightning-fast lookups regardless of how much data you have.

Unlike lists where you access items by their position (index 0, 1, 2...), dictionaries let you access items by meaningful names. Instead of remembering that the user's age is at index 2, you simply ask for user["age"]. This makes your code more readable and less prone to errors.

Dictionaries are one of Python's most used data structures, especially in data science. JSON data from APIs, configuration files, database records - they all map naturally to dictionaries. Master dictionaries and you'll handle real-world data with ease.

Creating Dictionaries

You can create dictionaries using curly braces {} with colon-separated key-value pairs, or using the dict() constructor. The curly brace syntax is more common and often more readable.

# Creating dictionaries - use curly braces {}
person = {
    "name": "Priya",
    "age": 30,
    "city": "Mumbai"
}
print(person)  # {'name': 'Priya', 'age': 30, 'city': 'Mumbai'}

Keys can be any immutable type - strings, numbers, or tuples (but not lists):

# Keys can be strings, numbers, or tuples
mixed_keys = {
    "name": "Product A",
    123: "ID number",
    (1, 2): "coordinate key"
}

# Empty dictionary - two ways
empty1 = {}
empty2 = dict()

Alternative ways to create dictionaries:

# Using dict() constructor
person2 = dict(name="Rahul", age=25, city="Delhi")
print(person2)  # {'name': 'Rahul', 'age': 25, 'city': 'Delhi'}

# From list of tuples
pairs = [("a", 1), ("b", 2), ("c", 3)]
from_pairs = dict(pairs)
print(from_pairs)  # {'a': 1, 'b': 2, 'c': 3}

Accessing Values

Unlike lists where you use numeric indices, dictionaries use keys to access values. There are two main ways to get values, and understanding when to use each will save you from debugging headaches.

The first method uses square brackets: dict[key]. This is direct and clean, but it raises a KeyError if the key doesn't exist. The second method uses dict.get(key), which returns None (or a default value you specify) if the key is missing - no error, no crash.

person = {"name": "Priya", "age": 30, "city": "Mumbai"}

# Method 1: Square brackets - raises error if key doesn't exist
print(person["name"])  # 'Priya'
print(person["age"])   # 30
# print(person["job"])  # KeyError: 'job'

The safer approach - get() returns None or a default value instead of crashing:

# Method 2: get() - returns None (or default) if key doesn't exist
print(person.get("name"))      # 'Priya'
print(person.get("job"))       # None (no error!)
print(person.get("job", "N/A"))  # 'N/A' (custom default)

Checking keys and viewing contents:

# Check if key exists
print("name" in person)  # True
print("job" in person)   # False

# Get all keys, values, or both
print(person.keys())    # dict_keys(['name', 'age', 'city'])
print(person.values())  # dict_values(['Priya', 30, 'Mumbai'])
print(person.items())   # dict_items([('name', 'Priya'), ('age', 30), ('city', 'Mumbai')])

Modifying Dictionaries

Dictionaries are mutable - you can add new key-value pairs, update existing values, or remove entries. The syntax is intuitive: just assign to a key (existing or new) using square brackets.

person = {"name": "Priya", "age": 30}
person["job"] = "Engineer"
print(person)
# {'name': 'Priya', 'age': 30, 'city': 'Mumbai', 'job': 'Engineer'}

# Updating existing values
person["age"] = 31  # Happy birthday!
print(person["age"])  # 31

update() adds or updates multiple key-value pairs at once:

# update() - add/update multiple pairs at once
person.update({"age": 32, "salary": 100000, "hobby": "hiking"})
print(person)
# {'name': 'Priya', 'age': 32, 'city': 'Mumbai', 'job': 'Engineer', 
#  'salary': 100000, 'hobby': 'hiking'}

setdefault() sets a value only if the key doesn't already exist:

# setdefault() - set only if key doesn't exist
person.setdefault("country", "India")  # Added (key didn't exist)
person.setdefault("name", "Rahul")     # Not changed (key exists)
print(person["country"])  # 'India'
print(person["name"])     # 'Priya' (unchanged)

Removing Items

Python offers several ways to remove dictionary entries. pop() removes a specific key and returns its value:

person = {"name": "Priya", "age": 30, "city": "Mumbai", "job": "Engineer"}

# pop() - remove by key and return value
job = person.pop("job")
print(job)     # 'Engineer'
print(person)  # {'name': 'Priya', 'age': 30, 'city': 'Mumbai'}

# pop() with default (no error if key missing)
country = person.pop("country", "Unknown")
print(country)  # 'Unknown'

Use del to remove by key without returning the value:

# del - remove by key
del person["city"]
print(person)  # {'name': 'Priya', 'age': 30}

popitem() removes and returns the last inserted pair, and clear() empties the entire dictionary:

# popitem() - remove and return last inserted pair
person["job"] = "Data Scientist"
person["salary"] = 120000
last_item = person.popitem()
print(last_item)  # ('salary', 120000)

# clear() - remove all items
person.clear()
print(person)  # {}

Iterating Over Dictionaries

Looping through dictionaries is slightly different from lists. By default, iterating over a dictionary gives you its keys. To access values or key-value pairs, use the .values() and .items() methods respectively.

student = {"name": "Priya", "grade": "A", "score": 95}

# Loop through keys (default behavior)
for key in student:
    print(key)
# name
# grade
# score

Use .values() to iterate over values only:

# Loop through values
for value in student.values():
    print(value)
# Priya
# A
# 95

Use .items() for key-value pairs (most common):

# Loop through key-value pairs (most common)
for key, value in student.items():
    print(f"{key}: {value}")
# name: Priya
# grade: A
# score: 95

Practical example: formatting output:

# Practical example: formatting output
person = {"name": "Rahul", "age": 25, "city": "Delhi", "job": "Designer"}
print("Person Details:")
print("--------------------")
for key, value in person.items():
    print(f"{key.capitalize():10} : {value}")

Nested Dictionaries

Dictionaries can contain other dictionaries as values, creating nested structures. This is extremely common when working with JSON data from APIs.

# Nested dictionary - like JSON data
company = {
    "name": "TechCorp",
    "founded": 2010,
    "employees": {
        "priya": {
            "title": "Engineer",
            "salary": 100000
        },
        "rahul": {
            "title": "Designer", 
            "salary": 90000
        }
    },
    "locations": ["Mumbai", "Bangalore", "Delhi"]
}

Accessing nested values using chained bracket notation:

# Accessing nested values
print(company["name"])                          # 'TechCorp'
print(company["employees"]["priya"]["title"])   # 'Engineer'
print(company["locations"][0])                  # 'Mumbai'

Modifying and adding to nested dictionaries:

# Modifying nested values
company["employees"]["priya"]["salary"] = 110000

# Adding to nested dict
company["employees"]["ankit"] = {"title": "Manager", "salary": 120000}

Safe access with chained .get() to avoid errors:

# Safe access with get() for nested dicts
# This avoids errors if keys don't exist
salary = company.get("employees", {}).get("vikram", {}).get("salary", "Not found")
print(salary)  # 'Not found'

Quick Preview: Dictionary Comprehensions

Just like list comprehensions (covered in Section 05), you can create dictionaries in one line:

# Create dict from two lists
names = ["Priya", "Rahul", "Ankit"]
scores = [95, 87, 92]

# Traditional way
student_scores = {}
for i in range(len(names)):
    student_scores[names[i]] = scores[i]

# Dictionary comprehension (cleaner!)
student_scores = {name: score for name, score in zip(names, scores)}
print(student_scores)  # {'Priya': 95, 'Rahul': 87, 'Ankit': 92}

# With condition
passing = {name: score for name, score in zip(names, scores) if score >= 90}
print(passing)  # {'Priya': 95, 'Ankit': 92}

# Transform values
squared = {x: x**2 for x in range(1, 6)}
print(squared)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Real-World Data Science Example

Let's work with product data, which is common in e-commerce applications:

# Product data (list of dictionaries)
products = [
    {"id": 1, "name": "Laptop", "price": 999, "category": "Electronics", "stock": 50},
    {"id": 2, "name": "Phone", "price": 699, "category": "Electronics", "stock": 100},
    {"id": 3, "name": "Desk", "price": 299, "category": "Furniture", "stock": 30},
    {"id": 4, "name": "Chair", "price": 199, "category": "Furniture", "stock": 45},
    {"id": 5, "name": "Headphones", "price": 149, "category": "Electronics", "stock": 200}
]

Calculate total inventory value by looping through all products:

# Calculate total inventory value
total_value = 0
for product in products:
    total_value += product["price"] * product["stock"]
print(f"Total inventory value: ${total_value:,}")  # $174,650

Group products by category using dictionary building:

# Group products by category
by_category = {}
for product in products:
    category = product["category"]
    if category not in by_category:
        by_category[category] = []
    by_category[category].append(product["name"])

print(by_category)
# {'Electronics': ['Laptop', 'Phone', 'Headphones'], 'Furniture': ['Desk', 'Chair']}

Find the most expensive product by iterating through the list:

# Find most expensive product
most_expensive = products[0]
for product in products:
    if product["price"] > most_expensive["price"]:
        most_expensive = product
        
print(f"Most expensive: {most_expensive['name']} (${most_expensive['price']})")
# Most expensive: Laptop ($999)

Create a price lookup dictionary for instant access:

# Create price lookup dict
price_lookup = {}
for product in products:
    price_lookup[product["name"]] = product["price"]
    
print(price_lookup["Phone"])  # 699 - instant lookup!

student = {"name": "Priya", "age": 22, "grade": "A"}

Name: Priya
Grade: A

student = {"name": "Priya", "age": 22, "grade": "A"}

print(f"Name: {student['name']}")
print(f"Grade: {student['grade']}")

product = {"name": "Laptop", "price": 999}

{"name": "Laptop", "price": 899, "stock": 50}

product = {"name": "Laptop", "price": 999}

product["stock"] = 50
product["price"] = 899

print(product)  # {'name': 'Laptop', 'price': 899, 'stock': 50}

user = {"name": "Rahul", "email": "rahul@example.com"}

user = {"name": "Rahul", "email": "rahul@example.com"}

phone = user.get("phone", "Not provided")
print(phone)  # Not provided

words = ["apple", "banana", "apple", "cherry", "banana", "apple"]

words = ["apple", "banana", "apple", "cherry", "banana", "apple"]

counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1

print(counts)  # {'apple': 3, 'banana': 2, 'cherry': 1}

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Method 1: Using spread operator (Python 3.9+)
merged = {**dict1, **dict2}
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Method 2: Using update()
merged2 = dict1.copy()
merged2.update(dict2)
print(merged2)  # {'a': 1, 'b': 3, 'c': 4}

# Method 3: Using | operator (Python 3.9+)
merged3 = dict1 | dict2
print(merged3)  # {'a': 1, 'b': 3, 'c': 4}

Sets are unordered collections of unique elements. They're perfect for removing duplicates and performing mathematical set operations like union and intersection.

What is a Set?

Think of a set like a bag of unique marbles - you can't have duplicates, and the marbles have no particular order. If you try to add a marble you already have, the bag stays the same. Sets are inspired by mathematical sets and support powerful operations like union, intersection, and difference.

Sets are incredibly useful in data science for several reasons: removing duplicates from data (just convert to a set!), finding common elements between datasets, checking membership extremely fast, and performing operations like "customers who bought both products" or "users on both platforms."

One important distinction: sets are unordered, meaning items have no position. You can't access the "first" element because there is no first - items are stored based on their hash value for fast lookup. This also means sets don't support indexing.

Creating Sets

You create sets using curly braces {} (same as dictionaries, but without the key:value pairs), or by using the set() constructor. One tricky thing: an empty {} creates a dictionary, not a set. For an empty set, you must use set().

# Creating sets - use curly braces {}
fruits = {"apple", "banana", "cherry"}
print(fruits)  # {'cherry', 'banana', 'apple'} - order may vary!

# Duplicates are automatically removed
numbers = {1, 2, 2, 3, 3, 3, 4}
print(numbers)  # {1, 2, 3, 4}

Great for removing duplicates from a list:

# Create set from a list (great for removing duplicates!)
names_list = ["Priya", "Rahul", "Priya", "Ankit", "Rahul"]
unique_names = set(names_list)
print(unique_names)  # {'Priya', 'Rahul', 'Ankit'}

Important: Empty set must use set(), not {}:

# Empty set - MUST use set(), not {}
empty_set = set()  # Correct
empty_dict = {}    # This is an empty dictionary, not a set!

print(type(empty_set))   # 
print(type(empty_dict))  # 

Sets can only contain immutable (hashable) elements:

# Sets can only contain immutable (hashable) elements
valid_set = {1, "hello", (1, 2, 3)}  # OK: int, str, tuple
# invalid_set = {1, [2, 3]}  # Error: lists are mutable!

Adding and Removing Elements

Sets are mutable - you can add and remove elements after creation. The methods are slightly different from lists because sets don't have positions. You add() a single item, update() with multiple items, and remove() or discard() to delete.

fruits = {"apple", "banana"}

# add() - add single element
fruits.add("cherry")
print(fruits)  # {'apple', 'banana', 'cherry'}

# Adding duplicate has no effect
fruits.add("apple")
print(fruits)  # {'apple', 'banana', 'cherry'} - still 3 items

Use update() to add multiple elements:

# update() - add multiple elements
fruits.update(["date", "elderberry"])
print(fruits)  # {'apple', 'banana', 'cherry', 'date', 'elderberry'}

Removing elements - two options with different behaviors:

# remove() - remove element (error if not found)
fruits.remove("date")
print(fruits)  # {'apple', 'banana', 'cherry', 'elderberry'}
# fruits.remove("grape")  # KeyError: 'grape'

# discard() - remove element (no error if not found)
fruits.discard("elderberry")
print(fruits)  # {'apple', 'banana', 'cherry'}
fruits.discard("grape")  # No error, nothing happens

Other removal methods:

# pop() - remove and return arbitrary element
popped = fruits.pop()
print(f"Removed: {popped}")  # Removed: (random element)

# clear() - remove all elements
fruits.clear()
print(fruits)  # set()

Mathematical Set Operations

This is where sets really shine! You can perform mathematical operations to compare and combine sets. These operations are fundamental in data analysis - finding customers in both groups, products unique to one category, or combining datasets while eliminating duplicates.

Each operation has both a method form (set1.union(set2)) and an operator form (set1 | set2). Use whichever feels more natural to you - they do exactly the same thing.

python_devs = {"Priya", "Rahul", "Ankit", "Neha"}
js_devs = {"Rahul", "Neha", "Vikram", "Sneha"}

Union - everyone who knows Python OR JavaScript (or both):

# Union
all_devs = python_devs | js_devs
print(all_devs)  # {'Priya', 'Rahul', 'Ankit', 'Neha', 'Vikram', 'Sneha'}

# Same thing with method
all_devs = python_devs.union(js_devs)

Intersection - developers who know BOTH Python AND JavaScript:

# Intersection
full_stack = python_devs & js_devs
print(full_stack)  # {'Rahul', 'Neha'}

Difference - Python devs who DON'T know JavaScript:

# Difference
python_only = python_devs - js_devs
print(python_only)  # {'Priya', 'Ankit'}

js_only = js_devs - python_devs
print(js_only)  # {'Vikram', 'Sneha'}

Symmetric difference - devs who know ONLY ONE language:

# Symmetric difference
one_language = python_devs ^ js_devs
print(one_language)  # {'Priya', 'Ankit', 'Vikram', 'Sneha'}

Set Comparisons

Beyond combining sets, you can compare them using subset and superset operations. A set A is a subset of B if every element in A is also in B. Conversely, B is a superset of A. These comparisons are useful for checking containment relationships - like "do all required skills exist in a candidate's skillset?"

A = {1, 2, 3}
B = {1, 2, 3, 4, 5}
C = {1, 2, 3}
D = {6, 7, 8}

# Subset - is A contained within B?
print(A.issubset(B))    # True - all of A's elements are in B
print(A <= B)           # True (operator version)
print(A < B)            # True (proper subset - A is subset but not equal)

# Superset - does B contain A?
print(B.issuperset(A))  # True - B contains all elements of A
print(B >= A)           # True
print(B > A)            # True (proper superset)

# Equality
print(A == C)           # True - same elements

# Disjoint - no common elements?
print(A.isdisjoint(D))  # True - A and D share no elements
print(A.isdisjoint(B))  # False - they share {1, 2, 3}

Practical Uses of Sets

# 1. Remove duplicates from a list
emails = ["a@test.com", "b@test.com", "a@test.com", "c@test.com", "b@test.com"]
unique_emails = list(set(emails))
print(unique_emails)  # ['a@test.com', 'b@test.com', 'c@test.com']

# 2. Fast membership testing (much faster than lists!)
valid_users = {"priya", "rahul", "ankit", "neha"}

username = "rahul"
if username in valid_users:  # O(1) average time!
    print("Access granted")
else:
    print("Access denied")

# 3. Find common elements between lists
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = set(list1) & set(list2)
print(common)  # {4, 5}

# 4. Find unique elements
all_elements = set(list1) | set(list2)
print(all_elements)  # {1, 2, 3, 4, 5, 6, 7, 8}

# 5. Check for duplicates
def has_duplicates(lst):
    return len(lst) != len(set(lst))

print(has_duplicates([1, 2, 3, 4]))     # False
print(has_duplicates([1, 2, 2, 3]))     # True

Frozen Sets: Immutable Sets

Just like tuples are immutable lists, frozen sets are immutable sets. They can be used as dictionary keys or elements of other sets.

# Creating a frozen set
frozen = frozenset([1, 2, 3, 4])
print(frozen)  # frozenset({1, 2, 3, 4})

# Can't modify frozen sets
# frozen.add(5)  # AttributeError: 'frozenset' object has no attribute 'add'

# But can do set operations (returns new frozenset)
other = frozenset([3, 4, 5, 6])
print(frozen | other)  # frozenset({1, 2, 3, 4, 5, 6})
print(frozen & other)  # frozenset({3, 4})

# Use as dictionary key
cache = {
    frozenset(["read", "write"]): "full_access",
    frozenset(["read"]): "read_only"
}
permissions = frozenset(["read", "write"])
print(cache[permissions])  # 'full_access'

Real-World Data Science Example

# Analyzing user engagement across platforms
instagram_users = {"priya", "rahul", "ankit", "neha", "vikram"}
twitter_users = {"rahul", "ankit", "sneha", "meera"}
linkedin_users = {"priya", "ankit", "neha", "amit", "karan"}

# Users on ALL platforms
power_users = instagram_users & twitter_users & linkedin_users
print(f"Power users (all platforms): {power_users}")  # {'ankit'}

# Users on ANY platform
all_users = instagram_users | twitter_users | linkedin_users
print(f"Total unique users: {len(all_users)}")  # 9

# Users ONLY on Instagram
instagram_exclusive = instagram_users - twitter_users - linkedin_users
print(f"Instagram only: {instagram_exclusive}")  # {'vikram'}

# Users on exactly 2 platforms
on_insta_twitter = instagram_users & twitter_users
on_insta_linkedin = instagram_users & linkedin_users
on_twitter_linkedin = twitter_users & linkedin_users
two_platforms = (on_insta_twitter | on_insta_linkedin | on_twitter_linkedin) - power_users
print(f"Users on exactly 2 platforms: {two_platforms}")

# Calculate platform overlap percentages
def overlap_percentage(set1, set2):
    if not set1 or not set2:
        return 0
    overlap = len(set1 & set2)
    return (overlap / min(len(set1), len(set2))) * 100

print(f"Instagram-Twitter overlap: {overlap_percentage(instagram_users, twitter_users):.1f}%")

numbers = [4, 2, 7, 2, 1, 4, 7, 8, 1, 3]

# Convert to set (removes duplicates), then to sorted list
unique_sorted = sorted(set(numbers))

print(unique_sorted)  # [1, 2, 3, 4, 7, 8]

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Union - all elements from both sets
print(A | B)  # {1, 2, 3, 4, 5, 6, 7, 8}

# Intersection - elements in both sets
print(A & B)  # {4, 5}

# Difference - elements in A but not in B
print(A - B)  # {1, 2, 3}

# Symmetric Difference - elements in either, but not both
print(A ^ B)  # {1, 2, 3, 6, 7, 8}

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
list3 = [4, 5, 6, 8, 9]

# Convert to sets and find intersection
common = set(list1) & set(list2) & set(list3)

print(common)  # {4, 5}

small = {1, 2, 3}
medium = {1, 2, 3, 4, 5}
other = {1, 2, 6}

# Subset check (all elements in small are in medium)
print(small.issubset(medium))  # True
print(small <= medium)  # True (alternative syntax)

# Superset check (medium contains all of small)
print(medium.issuperset(small))  # True
print(medium >= small)  # True (alternative syntax)

# Is small a subset of other?
print(small.issubset(other))  # False (3 is not in other)

# Are sets disjoint (no common elements)?
print(small.isdisjoint(other))  # False (1, 2 are common)

required = {"Python", "SQL", "Statistics", "ML", "Visualization"}
actual = {"Python", "SQL", "JavaScript", "Git", "ML"}

# Missing elements (in required but not in actual)
missing = required - actual
print(f"Missing: {missing}")  # {'Statistics', 'Visualization'}

# Extra elements (in actual but not in required)
extra = actual - required
print(f"Extra: {extra}")  # {'JavaScript', 'Git'}

# Matching elements
matching = required & actual
print(f"Matching: {matching}")  # {'Python', 'SQL', 'ML'}
print(f"Match count: {len(matching)} out of {len(required)}")

Comprehensions are Python's elegant way to create and transform data structures in a single, readable line. Master these and your code will become both shorter and clearer!

What are Comprehensions?

Imagine you have a list of temperatures in Celsius and need to convert them all to Fahrenheit. The traditional approach requires creating an empty list, writing a loop, doing the calculation, and appending each result. That's 4 lines of code for something conceptually simple.

Comprehensions let you express that same logic in a single, readable line. They're one of Python's most beloved features and are considered "Pythonic" - meaning they represent the elegant, concise style that experienced Python developers prefer.

At first, comprehensions might look strange, but once you get used to reading them, they're actually clearer than loops because the intent is immediately visible: you're creating a new collection by transforming each item from another collection.

Traditional Loop vs Comprehension

Let's see the same task done both ways. The comprehension version is not only shorter but also makes the intent clearer - "I'm creating a list of squares."

# Traditional way - 4 lines
squares = []
for x in range(5):
    squares.append(x ** 2)
print(squares)  # [0, 1, 4, 9, 16]

# List comprehension - 1 line!
squares = [x ** 2 for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# Much cleaner and more "Pythonic"!

List Comprehensions

The basic syntax is: [expression for item in iterable]. Read this as "create a list containing expression for each item in the iterable." The expression can be any valid Python expression - a calculation, a method call, or even just the item itself.

# Basic syntax: [expression for item in iterable]

# Example 1: Square numbers
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Example 2: Convert temperatures
celsius = [0, 10, 20, 30, 40]
fahrenheit = [(c * 9/5) + 32 for c in celsius]
print(fahrenheit)  # [32.0, 50.0, 68.0, 86.0, 104.0]

You can also call methods on each item. Here we're calling .upper() on each name:

# Example 3: String operations
names = ["priya", "rahul", "ankit"]
capitalized = [name.upper() for name in names]
print(capitalized)  # ['PRIYA', 'RAHUL', 'ANKIT']

Comprehensions work great with dictionaries too - extract specific fields from a list of dicts:

# Example 4: Extract data from dicts
people = [
    {"name": "Priya", "age": 30},
    {"name": "Rahul", "age": 25},
    {"name": "Ankit", "age": 35}
]
names = [person["name"] for person in people]
print(names)  # ['Priya', 'Rahul', 'Ankit']

Adding Conditions (Filtering)

You can add an if clause to filter which items get included. The syntax becomes: [expression for item in iterable if condition]. Only items where the condition is True will appear in the result.

This is incredibly powerful for data cleaning and filtering - extracting only the rows you want, removing invalid data, or selecting items that meet certain criteria.

# Syntax: [expression for item in iterable if condition]

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

# Example 2: Filter by length
words = ["apple", "hi", "banana", "go", "cherry"]
long_words = [w for w in words if len(w) > 3]
print(long_words)  # ['apple', 'banana', 'cherry']

You can combine multiple conditions using and and or:

# Example 3: Filter positive numbers
numbers = [-5, 3, -2, 8, -1, 7, -4]
positive = [n for n in numbers if n > 0]
print(positive)  # [3, 8, 7]

# Example 4: Multiple conditions
numbers = range(100)
# Divisible by both 3 AND 5
div_3_and_5 = [n for n in numbers if n % 3 == 0 and n % 5 == 0]
print(div_3_and_5)  # [0, 15, 30, 45, 60, 75, 90]

This is especially powerful when filtering data structures like lists of dictionaries:

# Example 5: Filter from list of dicts
products = [
    {"name": "Laptop", "price": 999, "in_stock": True},
    {"name": "Phone", "price": 699, "in_stock": False},
    {"name": "Tablet", "price": 399, "in_stock": True}
]
available = [p["name"] for p in products if p["in_stock"]]
print(available)  # ['Laptop', 'Tablet']

If-Else in Comprehensions

When you want to transform values differently based on a condition, put the if-else before the for: [expr1 if condition else expr2 for item in iterable]

# Syntax: [value_if_true if condition else value_if_false for item in iterable]

# Example 1: Classify as even/odd
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]
print(labels)  # ['even', 'odd', 'even', 'odd', 'even']

# Example 2: Cap values at maximum
numbers = [5, 15, 25, 35, 45]
capped = [n if n <= 20 else 20 for n in numbers]
print(capped)  # [5, 15, 20, 20, 20]

Replace negative values with zero:

# Example 3: Replace negative with zero
values = [10, -5, 20, -15, 30]
non_negative = [v if v >= 0 else 0 for v in values]
print(non_negative)  # [10, 0, 20, 0, 30]

Classify values into categories:

# Example 4: Grade classification
scores = [45, 72, 88, 55, 95, 60]
grades = ["Pass" if s >= 60 else "Fail" for s in scores]
print(grades)  # ['Fail', 'Pass', 'Pass', 'Fail', 'Pass', 'Pass']

Handle missing data by providing defaults:

# Example 5: Handle missing data
data = [10, None, 20, None, 30]
cleaned = [x if x is not None else 0 for x in data]
print(cleaned)  # [10, 0, 20, 0, 30]

Nested Comprehensions

You can have multiple for clauses to work with nested data or create combinations.

Flattening a 2D list into a single list:

# Flatten a 2D list
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
flat = [num for row in matrix for num in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Equivalent traditional loop:
flat = []
for row in matrix:
    for num in row:
        flat.append(num)

Creating combinations of multiple lists:

# Create all combinations
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
combinations = [(color, size) for color in colors for size in sizes]
print(combinations)
# [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

Creating nested structures like a multiplication table:

# Create multiplication table
table = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(table)  # [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

Transposing a matrix (swap rows and columns):

# Transpose a matrix (swap rows and columns)
matrix = [
    [1, 2, 3],
    [4, 5, 6]
]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed)  # [[1, 4], [2, 5], [3, 6]]

Dictionary Comprehensions

Same concept, but creates dictionaries: {key: value for item in iterable}

# Basic syntax: {key_expr: value_expr for item in iterable}

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

Create a dictionary from two lists using zip():

# Example 2: From two lists
names = ["Priya", "Rahul", "Ankit"]
scores = [95, 87, 92]
student_scores = {name: score for name, score in zip(names, scores)}
print(student_scores)  # {'Priya': 95, 'Rahul': 87, 'Ankit': 92}

A common use case is swapping keys and values:

# Example 3: Swap keys and values
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped)  # {1: 'a', 2: 'b', 3: 'c'}

Filtering while creating a dictionary:

# Example 4: With filtering
scores = {"Priya": 95, "Rahul": 67, "Ankit": 82, "Neha": 45}
passing = {name: score for name, score in scores.items() if score >= 70}
print(passing)  # {'Priya': 95, 'Ankit': 82}

Transform values while keeping keys:

# Example 5: Transform values
prices = {"apple": 1.0, "banana": 0.5, "orange": 0.75}
discounted = {item: price * 0.9 for item, price in prices.items()}
print(discounted)  # {'apple': 0.9, 'banana': 0.45, 'orange': 0.675}

Count character frequency in a string:

# Example 6: Count character frequency
text = "hello world"
char_count = {char: text.count(char) for char in set(text)}
print(char_count)  # {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

Set Comprehensions

Creates a set instead of a list: {expression for item in iterable}

# Basic syntax: {expression for item in iterable}

# Example 1: Unique squares
squares = {x**2 for x in range(-3, 4)}
print(squares)  # {0, 1, 4, 9} - duplicates removed!

# Example 2: Unique first letters
names = ["Priya", "Rahul", "Pooja", "Ankit", "Amit"]
first_letters = {name[0] for name in names}
print(first_letters)  # {'P', 'R', 'A'}

# Example 3: With filtering
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
even_unique = {n for n in numbers if n % 2 == 0}
print(even_unique)  # {2, 4}

# Example 4: Extract unique categories
products = [
    {"name": "Laptop", "category": "Electronics"},
    {"name": "Phone", "category": "Electronics"},
    {"name": "Desk", "category": "Furniture"},
    {"name": "Chair", "category": "Furniture"}
]
categories = {p["category"] for p in products}
print(categories)  # {'Electronics', 'Furniture'}

When NOT to Use Comprehensions

Comprehensions are powerful, but they can make code harder to read when overused. Here are guidelines:

# GOOD - simple and readable
squares = [x**2 for x in range(10)]

# BAD - too complex, use a regular loop instead
# result = [x.strip().lower().replace(' ', '_') for x in data if x and len(x.strip()) > 3 and not x.startswith('#')]

# BETTER - break it down
result = []
for x in data:
    if x and len(x.strip()) > 3 and not x.startswith('#'):
        cleaned = x.strip().lower().replace(' ', '_')
        result.append(cleaned)

Real-World Data Science Examples

# Data cleaning with comprehensions
raw_data = ["  Priya  ", "RAHUL", " ankit ", "", "  Neha", None]

# Clean and normalize names
clean_names = [name.strip().title() for name in raw_data if name and name.strip()]
print(clean_names)  # ['Priya', 'Rahul', 'Ankit', 'Neha']

# Convert list of dicts to specific format
api_response = [
    {"userId": 1, "name": "Priya", "email": "priya@test.com", "active": True},
    {"userId": 2, "name": "Rahul", "email": "rahul@test.com", "active": False},
    {"userId": 3, "name": "Ankit", "email": "ankit@test.com", "active": True}
]

# Extract active user emails
active_emails = [user["email"] for user in api_response if user["active"]]
print(active_emails)  # ['priya@test.com', 'ankit@test.com']

# Create lookup dictionary
user_lookup = {user["userId"]: user["name"] for user in api_response}
print(user_lookup)  # {1: 'Priya', 2: 'Rahul', 3: 'Ankit'}

# Calculate statistics from data
sales = [
    {"product": "A", "amount": 100},
    {"product": "B", "amount": 200},
    {"product": "A", "amount": 150},
    {"product": "B", "amount": 300},
    {"product": "C", "amount": 250}
]

# Total by product
from collections import defaultdict
totals = defaultdict(int)
for sale in sales:
    totals[sale["product"]] += sale["amount"]
    
# Or with comprehension (advanced)
products = {s["product"] for s in sales}
totals = {p: sum(s["amount"] for s in sales if s["product"] == p) for p in products}
print(totals)  # {'A': 250, 'B': 500, 'C': 250}

# Square only the even numbers from 1-10
result = [x**2 for x in range(1, 11) if x % 2 == 0]

print(result)  # [4, 16, 36, 64, 100]

# Breaking it down:
# Even numbers: 2, 4, 6, 8, 10
# Their squares: 4, 16, 36, 64, 100

words = ["Application", "Programming", "Interface"]

# Get first character of each word
first_chars = [word[0] for word in words]
print(first_chars)  # ['A', 'P', 'I']

# Join into acronym
acronym = "".join(first_chars)
print(acronym)  # "API"

# Or in one line
acronym = "".join([word[0] for word in words])
print(acronym)  # "API"

words = ["cat", "elephant", "dog", "butterfly", "ant", "tiger"]

# Filter (len > 4) and transform (uppercase)
result = [word.upper() for word in words if len(word) > 4]

print(result)  # ['ELEPHANT', 'BUTTERFLY', 'TIGER']

# Long form equivalent:
result = []
for word in words:
    if len(word) > 4:
        result.append(word.upper())

original = {"a": 1, "b": 2, "c": 3}

# Swap keys and values
swapped = {value: key for key, value in original.items()}

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

# Note: This only works if all values are unique and hashable

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

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

# Nested comprehension to flatten
flattened = [num for row in matrix for num in row]

print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Read as: "for each row in matrix, for each num in row, take num"

# Equivalent loop:
flattened = []
for row in matrix:
    for num in row:
        flattened.append(num)