A dictionary in Python is an unordered collection of data in a key-value pair format. Unlike lists and tuples, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be of any immutable type (e.g., strings, numbers, tuples)

my_dict = {
    "key1": "value1",
    "key2": "value2",
    ...
}

student = {
    "name": "John",
    "age": 21,
    "courses": ["Math", "Physics"]
}
print(student)  # Output: {'name': 'John', 'age': 21, 'courses': ['Math', 'Physics']}

You can access dictionary values by using their corresponding keys.

print(student["name"])  # Output: John
print(student["courses"])  # Output: ['Math', 'Physics']

To avoid KeyError when accessing keys that may not exist, you can use the get() method, which returns None or a default value if the key is not found.

print(student.get("age"))  # Output: 21
print(student.get("grade", "Not Found"))  # Output: Not Found

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