Dictionary and Set Comprehensions in Python

# Dictionary Comprehension Basics

# Traditional dictionary creation
squares = {}
for x in range(1, 6):
    squares[x] = x ** 2
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Dictionary comprehension equivalent
squares = {x: x ** 2 for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Basic syntax: {key: value for item in iterable}
# Create cubes dictionary
cubes = {x: x ** 3 for x in range(1, 6)}
print(cubes)  # Output: {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

# String keys with computed values
words = ['apple', 'banana', 'cherry']
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # Output: {'apple': 5, 'banana': 6, 'cherry': 6}

# Number to word mapping
number_words = {i: str(i) for i in range(5)}
print(number_words)  # Output: {0: '0', 1: '1', 2: '2', 3: '3', 4: '4'}

# Using enumerate for indexed dictionary
fruits = ['apple', 'banana', 'cherry']
fruit_index = {i: fruit for i, fruit in enumerate(fruits)}
print(fruit_index)  # Output: {0: 'apple', 1: 'banana', 2: 'cherry'}

# Reverse: fruit to index
index_dict = {fruit: i for i, fruit in enumerate(fruits)}
print(index_dict)  # Output: {'apple': 0, 'banana': 1, 'cherry': 2}

# Create dictionary from two lists using zip
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'NYC']
person = {k: v for k, v in zip(keys, values)}
print(person)  # Output: {'name': 'Alice', 'age': 25, 'city': 'NYC'}

# Simpler: dict(zip(keys, values))
person = dict(zip(keys, values))

# Transform values during creation
temperatures_f = [32, 68, 86, 104]
temp_dict = {f"{temp}F": (temp - 32) * 5/9 for temp in temperatures_f}
print(temp_dict)
# Output: {'32F': 0.0, '68F': 20.0, '86F': 30.0, '104F': 40.0}

# Using functions in comprehension
def classify(num):
    return 'even' if num % 2 == 0 else 'odd'

classified = {num: classify(num) for num in range(1, 6)}
print(classified)  # Output: {1: 'odd', 2: 'even', 3: 'odd', 4: 'even', 5: 'odd'}

# Multiple expressions
names = ['Alice', 'Bob', 'Charlie']
name_info = {name: {'length': len(name), 'upper': name.upper()} 
             for name in names}
print(name_info)
# Output: {'Alice': {'length': 5, 'upper': 'ALICE'}, ...}

# From list of tuples
pairs = [('a', 1), ('b', 2), ('c', 3)]
dict_from_tuples = {k: v for k, v in pairs}
print(dict_from_tuples)  # Output: {'a': 1, 'b': 2, 'c': 3}

# Constant values
default_config = {key: 0 for key in ['width', 'height', 'depth']}
print(default_config)  # Output: {'width': 0, 'height': 0, 'depth': 0}

# Transforming and Filtering Dictionaries

# Transform dictionary values
prices = {'apple': 1.20, 'banana': 0.50, 'orange': 1.50}
prices_with_tax = {item: price * 1.08 for item, price in prices.items()}
print(prices_with_tax)
# Output: {'apple': 1.296, 'banana': 0.54, 'orange': 1.62}

# Transform dictionary keys
data = {'Name': 'Alice', 'Age': 25, 'City': 'NYC'}
lowercase_keys = {key.lower(): value for key, value in data.items()}
print(lowercase_keys)
# Output: {'name': 'Alice', 'age': 25, 'city': 'NYC'}

# Invert dictionary (swap keys and values)
original = {'a': 1, 'b': 2, 'c': 3}
inverted = {value: key for key, value in original.items()}
print(inverted)  # Output: {1: 'a', 2: 'b', 3: 'c'}

# Filter dictionary by values
scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'Diana': 95}
passed = {name: score for name, score in scores.items() if score >= 80}
print(passed)  # Output: {'Alice': 85, 'Bob': 92, 'Diana': 95}

# Filter by keys
user_data = {'name': 'Alice', 'age': 25, 'password': 'secret', 'email': '[email protected]'}
public_data = {k: v for k, v in user_data.items() if k != 'password'}
print(public_data)
# Output: {'name': 'Alice', 'age': 25, 'email': '[email protected]'}

# Multiple conditions
inventory = {'apple': 50, 'banana': 0, 'orange': 25, 'grape': 5}
in_stock = {item: qty for item, qty in inventory.items() 
            if qty > 0 and qty < 30}
print(in_stock)  # Output: {'orange': 25, 'grape': 5}

# Transform both keys and values
temperatures = {'NYC': 32, 'LA': 68, 'Chicago': 14}
celsius = {city.lower(): (temp - 32) * 5/9 
           for city, temp in temperatures.items()}
