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.

A package is a collection of related modules. A package is just a directory that contains multiple Python files (modules) and an __init__.py file. The __init__.py file makes the directory a Python package.

math_package/
    __init__.py
    basic_operations.py
    advanced_operations.py

__init__.py: This file can be empty or contain initialization code for the package.

Modules (basic_operations.py, advanced_operations.py): The Python files inside the package contain your functions or classes.

my_package/
    __init__.py
    utilities.py

def greet(name):
    return f"Hello, {name}!"

from my_package import utilities

print(utilities.greet("Alice"))  # Output: Hello, Alice!

pip install package_name

pip install requests

import requests

response = requests.get("https://api.github.com")
print(response.status_code)  # Output: 200

import math

print(dir(math))  # Lists all functions and constants in the math module
help(math.sqrt)   # Provides documentation for the sqrt function