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.

Write a Python program to find the factorial of a number using an iterative function instead of recursion.

Write a Python program to use map() with a lambda function to convert a list of temperatures from Celsius to Fahrenheit.

Write a Python function to check if a given number is a prime number.

Write a Python function to flatten a nested list using recursion.

Write a Python function that takes another function as an argument and applies it to every element in a list.

A module in Python is simply a file containing Python definitions and statements. A module can define functions, classes, and variables. It can also include runnable code.

By organizing your code into modules, you can keep related code together and reuse it across multiple programs.

# greetings.py
def hello(name):
    print(f"Hello, {name}!")

def goodbye(name):
    print(f"Goodbye, {name}!")

To use a module in another Python program, you need to import it using the import keyword.

import greetings

greetings.hello("Alice")   # Output: Hello, Alice!
greetings.goodbye("Bob")   # Output: Goodbye, Bob!

You can also import specific functions or variables from a module using from.

from greetings import hello

hello("Alice")   # Output: Hello, Alice!

Python comes with a large standard library of modules that you can use without needing to install them. The standard library includes modules for various tasks such as working with files, handling dates and times, performing mathematical operations, and much more.

import math

result = math.sqrt(16)
print(result)  # Output: 4.0

from datetime import datetime

current_time = datetime.now()
print(current_time)  # Output: 2024-09-12 10:23:00 (example output)

You can easily create your own modules. All you need to do is save your Python code in a .py file. Later, you can import and use this module in other programs.

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

def subtract(a, b):
    return a - b

import math_tools

print(math_tools.add(3, 5))  # Output: 8
print(math_tools.subtract(10, 4))  # Output: 6

Importing with Aliases: You can give an alias to a module or function while importing it to simplify the code or avoid naming conflicts.

import math as m

print(m.sqrt(25))  # Output: 5.0

Importing All Names from a Module: You can use the * symbol to import everything from a module

from math import *

print(sqrt(9))  # Output: 3.0

However, importing everything this way is discouraged as it can lead to confusion if you have multiple imports with the same function names.