Dictionary Methods

student = {"name": "Rahul", "age": 20, "grade": "A", "city": "Mumbai"}

# Getting all keys
all_keys = student.keys()
print(all_keys)
print(type(all_keys))

# Iterating through keys
for key in student.keys():
    print(key, "->", student[key])

# Using keys directly in a for loop (implicit keys())
for key in student:
    print(f"{key}: {student[key]}")

marks = {"Math": 95, "Science": 88, "English": 76, "Hindi": 92}

# Getting all values
all_values = marks.values()
print(all_values)

# Calculate average marks
avg = sum(marks.values()) / len(marks)
print(f"Average marks: {avg}")

# Check if a value exists
if 95 in marks.values():
    print("Found a student with 95 marks!")

phone = {"brand": "Samsung", "model": "Galaxy S24", "price": 79999, "ram": "12GB"}

# Getting all items as tuples
all_items = phone.items()
print(all_items)

# Iterating through items
for key, value in phone.items():
    print(f"{key.upper()}: {value}")

# Finding an item by value
result = [(k, v) for k, v in phone.items() if v == "12GB"]
print("Items with 12GB:", result)

dictionary.get(key, default_value)

student = {"name": "Priya", "age": 21, "course": "B.Tech CSE"}

# Using get() - key exists
print(student.get("name"))         # Returns value
print(student.get("course"))       # Returns value

# Using get() - key does not exist
print(student.get("phone"))        # Returns None
print(student.get("phone", "N/A")) # Returns "N/A"

# Using get() vs direct access
# student["address"]    # This would raise KeyError!
print(student.get("address", "Not Available"))  # Safe access

# Practical example: counting characters
text = "programming"
char_count = {}
for char in text:
    char_count[char] = char_count.get(char, 0) + 1
print(char_count)

student = {"name": "Amit", "age": 20, "city": "Delhi"}

# Update with another dictionary
new_data = {"age": 21, "grade": "A+", "city": "Bangalore"}
student.update(new_data)
print("After update:", student)

# Update with keyword arguments (Python 3.9+)
student.update(phone="9876543210", email="amit@email.com")
print("After keyword update:", student)

# Update with a list of tuples
details = [("course", "B.Tech"), ("year", 3)]
student.update(details)
print("After list update:", student)

# Merge two dictionaries (Python 3.9+ using |)
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged = dict1 | dict2  # dict2 values override dict1 for common keys
print("Merged:", merged)

inventory = {"laptop": 50000, "phone": 25000, "tablet": 15000, "watch": 8000}

# pop() - removes key and returns value
price = inventory.pop("tablet")
print(f"Removed tablet: {price}")
print("Inventory:", inventory)

# pop() with default value
value = inventory.pop("camera", "Not in stock")
print(f"Camera: {value}")

# pop() without default (would raise KeyError if key missing)
# inventory.pop("nonexistent")  # Uncomment to see error

# popitem() - removes last inserted pair
last_item = inventory.popitem()
print(f"Last item removed: {last_item}")
print("Inventory:", inventory)

# popitem() on empty dict raises KeyError
# empty = {}
# empty.popitem()  # KeyError

# Practical example: processing a queue
tasks = {"task1": "High", "task2": "Medium", "task3": "Low", "task4": "High"}
while tasks:
    task, priority = tasks.popitem()
    print(f"Processing {task} (Priority: {priority})")

# clear() method
config = {"debug": True, "version": "2.0", "host": "localhost"}
print("Before clear:", config)
config.clear()
print("After clear:", config)
print("Is empty:", len(config) == 0)

# copy() - shallow copy
original = {"name": "Python", "version": 3.12, "features": ["OOP", "Functional", "Procedural"]}

# This is NOT a copy - it's just another reference
reference = original
reference["version"] = 3.11
print("Original after ref change:", original)  # Also changed!

# This IS a copy (shallow)
copied = original.copy()
copied["version"] = 3.10
print("Original after copy change:", original)  # NOT changed
print("Copied dict:", copied)

# Shallow copy caveat - nested objects are shared
original = {"name": "Alice", "scores": [90, 85, 92]}
shallow = original.copy()
shallow["scores"].append(88)
print("Original scores:", original["scores"])  # Also has 88!
print("Shallow scores:", shallow["scores"])

# For deep copy, use copy module
import copy
original = {"name": "Bob", "scores": [78, 82]}
deep = copy.deepcopy(original)
deep["scores"].append(95)
print("Original deep:", original["scores"])   # Not changed
print("Deep copy:", deep["scores"])           # Has 95

student = {"name": "Ravi", "age": 22}

# Key exists - returns existing value, does NOT change
age = student.setdefault("age", 20)
print(f"Age: {age}")
print("Student:", student)

# Key does not exist - adds key with default value
grade = student.setdefault("grade", "B")
print(f"Grade: {grade}")
print("Student:", student)

# Practical: Grouping items by category
words = ["apple", "ant", "banana", "bat", "cherry", "cat"]
grouped = {}
for word in words:
    first_letter = word[0]
    grouped.setdefault(first_letter, []).append(word)
print("Grouped:", grouped)

# Counting occurrences efficiently
sentences = ["hello world", "hello python", "world of python"]
word_freq = {}
for sentence in sentences:
    for word in sentence.split():
        word_freq[word] = word_freq.get(word, 0) + 1
print("Word frequency:", word_freq)

# Creating a dictionary with default values
keys = ["name", "age", "city"]
default_dict = dict.fromkeys(keys, "Unknown")
print("Default dict:", default_dict)

# fromkeys with None (default)
keys = ["a", "b", "c"]
none_dict = dict.fromkeys(keys)
print("None dict:", none_dict)

# fromkeys with mutable default (caution!)
keys = ["students", "teachers", "admins"]
shared_list = dict.fromkeys(keys, [])
shared_list["students"].append("Alice")
print("Shared list:", shared_list)  # All keys share same list!

# Safe way with dict comprehension
safe = {key: [] for key in keys}
safe["students"].append("Bob")
print("Safe dict:", safe)

# fromkeys with range
squares = dict.fromkeys(range(1, 6), 0)
print("Squares init:", squares)

# Initialize scores for students
students = ["Rahul", "Priya", "Amit"]
scores = dict.fromkeys(students, 0)
print("Initial scores:", scores)

{key_expression: value_expression for item in iterable if condition}

# Basic comprehension
squares = {x: x**2 for x in range(1, 11)}
print("Squares:", squares)

# With condition - even numbers only
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print("Even squares:", even_squares)

# Transform a dictionary
prices = {"apple": 50, "banana": 30, "cherry": 80, "date": 120}
discounted = {item: price * 0.9 for item, price in prices.items()}
print("Discounted:", {k: round(v, 1) for k, v in discounted.items()})

# Filter expensive items
expensive = {k: v for k, v in prices.items() if v > 50}
print("Expensive items:", expensive)

# Invert dictionary
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print("Inverted:", inverted)

# From two lists
names = ["Rahul", "Priya", "Amit"]
scores = [85, 92, 78]
grade_book = {name: score for name, score in zip(names, scores)}
print("Grade book:", grade_book)

# Nested comprehension - matrix transpose
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transpose = [[row[i] for row in matrix] for i in range(3)]
print("Original:", matrix)
print("Transposed:", transpose)