Unit III Function and Recursion | Cse 108 Python Programming |B.tech cse

What is a Function?

A function is a block of reusable code that performs a specific task. You define a function once and can call it multiple times throughout your code. This helps keep your code organized and makes it easier to maintain.

Defining a Function

To define a function in Python, you use the def keyword, followed by the function name and parentheses. Inside the parentheses, you can include parameters that allow you to pass values into the function.

Basic structure

def function_name(parameters): 

# Code to execute return value # (optional)

Example of a Function

Let’s create a simple function that adds two numbers. 

Code

 def add_numbers(a, b): # Define a function named add_numbers with two parameters

 result = a + b # Add the two numbers 

 return result # Return the result.

Calling a Function

To call a function, you simply use its name followed by parentheses, including any arguments (actual values) you want to pass. 

Example of Function Call

sum_result = add_numbers(3, 5) # Call the function with 3 and 5 as arguments

print(sum_result) # Outputs: 8.

Full Example

Here’s a complete example with both the function definition and the function call:

Complete Example

def greet(name): # Define a function to greet someone

print(f"Hello, {name}!") # Print a greeting

# Calling the function

greet("Alice") # Outputs: Hello, Alice!

greet("Bob") # Outputs: Hello, Bob!.

Key Points

• Defining a Function: Use def, followed by the function name and parameters.
• Calling a Function: Use the function name and provide the necessary arguments.
• Return Value: Functions can return a value using the return statement, which you can store in a variable.
• Why Use Functions?
• Reusability: Write once, use multiple times.
• Organization: Break down complex problems into smaller, manageable pieces.

 Type Conversion

Type Conversion is the process of converting one data type into another. This is often necessary when you want to perform operations that require data to be of the same type.

Key Points:

• Manual Process: You explicitly change the data type using built-in functions.
• Common Functions: In Python, you can use functions like int(), float(), str(), etc.

Examples:

Converting a String to an Integer:

• Code
• age_str = "25" # This is a string
• age_int = int(age_str) # Convert to integer
• print(age_int) # Outputs: 25

Converting an Integer to a Float:

• Code
• number = 10
• number_float = float(number) # Convert to float
• print(number_float) # Outputs: 10.0

Converting a Float to a String:

• Code
• pi = 3.14
• pi_str = str(pi) # Convert to string
• print(pi_str) # Outputs: "3.14"

 Coercion

Coercion is the automatic conversion of data types that occurs when different types are involved in an operation. Python tries to make the operation valid by converting one type to another.

Key Points:

• Automatic Process: The programming language does this for you without needing explicit commands.
• Common Scenario: Happens during arithmetic operations when combining types like integers and floats.

Examples:

Adding an Integer and a Float:

• Code
• num_int = 5 # Integer
• num_float = 2.5 # Float
• result = num_int + num_float # num_int is automatically converted to float
• print(result) # Outputs: 7.5
• In this case, 5 is converted to 5.0 to perform the addition.

Combining Strings and Numbers:

• Coercion can also lead to errors if the types are incompatible:
• # This will cause a TypeError
• # print("The answer is: " + 42) # Uncommenting this will raise an error
• Instead, you would need to convert the number to a string first:
• Code
• print("The answer is: " + str(42)) # Outputs: The answer is: 42

 Math Functions

Math Functions are built-in functions provided by Python (and often libraries like math) that perform various mathematical operations.

Key Points:

• Built-in Functions: Python has many built-in functions for performing calculations.
• Additional Library: For more advanced functions, you can use the math module, which needs to be imported.

Common Math Functions:

abs(x): Returns the absolute value of x.

• Code
• print(abs(-10)) # Outputs: 10

pow(x, y): Raises x to the power of y.

• Code
• print(pow(2, 3)) # Outputs: 8 (2^3)

math.sqrt(x): Returns the square root of x.

• Code
• import math
• print(math.sqrt(16)) # Outputs: 4.0

Trigonometric Functions: Functions like math.sin(), math.cos(), and math.tan() are used for trigonometric calculations.

• Code
• angle = math.radians(30) # Convert degrees to radians
• print(math.sin(angle)) # Outputs: 0.49999999999999994

Summary

