6. Functions in Python

A function is a reusable block of code that performs a specific task. It helps in: ● Organizing code into logical sections ● Reducing repetition (DRY – Don’t Repeat Yourself) ● Improving readability and maintainability

A function in Python is a set of instructions that you can define once and use over and over again. Functions help structure code by separating different tasks into manageable parts. This organization makes your code easier to read, understand, and maintain. Additionally, by using functions, you can avoid writing the same code multiple times, which is aligned with the principle of DRY – Don't Repeat Yourself.

Think of a function like a recipe. When you follow a recipe (the function), you can produce a dish without needing to remember every step. By using the same recipe multiple times, you can create the dish for different occasions without rewriting the recipe each time.

Syntax:

def function_name():
    # code block

Calling a Function:

function_name()

Example:

def greet():
    print("Hello, welcome to Python!")
greet() # Calling the function

To create a function, you use the def keyword followed by the function name and parentheses. Inside the parentheses, you may specify parameters. The instructions to be executed when the function is called are written within the indented block under the function definition. Once defined, you can call the function simply by using its name followed by parentheses. For example, the greet function prints a welcome message to the console when called.

Imagine defining a greeting as organizing an event where you need to welcome guests. You set up the event just once (define the function) and whenever guests arrive (calling the function), you just follow your plan to greet them. This way, you maintain a consistent welcome for everyone.

Functions can take input parameters (also called arguments).

Example:

def greet(name):
    print("Hello,", name)
greet("Alice")

Parameters allow you to pass information to a function when it's called. In the function declaration, parameters are defined within the parentheses. For example, greet(name) defines a function that takes one parameter, name. When calling `greet(

• Chunk Title: Return Values
• Chunk Text: Functions can return results using the return keyword.

Example:

def add(a, b):
    return a + b
result = add(5, 3)
print(result) # Output: 8

• Detailed Explanation: The return keyword is used to send a value back from a function to wherever the function was called. This means the function can perform a calculation and give back the result. In the example given, the add function takes two numbers and returns their sum. This functionality allows you to capture the output of the function and use it later in your code.

Think about returning a book after reading it. When you finish with a book (completing the function), you return it to its shelf (the calling location). The add function sends back the sum, just like returning the book allows others to use it again.

You can assign default values to parameters.

Example:

def greet(name="Guest"):
    print("Hello,", name)
greet() # Output: Hello, Guest
greet("Rahul") # Output: Hello, Rahul

Default parameters allow a function to have a predefined value if no argument is provided during the function call. In this example, if greet() is called without arguments, it defaults to 'Guest'. This feature provides flexibility and allows for simpler function calls when a common value is expected.

Imagine a restaurant where the default order for a drink is water if you don’t specify what you want. If someone just says 'I would like a drink', they get water. This is similar to how default parameters work in functions.

🔹 *args: accepts any number of positional arguments

def total(*numbers):
    print(sum(numbers))
total(1, 2, 3, 4) # Output: 10

🔹 **kwargs: accepts any number of keyword arguments

def profile(**info):
    print(info)
profile(name="Ana", age=25)
# Output: {'name': 'Ana', 'age': 25}

In Python, the *args syntax allows a function to accept any number of positional arguments, which it receives as a tuple, while **kwargs allows for any number of keyword arguments, received as a dictionary. This means you can create functions that can handle dynamic amounts of input. For example, the total function can sum any number of numbers passed to it, and profile can describe a person with various attributes.

Imagine throwing a party where you invite as many friends as you want (*args) and you can ask for specific details about each friend like their name and age (**kwargs). This way, whether you have a few friends or many, you can still manage the party efficiently.

Type Examples

• Built-in: print(), len(), type(), range()
• User-defined: defined using def keyword

Python comes with a rich set of built-in functions that perform common tasks, such as print() for displaying output or len() for finding the length of an object. User-defined functions, on the other hand, are created by you using the def keyword to encapsulate specific tasks you need for your application. Understanding the difference allows you to effectively utilize the capabilities of Python.

Think of built-in functions as tools you find in a toolbox, such as a screwdriver or pliers. They are always available to you. User-defined functions are like custom tools you create for a specific task, tailored just for your needs. Just as you would choose the right tool for a job, you choose functions based on specific requirements.

--