You can add new key-value pairs or update existing ones using the assignment operator.

student["grade"] = "A"  # Adding a new key-value pair
print(student)  # Output: {'name': 'John', 'age': 21, 'courses': ['Math', 'Physics'], 'grade': 'A'}

student["age"] = 22  # Modifying an existing key-value pair
print(student)  # Output: {'name': 'John', 'age': 22, 'courses': ['Math', 'Physics'], 'grade': 'A'}

Dictionaries provide several methods for removing elements:

# Using pop()
age = student.pop("age")
print(age)  # Output: 22
print(student)  # Output: {'name': 'John', 'courses': ['Math', 'Physics'], 'grade': 'A'}

# Using popitem()
last_item = student.popitem()
print(last_item)  # Output: ('grade', 'A')
print(student)  # Output: {'name': 'John', 'courses': ['Math', 'Physics']}

# Using del
del student["courses"]
print(student)  # Output: {'name': 'John'}

# Using clear()
student.clear()
print(student)  # Output: {}

You can loop through keys, values, or both in a dictionary.

student = {
    "name": "John",
    "age": 21,
    "courses": ["Math", "Physics"]
}

# Loop through keys
for key in student:
    print(key)

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

# Loop through key-value pairs
for key, value in student.items():
    print(f"{key}: {value}")

Some useful dictionary methods:

print(student.keys())    # Output: dict_keys(['name', 'age', 'courses'])
print(student.values())  # Output: dict_values(['John', 21, ['Math', 'Physics']])
print(student.items())   # Output: dict_items([('name', 'John'), ('age', 21), ('courses', ['Math', 'Physics'])])

# Using update()
student.update({"name": "Jane", "age": 22})
print(student)  # Output: {'name': 'Jane', 'age': 22, 'courses': ['Math', 'Physics']}

A set is an unordered collection of unique elements. Sets are mutable, but their elements must be immutable (e.g., strings, numbers, tuples). Sets do not allow duplicate values.

my_set = {element1, element2, element3, ...}

fruits = {"apple", "banana", "cherry"}
print(fruits)  # Output: {'apple', 'banana', 'cherry'}

Sets are useful for mathematical operations like union, intersection, difference, and symmetric difference.

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1.union(set2))              # Output: {1, 2, 3, 4, 5, 6}
print(set1.intersection(set2))       # Output: {3, 4}
print(set1.difference(set2))         # Output: {1, 2}
print(set1.symmetric_difference(set2))  # Output: {1, 2, 5, 6}

Sets can be modified by adding or removing elements:

fruits.add("orange")
print(fruits)  # Output: {'apple', 'banana', 'cherry', 'orange'}

fruits.remove("banana")
print(fruits)  # Output: {'apple', 'cherry', 'orange'}

fruits.discard("banana")  # No error if "banana" is not in the set
print(fruits)  # Output: {'apple', 'cherry', 'orange'}

fruits.clear()
print(fruits)  # Output: set()

A frozenset is an immutable version of a set. It cannot be modified after it is created.

frozen_set = frozenset([1, 2, 3, 4])
print(frozen_set)  # Output: frozenset({1, 2, 3, 4})

# Attempting to modify a frozenset will raise an AttributeError
# frozen_set.add(5)  # Raises AttributeError

Create a dictionary with keys as names and values as marks. Add new entries, update marks, and delete a student entry.

Write a Python program to count the frequency of each word in a given sentence using a dictionary.

Given two lists, create sets from them and perform union, intersection, difference, and symmetric difference operations.

Write a Python program to find unique elements in a list using a set.

Create a nested dictionary to represent students' data, including their names, ages, and subjects. Write a program to print each student's details.

Write a Python program to create a contact book using a dictionary. The user should be able to add, delete, update, and search contacts.

Write a Python program to count the number of unique vowels in a given string using a set.

Write a Python program to create a dictionary from a list of numbers where the keys are the numbers, and the values

A function is a block of organized, reusable code that performs a single action or returns a value. Functions allow you to break down complex problems into smaller, manageable tasks.

def function_name(parameters):
    # Function body
    # Perform some action
    return result

def greet():
    print("Hello, World!")

greet()  # Output: Hello, World!

Use the def keyword followed by the function name and parentheses (). You can pass parameters inside the parentheses.

Simply use the function name followed by parentheses ().

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # Output: 8

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # Output: Hello, Alice!
greet("Bob", "Good Morning")  # Output: Good Morning, Bob!

def display(*args):
    print(args)

display(1, 2, 3)  # Output: (1, 2, 3)

def show_details(**kwargs):
    print(kwargs)

show_details(name="Alice", age=25)  # Output: {'name': 'Alice', 'age': 25}

The return statement is used to exit a function and send back a value to the caller. If no return statement is used, the function returns None.

def multiply(x, y):
    return x * y

result = multiply(4, 5)
print(result)  # Output: 20

The scope of a variable determines the part of the program where the variable is accessible. Python has two main types of scope:

x = 10  # Global variable

def show():
    y = 5  # Local variable
    print(y)

show()  # Output: 5
print(x)  # Output: 10
# print(y)  # Error: y is not defined

A function that calls itself is known as a recursive function. Recursion is a common mathematical and programming concept that helps solve problems by breaking them down into simpler, smaller problems.

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # Output: 120

A lambda function is a small anonymous function defined using the lambda keyword. It can have any number of arguments but only one expression.

lambda arguments: expression

square = lambda x: x ** 2
print(square(4))  # Output: 16

add = lambda a, b: a + b
print(add(3, 5))  # Output: 8

# Using map()
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # Output: [1, 4, 9, 16]

# Using filter()
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # Output: [2, 4]

# Using reduce()
from functools import reduce
product = reduce(lambda x, y: x * y, numbers)
print(product)  # Output: 24

Function annotations provide a way of attaching metadata to function arguments and return values. Annotations are optional and are stored in the function's __annotations__ attribute.

def add(a: int, b: int) -> int:
    return a + b

print(add(3, 4))  # Output: 7
print(add.__annotations__)  # Output: {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

Write a function calculator() that takes three arguments (two numbers and an operator) and returns the result of the operation.

Write a Python function that checks if a given string is a palindrome (reads the same backward as forward).

Write a recursive function to generate the Fibonacci sequence up to n terms.

Write a Python function that takes three numbers and returns the maximum of the three.

Write a Python function that takes a string as input and returns a dictionary with the frequency of each character.