print(celsius)
# Output: {'nyc': 0.0, 'la': 20.0, 'chicago': -10.0}

# Conditional value transformation
numbers = {1: 10, 2: 20, 3: 30, 4: 40}
doubled_odds = {k: v * 2 if k % 2 != 0 else v 
                for k, v in numbers.items()}
print(doubled_odds)  # Output: {1: 20, 2: 20, 3: 60, 4: 40}

# Extract subset of keys
full_config = {
    'host': 'localhost',
    'port': 5432,
    'user': 'admin',
    'password': 'secret',
    'database': 'mydb'
}
required_keys = ['host', 'port', 'database']
connection_config = {k: full_config[k] for k in required_keys}
print(connection_config)
# Output: {'host': 'localhost', 'port': 5432, 'database': 'mydb'}

# Safe extraction with get()
connection_config = {k: full_config.get(k, 'default') 
                     for k in required_keys}

# Merge and transform dictionaries
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {k: v * 10 for d in [dict1, dict2] for k, v in d.items()}
print(merged)  # Output: {'a': 10, 'b': 20, 'c': 30, 'd': 40}

# Remove None values
data = {'name': 'Alice', 'age': None, 'city': 'NYC', 'phone': None}
cleaned = {k: v for k, v in data.items() if v is not None}
print(cleaned)  # Output: {'name': 'Alice', 'city': 'NYC'}

# Type conversion
string_dict = {'1': 'one', '2': 'two', '3': 'three'}
int_dict = {int(k): v for k, v in string_dict.items()}
print(int_dict)  # Output: {1: 'one', 2: 'two', 3: 'three'}

# Nested Dictionary Comprehensions

# Create multiplication table
mult_table = {i: {j: i * j for j in range(1, 6)} for i in range(1, 6)}
print(mult_table)
# Output: {
#   1: {1: 1, 2: 2, 3: 3, 4: 4, 5: 5},
#   2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10},
#   ...
# }

# Access nested values
print(mult_table[3][4])  # Output: 12

# Create nested configuration
servers = ['web', 'db', 'cache']
config = {server: {'host': f'{server}.example.com', 'port': 8000 + i} 
          for i, server in enumerate(servers)}
print(config)
# Output: {
#   'web': {'host': 'web.example.com', 'port': 8000},
#   'db': {'host': 'db.example.com', 'port': 8001},
#   'cache': {'host': 'cache.example.com', 'port': 8002}
# }

# Group data by category
items = [
    {'name': 'Apple', 'category': 'Fruit', 'price': 1.20},
    {'name': 'Carrot', 'category': 'Vegetable', 'price': 0.80},
    {'name': 'Banana', 'category': 'Fruit', 'price': 0.50}
]

# Get unique categories first
categories = {item['category'] for item in items}

# Group by category
grouped = {cat: [item['name'] for item in items if item['category'] == cat]
           for cat in categories}
print(grouped)
# Output: {'Fruit': ['Apple', 'Banana'], 'Vegetable': ['Carrot']}

# Create matrix as nested dict
matrix_dict = {i: {j: 0 for j in range(3)} for i in range(3)}
print(matrix_dict)
# Output: {0: {0: 0, 1: 0, 2: 0}, 1: {0: 0, 1: 0, 2: 0}, 2: {0: 0, 1: 0, 2: 0}}

# Transform nested structures
users = {
    'alice': {'age': 25, 'city': 'NYC'},
    'bob': {'age': 30, 'city': 'LA'}
}

# Add computed fields
enhanced = {name: {**data, 'adult': data['age'] >= 18} 
            for name, data in users.items()}
print(enhanced)
# Output: {
#   'alice': {'age': 25, 'city': 'NYC', 'adult': True},
#   'bob': {'age': 30, 'city': 'LA', 'adult': True}
# }

# Create lookup tables
products = [
    {'id': 1, 'name': 'Laptop', 'price': 999},
    {'id': 2, 'name': 'Mouse', 'price': 25}
]

product_lookup = {p['id']: {'name': p['name'], 'price': p['price']} 
                  for p in products}
print(product_lookup)
# Output: {1: {'name': 'Laptop', 'price': 999}, 2: {'name': 'Mouse', 'price': 25}}

# Nested with conditions
student_scores = {
    'Alice': [85, 90, 88],
    'Bob': [92, 88, 95],
    'Charlie': [78, 82, 75]
}

averages = {name: {'average': sum(scores) / len(scores), 
                   'passed': sum(scores) / len(scores) >= 80}
            for name, scores in student_scores.items()}
print(averages)

# Set Comprehension Basics

# Traditional set creation
squares_set = set()
for x in range(10):
    squares_set.add(x ** 2)