• Type Conversion: Manually change data types using functions like int(), float(), and str().
• Coercion: Automatic type conversion that happens during operations with different types.
• Math Functions: Built-in functions (like abs() and pow()) and functions from the math library that simplify mathematical calculations.

Adding New Functions

In Python, you can create your own functions to perform specific tasks. This helps you organize your code and make it reusable.

Key Points:

• Definition: Use the def keyword to define a new function.
• Naming: Give the function a meaningful name that describes what it does.
• Parameters: Functions can accept input values, known as parameters.
• Return Values: Functions can return a value using the return statement.

Structure of a Function

The basic structure of a function in Python looks like this:

def function_name(parameters):
    # Code to execute
    return value  # (optional)

1. Simple Function

Let’s create a simple function that greets a user:

def greet(name):  # Define the function with a parameter 'name'
    print(f"Hello, {name}!")  # Print a greeting

# Calling the function
greet("Alice")  # Outputs: Hello, Alice!
greet("Bob")    # Outputs: Hello, Bob

2. Function with Multiple Parameters

You can define functions that take multiple parameters. For example, a function that adds two numbers:

def add(a, b):  # Define a function that takes two parameters
    return a + b  # Return the sum of the two parameters

# Calling the function
result = add(3, 5)  # result will be 8
print(result)  # Outputs: 8

3. Function with Default Parameters

You can also set default values for parameters. If no argument is provided, the default value will be used

def greet(name="Guest"):  # 'name' is a parameter with a default value
    print(f"Hello, {name}!")

greet()          # Outputs: Hello, Guest! (no argument provided)
greet("Alice")  # Outputs: Hello, Alice! (argument provided)  

4. Function with Variable Arguments

Sometimes you might want to accept an arbitrary number of arguments. You can do this using *args.

def sum_all(*args):  # Accept any number of arguments
    total = 0
    for number in args:
        total += number  # Sum all the numbers
    return total

# Calling the function
print(sum_all(1, 2, 3))         # Outputs: 6
print(sum_all(1, 2, 3, 4, 5))   # Outputs: 15
    

Summary

• Defining Functions: Use def followed by a function name and parentheses to define a new function.
• Parameters: Functions can accept inputs, which can be used within the function.
• Return Values: Use the return statement to send a result back to the caller.

Types of Functions:

• Simple functions with one parameter.
• Functions with multiple parameters.
• Functions with default parameters.
• Functions with variable arguments.

Parameters

Parameters are variables defined in a function's declaration. They act as placeholders for the values (arguments) that you pass to the function when you call it.

Key Points:

• Definition Location: Parameters are defined within the parentheses of the function definition.
• Function Signature: The function’s parameters are part of its signature, helping to specify what inputs the function expects.

Example of Parameters:

• def greet(name): # 'name' is a parameter
• print(f"Hello, {name}!")

In this example:

• The function greet has one parameter called name.
• When you call the function, you need to provide a value for name.

Arguments

Arguments are the actual values you pass to the function when you call it. They are the data that fill in the parameters defined in the function.

Key Points:

• Value Location: Arguments are provided in the function call.
• Types: Arguments can be of any data type (strings, integers, lists, etc.).

Example of Arguments:

• greet("Alice") # "Alice" is an argument
• greet("Bob") # "Bob" is another argument

In this example:

• When calling greet("Alice"), the string "Alice" is passed as an argument, filling the name parameter.
• When calling greet("Bob"), the string "Bob" is passed similarly.

Differences Between Parameters and Arguments

Aspect	Parameters	Arguments
Definition	Variables in function definition	Values passed to the function call
Location	Found in the function signature	Found in the function call
Purpose	Serve as placeholders for incoming data	Provide actual data to the function

More Examples

Example of a Function with a Single Parameter

def greet(name):  # 'name' is a parameter
    print(f"Hello, {name}!")  # Using the parameter in the function

# Calling the function with an argument
greet("Alice")  # Outputs: Hello, Alice!
greet("Bob")    # Outputs: Hello, Bob!
    

Example of a Function with Multiple Parameters

def add(a, b):  # 'a' and 'b' are parameters
    return a + b  # Return the sum of the two parameters

# Calling the function
result = add(3, 5)  # Arguments: 3 and 5
print(result)  # Outputs: 8
    

Example of a Function with a Default Parameter

def greet(name="Guest"):  # Default parameter value
    print(f"Hello, {name}!")  # Using the parameter in the function

