Python_Functions_Concepts_and_Examples

November 15, 2024

1 User Defined Function

A user-defined function in Python is a code block that performs a specific task and is defined by
the programmer. Here are the key points about user-defined functions:
Definition: User-defined functions are created with the def keyword followed by a function name of
your choosing.
Parameters: Functions can take parameters, which are values you supply to the function so it
can perform a computation with them. These parameters are placed inside parentheses after the
function name.
Body: After the parameters, you write a colon : and indent the next line to begin the function’s
body, which contains the statements that will be executed when the function is called.
Return: Functions can optionally return a value using the return statement. The value that’s
returned can be used in other parts of your program. If no return statement is specified, the
function will return None.
Calling: After defining a function, you can “call” it by writing its name followed by parentheses ().
If the function takes parameters, you can supply them inside these parentheses.

[ ]: def introduction():
print("Hello, this is my first function")

# Call function
introduction()

Hello, this is my first function

[ ]: # Single argument
def introduction(fname):
print(fname + " is my first name")

introduction("John")

John is my first name

[ ]: def introduction(fname, lname):

print("My first name is " + fname + " and my last name is " + lname)

1
 introduction("John", "Alter")

My first name is John and my last name is Alter

[1]: def introduction(fname, lname):

print("My first name is " + fname + " and my last name is " + lname)

introduction("John")

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-1-ee1f09e0e8cc> in <cell line: 4>()
2 print("My first name is " + fname + " and my last name is " + lname)
3
----> 4 introduction("John")

TypeError: introduction() missing 1 required positional argument: 'lname'

[ ]: def introduction(fname, lname = ''):

print("My first name is " + fname + " and my last name is " + lname)

introduction("John")

My first name is John and my last name is

2 Return
[ ]: def add_numbers(number_1, number_2):
sum = number_1 + number_2

result = add_numbers(5, 3)
print("The sum is:", result)

The sum is: None

the add_numbers function still computes the sum of the two numbers, but it doesn’t explicitly
return the result. As a result, when we print result, it outputs None because that’s the default
return value when no return statement is used.

[ ]: def add_numbers(number_1, number_2):

sum = number_1 + number_2
return sum

result = add_numbers(5, 3)
print("The sum is:", result)

The sum is: 8

2
 In this example, the add_numbers function takes two numbers as input, performs the addition,
and returns the sum using the return statement.
The calling code assigns the returned value to the variable result and prints it.
Without the return statement, the function would not produce any output that can be used outside
of the function.
Overall, the return statement is crucial in user-defined functions as it enables the functions to
produce outputs, pass data, allow result reusability, handle conditional returns, and control the
flow of the function’s execution.
Make a function in Python which take two numbers from user and perform add, sub mul, div

[ ]: def My_Mini_Calculator():
number_1 = float(input("Enter the first number: "))
number_2 = float(input("Enter the second number: "))

# Addition
result = number_1 + number_2
print("The sum is:", result)

# Subtraction
result = number_1 - number_2
print("The difference is:", result)

# Multiplication
result = number_1 * number_2
print("The product is:", result)

# Division
result = number_1 / number_2
print("The quotient is:", result)

# Call the function

My_Mini_Calculator()

Enter the first number: 4

Enter the second number: 2
The sum is: 6.0
The difference is: 2.0
The product is: 8.0
The quotient is: 2.0

[ ]: def My_Mini_Calculator():
number_1 = float(input("Enter the first number: "))
number_2 = float(input("Enter the second number: "))

# Addition
result = number_1 + number_2

3
 print("The sum is:", result)

# Subtraction
result = number_1 - number_2
print("The difference is:", result)

# Multiplication
result = number_1 * number_2
print("The product is:", result)

# Division
if number_2 != 0:
result = number_1 / number_2
print("The quotient is:", result)
else:
print("Oops there is an error: Division by zero is not allowed.")

# Call the function

My_Mini_Calculator()

Enter the first number: 5

Enter the second number: 0
The sum is: 5.0
The difference is: 5.0
The product is: 0.0
Oops there is an error: Division by zero is not allowed.

[ ]: def My_Mini_Calculator():
number_1 = float(input("Enter the first number: "))
number_2 = float(input("Enter the second number: "))

# Addition
add_result = number_1 + number_2

# Subtraction
diff_result = number_1 - number_2

# Multiplication
mult_result = number_1 * number_2

# Division
div_result = number_1 / number_2

return {
"Addition": add_result,
"Substraction": diff_result,
"Multiplication": mult_result,

4
 "Division": div_result,
}

# Call the function

results = My_Mini_Calculator()

