Functions in Python

Introduction to Functions

A function is a reusable block of code that performs a specific task. Instead of writing the same code multiple times, functions allow you to write it once and reuse it wherever needed.

Why Functions are Important

• Reduce repetition (DRY principle: Don’t Repeat Yourself)
• Improve code readability and structure
• Make debugging easier
• Enable modular programming

Real-World Analogy

Think of a function like a calculator: you give input (numbers), it processes them, and returns output (result).

Example

def welcome():
    print("Welcome to Python Programming")

---

• Defining and Calling Functions

Defining a Function

Functions are defined using the def keyword followed by a function name and parentheses.

Syntax

def function_name(parameters):
    # code block

Example

def greet():
    print("Hello, User")

Calling a Function

To execute the function, call it by its name.

greet()

Function with Parameters

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

Function Execution Flow

1. Function is defined
2. Function is called
3. Control moves to function body
4. Code executes
5. Control returns back

---

• Function Arguments

Arguments are values passed into functions to make them dynamic.

1. Positional Arguments

Values are passed in order.

def subtract(a, b):
    print(a - b)subtract(10, 5)

2. Keyword Arguments

Arguments are passed using parameter names.

subtract(a=10, b=5)

3. Default Arguments

Default values are assigned to parameters.

def greet(name="Guest"):
    print("Hello", name)greet()
greet("Pooja")

4. Variable-Length Arguments (Advanced Basic)

*Arbitrary Arguments (args)

def add_numbers(*numbers):
    print(sum(numbers))add_numbers(1, 2, 3, 4)

**Keyword Arbitrary Arguments (kwargs)

def display_info(**data):
    print(data)display_info(name="Pooja", age=20)

Key Points

• Order matters in positional arguments
• Default arguments must come after positional arguments
• *args and **kwargs allow flexibility

---

• Return Statement

The return statement sends a result back to the caller.

Example

def multiply(a, b):
    return a * bresult = multiply(3, 4)
print(result)

//Returning Multiple Values

def get_values():
    return 10, 20x, y = get_values()

//Returning Different Data Types

def info():
    return "Python", 3.10, True

Key Points

• Ends function execution immediately
• Can return any data type
• If no return, function returns None

---

• Lambda Functions

Lambda functions are small, one-line anonymous functions used for simple operations.

Syntax

lambda parameters: expression

Example

square = lambda x: x * x
print(square(5))

//Using Lambda with Built-in Functions

//map() Example

nums = [1, 2, 3]
result = list(map(lambda x: x * 2, nums))
print(result)

//filter() Example

nums = [1, 2, 3, 4]
even = list(filter(lambda x: x % 2 == 0, nums))
print(even)

When to Use

• Short operations
• Temporary functions
• Functional programming style

---

• Recursion

Recursion is when a function calls itself to solve a problem.

Key Components

• Base Case: Stops recursion
• Recursive Case: Function calls itself

Example (Factorial)

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

Step-by-Step Flow

factorial(5)
→ 5 × factorial(4)
→ 5 × 4 × factorial(3)
→ continues until base case

Example (Fibonacci)

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Advantages

• Simplifies complex problems
• Useful for tree and recursive structures

Disadvantages

• Higher memory usage
• Slower than loops in some cases
• Risk of maximum recursion depth error

---

Conclusion

Functions are a fundamental building block in Python programming. They enable developers to write clean, reusable, and organized code. By understanding how to define functions, pass arguments, return values, and use advanced concepts like lambda functions and recursion, learners can significantly improve their coding skills.

Mastering functions is essential for progressing into advanced topics such as data structures, object-oriented programming, and real-world application development. Functions not only make programs efficient but also make them easier to read, debug, and maintain