print(squares_set)  # Output: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# Set comprehension equivalent
squares_set = {x ** 2 for x in range(10)}
print(squares_set)  # Output: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# Basic syntax: {expression for item in iterable}
# Automatic deduplication
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = {x for x in numbers}
print(unique)  # Output: {1, 2, 3, 4}

# Simpler: set(numbers)
unique = set(numbers)

# Transform and deduplicate
words = ['Hello', 'WORLD', 'hello', 'Python', 'world']
lowercase_unique = {word.lower() for word in words}
print(lowercase_unique)  # Output: {'hello', 'world', 'python'}

# Extract unique lengths
words = ['a', 'to', 'cat', 'python', 'code', 'hi']
lengths = {len(word) for word in words}
print(lengths)  # Output: {1, 2, 3, 4, 6}

# Get first characters
names = ['Alice', 'Bob', 'Charlie', 'Amanda', 'David']
first_letters = {name[0] for name in names}
print(first_letters)  # Output: {'A', 'B', 'C', 'D'}

# Mathematical operations
even_squares = {x ** 2 for x in range(20) if x % 2 == 0}
print(even_squares)  # Output: {0, 4, 16, 36, 64, 100, 144, 196, 256, 324}

# Remove duplicates from nested list
nested = [[1, 2, 2], [3, 3, 4], [4, 5, 5]]
unique_nums = {num for sublist in nested for num in sublist}
print(unique_nums)  # Output: {1, 2, 3, 4, 5}

# Extract unique values from dict
user_cities = {'Alice': 'NYC', 'Bob': 'LA', 'Charlie': 'NYC', 'Diana': 'Chicago'}
cities = {city for city in user_cities.values()}
print(cities)  # Output: {'NYC', 'LA', 'Chicago'}

# String operations
sentence = "hello world hello python"
unique_words = {word for word in sentence.split()}
print(unique_words)  # Output: {'hello', 'world', 'python'}

# Unique characters
text = "hello"
chars = {char for char in text}
print(chars)  # Output: {'h', 'e', 'l', 'o'}

# Type conversion
string_numbers = ['1', '2', '2', '3', '3', '3']
unique_ints = {int(s) for s in string_numbers}
print(unique_ints)  # Output: {1, 2, 3}

# From range
multiples_of_5 = {x for x in range(0, 51, 5)}
print(multiples_of_5)  # Output: {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50}

# Filtering and Set Operations

# Filter with condition
numbers = range(20)
even_nums = {x for x in numbers if x % 2 == 0}
print(even_nums)  # Output: {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

# Multiple conditions
multiples = {x for x in range(1, 101) if x % 3 == 0 and x % 5 == 0}
print(multiples)  # Output: {15, 30, 45, 60, 75, 90}

# Filter strings by length
words = ['a', 'to', 'cat', 'python', 'code', 'hi']
long_words = {word for word in words if len(word) > 2}
print(long_words)  # Output: {'cat', 'python', 'code'}

# Filter and transform
values = [-5, -2, 0, 3, 7, -1, 10]
positive_squares = {x ** 2 for x in values if x > 0}
print(positive_squares)  # Output: {9, 49, 100}

# Extract valid emails
emails = ['[email protected]', 'invalid', '[email protected]', 'no-at']
valid = {email for email in emails if '@' in email and '.' in email}
print(valid)  # Output: {'[email protected]', '[email protected]'}

# Set union with comprehensions
list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
combined = {x for x in list1} | {x for x in list2}
print(combined)  # Output: {1, 2, 3, 4, 5, 6}

# Or simpler:
combined = set(list1) | set(list2)

# Set intersection
common = {x for x in list1} & {x for x in list2}
print(common)  # Output: {3, 4}

# Set difference
only_in_first = {x for x in list1} - {x for x in list2}
print(only_in_first)  # Output: {1, 2}

# Symmetric difference
difference = {x for x in list1} ^ {x for x in list2}
print(difference)  # Output: {1, 2, 5, 6}

# Complex filtering with multiple lists
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
list3 = [5, 6, 7, 8, 9]

# Elements in all three
in_all = {x for x in list1} & {x for x in list2} & {x for x in list3}
print(in_all)  # Output: {5}

# Elements in any list
in_any = {x for x in list1} | {x for x in list2} | {x for x in list3}
print(in_any)  # Output: {1, 2, 3, 4, 5, 6, 7, 8, 9}

# Filter based on another set
all_numbers = {x for x in range(20)}
exclude = {2, 5, 7, 11, 13, 17, 19}  # Primes
non_primes = {x for x in all_numbers if x not in exclude}
print(non_primes)