print("The sum is:", results["Addition"])

print("The difference is:", results["Substraction"])
print("The product is:", results["Multiplication"])
print("The quotient is:", results["Division"])

Enter the first number: 4

Enter the second number: 2
The sum is: 6.0
The difference is: 2.0
The product is: 8.0
The quotient is: 2.0
You can create a custom function in Python to accomplish the following:
Ask the user to enter 1st and last names, be careful about case sensitivity.
Print theoutput, need only to capitalize the first letter of the first name and last name.

[ ]: def format_name():
first_name = input("Enter your first name: ")
last_name = input("Enter your last name: ")

# Capitalize the first letter of the first name

formatted_first_name = first_name.capitalize()

# Capitalize the first letter of the last name

formatted_last_name = last_name.capitalize()

# Print the formatted name

print("Candidate name is:", formatted_first_name, formatted_last_name)

# Call the function

format_name()

Enter your first name: ddd

Enter your last name: sd
Candidate name is: Ddd Sd
Create a Python programme that includes a user-defined function called print_even_numbers().
The function should prompt the user to set a range limit before printing all even numbers up to
that limit.

[ ]: def print_even_numbers():
n = int(input("Enter the range limit: "))

5
 even_numbers = []
for num in range(1, n + 1):
if num % 2 == 0:
even_numbers.append(num)

print("Even numbers up to", n, "are:", even_numbers)

# Call the function

print_even_numbers()

Enter the range limit: 8

Even numbers up to 8 are: [2, 4, 6, 8]

3 Lambda Function
here are some key points about lambda functions in Python, each point is a one-liner:
Lambda functions are small, anonymous functions defined with the lambda keyword.
They can take any number of arguments but can only have one expression.
The expression is evaluated and returned when the function is called.
Lambda functions do not require a return statement, the expression is implicitly returned.
They can be used wherever function objects are required, like inside functions like map(), filter(),
and reduce().
You can’t include statements like loops, if, or else in lambda functions; only expressions are allowed.
Lambda functions are useful for small tasks that are not reused throughout your code.
They can be assigned to variables and used like regular functions.

[ ]: # lambda arguments: expression

add = lambda x, y: x + y
print(add(5, 3)) # Output: 8

[ ]: # Define a lambda function that takes three arguments and returns their sum
add_three_numbers = lambda x, y, z: x + y + z

# Use the lambda function

result = add_three_numbers(5, 3, 8)
print(result) # Output: 16

16

[ ]: square = lambda x: x ** 2
print(square(5)) # Output: 25

6
 25

[ ]: concat = lambda x, y: x + y
print(concat("Hello", " World")) # Output: "Hello World"

Hello World

[ ]: even_or_odd = lambda x: 'even' if x%2==0 else 'odd'

print(even_or_odd(7)) # Output: 'odd'

odd

[ ]: max_num = lambda x, y: x if x > y else y

print(max_num(5, 10)) # Output: 10

10

[ ]: add = lambda a, b: a + b
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))
print(add(num1, num2))

Enter first number: 4

Enter second number: 2
6