# Calling the function with and without an argument
greet("Alice")  # Outputs: Hello, Alice!
greet()         # Outputs: Hello, Guest!
    

Example of a Function with Variable-Length Arguments

def sum_all(*args):  # 'args' is a parameter that accepts any number of arguments
    total = 0
    for number in args:
        total += number  # Sum all the numbers
    return total

# Calling the function
print(sum_all(1, 2, 3))         # Outputs: 6
print(sum_all(1, 2, 3, 4, 5))   # Outputs: 15
    

What is Recursion?

Recursion is a programming technique where a function calls itself in order to solve a problem. It typically breaks down a problem into smaller, more manageable sub-problems until it reaches a base case that can be solved directly.

Key Concepts of Recursion

Base Case:

• The base case is a condition under which the recursion stops. It is crucial for preventing infinite loops.
• Example: In a function that computes the factorial of a number, the base case is when the number is 0 or 1, where the factorial is defined as 1.

Recursive Case:

This is the part of the function where the recursion happens. It calls the function itself with a modified argument.

Example: For factorial, the recursive case would involve calling the factorial function with the number minus one.

Example of Recursion

Factorial Function

The factorial of a non-negative integer n is the product of all positive integers less than or equal to 𝑛

Code:

         def factorial(n):
         if n == 0 or n == 1: # Base case
        return 1
       else: # Recursive case
       return n * factorial(n - 1)
       # Calling the function
       print(factorial(5)) # Outputs: 120

Uses of Recursion

• Simplifying Complex Problems:
• Recursion can simplify the code for problems that have repetitive sub-problems.
• Example: Tree traversals, such as depth-first search (DFS).
• Solving Mathematical Problems:
• Many mathematical problems can be elegantly solved using recursion.
• Example: Fibonacci series, where each number is the sum of the two preceding ones.
•  Code
• def fibonacci(n):
• if n <= 1: # Base case
• return n
• else: # Recursive case
• return fibonacci(n - 1) + fibonacci(n - 2)
• print(fibonacci(5)) # Outputs: 5
• Data Structure Operations:
• Recursion is often used in operations involving data structures like trees and graphs.
• Example: Calculating the height of a binary tree.
• Backtracking Algorithms:
• Recursion is useful in backtracking algorithms, where you try different solutions and backtrack to previous steps if a solution fails.
• Example: Solving the N-Queens problem.
• Dynamic Programming:
• Although recursion itself can lead to inefficiencies (due to repeated calculations), combining recursion with memoization can solve complex problems efficiently.
• Example: Calculating Fibonacci numbers using memoization to store previously calculated values.

Advantages of Recursion

• Code Readability: Recursive solutions can be more straightforward and easier to understand compared to iterative solutions.
• Reduced Complexity: For problems that naturally fit the recursive pattern (like tree structures), recursive code can be more concise.

Disadvantages of Recursion

• Memory Usage: Each recursive call adds a new layer to the call stack, which can lead to stack overflow errors for deep recursions.
• Performance: Recursive solutions may be less efficient due to the overhead of multiple function calls and lack of optimization (unless using memoization).

Summary

• Recursion is a powerful programming technique that allows functions to call themselves.
• It consists of a base case (stopping condition) and a recursive case (the self-call).
• Commonly used for simplifying complex problems, solving mathematical problems, and implementing algorithms involving data structures.

Examples Of Recursion

1. Factorial Calculation

This program calculates the factorial of a number using recursion.

def factorial(n):
    if n == 0 or n == 1:  # Base case
        return 1
    else:                  # Recursive case
        return n * factorial(n - 1)
# Example usage
print(factorial(5))  # Outputs: 120

2. Fibonacci Sequence

This program computes the nth Fibonacci number using recursion.

Replace the text with codedef fibonacci(n):
    if n <= 1:  # Base case
        return n
    else:       # Recursive case
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6))  # Outputs: 8

3. Sum of a List

This program calculates the sum of elements in a list using recursion.

def sum_list(numbers):
    if len(numbers) == 0:  # Base case
        return 0
    else:                  # Recursive case
        return numbers[0] + sum_list(numbers[1:])

# Example usage
my_list = [1, 2, 3, 4, 5]
print(sum_list(my_list))  # Outputs: 15