# Practical: Find unique tags across posts
posts = [
    {'title': 'Post 1', 'tags': ['python', 'coding', 'tutorial']},
    {'title': 'Post 2', 'tags': ['python', 'data', 'analysis']},
    {'title': 'Post 3', 'tags': ['javascript', 'web', 'coding']}
]

all_tags = {tag for post in posts for tag in post['tags']}
print(all_tags)
# Output: {'python', 'coding', 'tutorial', 'data', 'analysis', 'javascript', 'web'}

# Find common tags
post1_tags = set(posts[0]['tags'])
post2_tags = set(posts[1]['tags'])
common_tags = post1_tags & post2_tags
print(common_tags)  # Output: {'python'}

# Conditional based on set membership
allowed = {'admin', 'user', 'guest'}
roles = ['admin', 'user', 'superuser', 'guest', 'anonymous']
valid_roles = {role for role in roles if role in allowed}
print(valid_roles)  # Output: {'admin', 'user', 'guest'}

# Practical Applications

# 1. Create lookup table from list of dicts
users = [
    {'id': 1, 'name': 'Alice', 'email': '[email protected]'},
    {'id': 2, 'name': 'Bob', 'email': '[email protected]'},
    {'id': 3, 'name': 'Charlie', 'email': '[email protected]'}
]

# Lookup by ID for O(1) access
user_lookup = {user['id']: user for user in users}
print(user_lookup[2])  # Fast access: O(1)
# Output: {'id': 2, 'name': 'Bob', 'email': '[email protected]'}

# 2. Invert mapping for reverse lookup
email_to_id = {user['email']: user['id'] for user in users}
print(email_to_id['[email protected]'])  # Output: 1

# 3. Extract and validate data
form_data = {
    'username': 'alice123',
    'email': '[email protected]',
    'password': 'secret',
    'csrf_token': 'abc123',
    'remember': True
}

# Extract only valid fields
valid_fields = {'username', 'email', 'password', 'remember'}
user_data = {k: v for k, v in form_data.items() if k in valid_fields}
print(user_data)
# Output: {'username': 'alice123', 'email': '[email protected]', ...}

# 4. Group data by attribute
products = [
    {'name': 'Laptop', 'category': 'Electronics', 'price': 999},
    {'name': 'Shirt', 'category': 'Clothing', 'price': 29},
    {'name': 'Phone', 'category': 'Electronics', 'price': 699},
    {'name': 'Jeans', 'category': 'Clothing', 'price': 49}
]

categories = {p['category'] for p in products}
grouped = {cat: [p for p in products if p['category'] == cat] 
           for cat in categories}
print(grouped['Electronics'])
# Output: [{'name': 'Laptop', ...}, {'name': 'Phone', ...}]

# 5. Build cache/memoization
import functools

cache = {}
def expensive_computation(n):
    if n not in cache:
        cache[n] = n ** 3  # Expensive operation
    return cache[n]

# Pre-populate cache with comprehension
cache = {i: i ** 3 for i in range(100)}

# 6. Transform API response
api_response = [
    {'userId': 1, 'userName': 'Alice'},
    {'userId': 2, 'userName': 'Bob'}
]

# Convert to snake_case keys
transformed = [{k.replace('u', '_u').lower(): v 
                for k, v in item.items()} 
               for item in api_response]
print(transformed)
# Output: [{'user_id': 1, 'user_name': 'Alice'}, ...]

# 7. Validate against whitelist
allowed_domains = {'gmail.com', 'yahoo.com', 'outlook.com'}
emails = ['[email protected]', '[email protected]', '[email protected]']
valid_emails = {email for email in emails 
                if email.split('@')[1] in allowed_domains}
print(valid_emails)
# Output: {'[email protected]', '[email protected]'}

# 8. Count unique values
events = [
    {'user': 'alice', 'action': 'login'},
    {'user': 'bob', 'action': 'logout'},
    {'user': 'alice', 'action': 'logout'}
]

unique_users = {event['user'] for event in events}
print(f"Total unique users: {len(unique_users)}")
# Output: Total unique users: 2

# 9. Find duplicates
numbers = [1, 2, 3, 2, 4, 5, 3, 6]
seen = set()
duplicates = {x for x in numbers if x in seen or seen.add(x)}
print(duplicates)  # Output: {2, 3}

# Better approach:
from collections import Counter
counts = Counter(numbers)
duplicates = {num for num, count in counts.items() if count > 1}

# 10. Configuration merging
default_config = {'debug': False, 'port': 8000, 'host': 'localhost'}
user_config = {'port': 3000, 'ssl': True}

# Merge with user config override
final_config = {**default_config, **user_config}
print(final_config)
# Output: {'debug': False, 'port': 3000, 'host': 'localhost', 'ssl': True}