[ ]: add = lambda: int(input("Enter first number: ")) + int(input("Enter second␣

↪number: "))

print(add())

Enter first number: 4

Enter second number: 5
9

[ ]: lambda_function = lambda x: [i ** 2 for i in x]

print(lambda_function([1, 2, 3, 4, 5])) # Output: [1, 4, 9, 16, 25]

[1, 4, 9, 16, 25]

Lambda functions are especially useful when you want to define a small function to pass as an
argument to another function.
They’re often used with functions like map(), filter(), reduce(), and sorted().
Let’s take a real-world use case involving sorting:
Consider you have a list of dictionaries, where each dictionary represents a product with a name
and a price. You want to sort this list of products based on the price.

[ ]: # A list of dictionaries is created, where each dictionary represents a product.

↪

# Each product has two properties: 'name' and 'price'.

7
products = [
{'name': 'Product1', 'price': 50},
{'name': 'Product2', 'price': 30},
{'name': 'Product3', 'price': 40},
{'name': 'Product4', 'price': 20},
]

# The products list and a lambda function are passed to the sorted() method.
# The sorted() function's key parameter accepts a function as an argument.
# This function generates a'sorting key' for each entry in the list.

# In this case, the lambda function lambda x: x['price'] takes an argument (a␣
↪dictionary) and returns the value of its 'price' key.

# These pricing values are used by the sorted() method to compare products and␣
↪determine their rank in the sorted list.

sorted_products = sorted(products, key=lambda x: x['price'])

for product in sorted_products:

print(product)

{'name': 'Product4', 'price': 20}

{'name': 'Product2', 'price': 30}
{'name': 'Product3', 'price': 40}
{'name': 'Product1', 'price': 50}

4 Recursion
Recursion refers to the programming technique in which a function defines itself by calling itself.
Here are a few highlights:
Recursion occurs when a function calls itself while providing a different input for each consecutive
call.
Base Case: To prevent unbounded recursion, every recursive function should have a base case,
which is a condition under which it stops invoking itself.
The execution context or state of each recursive call is different. The current values of a function’s
parameters and variables are placed onto the call stack when it calls itself.
Problem-Solving: Recursion is frequently used to solve problems that can be divided into smaller,
simpler problems of the same type.
Memory: Because recursive functions must retain stack frames for all recursive calls, they consume
more memory than iterative versions.
Efficiency: Because of the complexity of maintaining the stack, recursive functions can be less
efficient and can result in a stack overflow for deep recursion.
Readability: Despite potential inefficiencies, recursion can result in easier-to-read and write code
for certain issues, such as traversing tree-like data structures, sorting algorithms (such as quicksort

8
 and mergesort), solving Tower of Hanoi, Fibonacci series, and so on.
Remember that recursion is a tool, and whether or not to utilise it depends on the particular
problem you’re attempting to solve. Some issues lend themselves nicely to recursive solutions,
while others may benefit from an iterative approach.

[ ]: def recursive_sum(n):
# Base case
if n == 1:
return 1
# Recursive case
else:
return n + recursive_sum(n - 1)

print(recursive_sum(12))

78

[ ]: def factorial(n):
# Base case: 1! = 1
if n == 1:
return 1
# Recursive case: n! = n * (n-1)!
else:
return n * factorial(n-1)

The Fibonacci sequence is a set of numbers in which each number is the sum of the two numbers
before it. It usually starts with 0 and 1. In certain variants, it begins with two 1’s.
Here’s the beginning of the Fibonacci sequence:
0, 1, 1, 2, 3, 5, 8, 13, 21, …
You can see the pattern:
0+1=1
1+1=2
1+2=3
2+3=5
3+5=8
…
Each number is the sum of the two numbers before it.

[ ]: def my_fibonacci(n):
a, b = 0, 1
for i in range(n):
print(a)
a, b = b, a + b

9
 my_fibonacci(7)

0
1
1
2
3
5
8

[ ]: # We need to have a counter

cnt = 1 # This is a counter, because to explain each step. Nothing more than it.

def my_fibonacci(n):
global cnt

if n <= 0:
return []
elif n == 1:
return [0]
elif n == 2:
return [0, 1]
else:
fibonacci_series = my_fibonacci(n - 1)
print(f"Step {cnt}: Our Fibonacci series up to n-1 terms =␣
↪{fibonacci_series}")

cnt += 1
next_term = fibonacci_series[-1] + fibonacci_series[-2]
print(f"Step {cnt}: Next term to add = {next_term}")
cnt += 1
fibonacci_series.append(next_term)
print(f"Step {cnt}: Our Fibonacci series after adding next term =␣
↪{fibonacci_series}")

cnt += 1
return fibonacci_series

print("So my final Fibonacci series is ---> ", my_fibonacci(4))

Step 1: Our Fibonacci series up to n-1 terms = [0, 1]

Step 2: Next term to add = 1
Step 3: Our Fibonacci series after adding next term = [0, 1, 1]
Step 4: Our Fibonacci series up to n-1 terms = [0, 1, 1]
Step 5: Next term to add = 2
Step 6: Our Fibonacci series after adding next term = [0, 1, 1, 2]
So my final Fibonacci series is ---> [0, 1, 1, 2]
Explanation:

10
Step 1: def my_fibonacci(n): - Defines a function my_fibonacci taking one argument n.
Step 2: if n <= 0: - Checks if n is 0 or less. Skips as n=4.
Step 3: elif n == 1: - Checks if n equals 1. Skips as n=4.
Step 4: elif n == 2: - Checks if n equals 2. Skips as n=4.
Step 5: else: - As n is not 0, 1, or 2, enters the else block.
Step 6: fibonacci_series = my_fibonacci(n - 1) - Calls my_fibonacci(3) which gives [0, 1, 1].
Step 7: fibonacci_series.append(fibonacci_series[-1] + fibonacci_series[-2]) - Appends the sum of
last two elements in fib_series to the list. The list becomes [0, 1, 1, 2].
Setp 8: return fibonacci_series - Returns the final list [0, 1, 1, 2] when my_fibonacci(4) is called.

11