Chapter 8: Functions in Python With free Notes

Functions in Python

Functions are one of the most important building blocks of Python programming. They allow developers to divide a program into smaller, reusable sections that perform specific tasks. Instead of writing the same statements repeatedly, you can place them inside a function and call that function whenever it is needed.

Using functions makes Python programs more organized, easier to understand, and simpler to maintain. Functions can accept input through arguments, process that information, and return results to the part of the program that called them. Python also provides lambda functions, which are useful when a small operation needs to be written in a concise form.

In this chapter, we will learn how to define and call functions, work with different types of function arguments, use return values, create lambda functions, and apply lambda functions with map(), filter(), and reduce(). The chapter also includes practice questions to help you apply these concepts.

Functions in Python

A function is a reusable block of code designed to perform a particular task. Once a function has been defined, it can be called multiple times from different parts of a program. This approach reduces repetition and helps separate different tasks into logical sections.

Python functions are created using the def keyword, followed by the function name and parentheses. The statements belonging to the function are written inside the indented function body.

Defining and Calling Functions

Defining a Function

To define a function, use the def keyword followed by the function name and parentheses. A colon is placed at the end of the function definition, and the statements inside the function are indented.

def greet():
    print("Hello, world!")

Here, greet is the name of the function. The function contains one statement that displays a greeting message. Defining a function does not execute its code immediately. The function must be called to run the statements inside it.

Calling a Function

A function is called by writing its name followed by parentheses. When the function is called, Python executes the statements contained within its body.

greet()

The output is:

Hello, world!

This simple example demonstrates the basic process of defining and calling a Python function.

Function Arguments

Many functions require input values to perform their tasks. These values are supplied through arguments. The variables defined in a function’s definition to receive these values are commonly called parameters.

Python provides different ways to pass arguments to functions. Positional arguments, keyword arguments, and default arguments are important types to understand when working with functions.

Positional Arguments

Positional arguments are passed to a function according to the order of the parameters in the function definition. Therefore, the position of each argument is important.

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

greet("Alice")

The output is:

Hello, Alice!

In this example, "Alice" is passed as the argument for the name parameter. Because it is a positional argument, Python associates the value with the parameter according to its position.

Keyword Arguments

Keyword arguments allow you to specify the parameter name when calling a function. This can make a function call clearer because the purpose of each supplied value is directly visible.

def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")

greet(name="Alice", age=30)

The output is:

Hello, Alice! You are 30 years old.

In this example, the values are passed using the parameter names name and age. Keyword arguments can make function calls easier to read, particularly when a function accepts several parameters.

Default Arguments

Default arguments allow a parameter to have a predefined value. If the caller does not provide a value for that parameter, Python uses the default value.

def greet(name, age=18):
    print(f"Hello, {name}! You are {age} years old.")

greet("Alice")

The output is:

Hello, Alice! You are 18 years old.

Because no value was supplied for age, the function uses the default value of 18.

Return Values

A function can produce a result and send that result back to the code that called it. Python uses the return statement for this purpose.

Return values are useful when the result of a calculation or operation needs to be stored, printed, or used in another part of the program.

def add(a, b):
    return a + b

result = add(5, 3)

print(result)

The output is:

8

In this example, the add() function receives two values and returns their sum. The returned result is stored in the result variable and then displayed.

Lambda Functions

Lambda functions are small anonymous functions created using the lambda keyword. They are useful when a simple function is required for a short operation without creating a regular named function.

A lambda function can accept any number of arguments, but its body contains a single expression.

Creating a Lambda Function

A simple lambda function that calculates the square of a number can be written as follows:

square = lambda x: x ** 2

print(square(5))

The output is:

25

Here, lambda x: x ** 2 creates a function that accepts x and returns its square. The function is assigned to the variable square, which can then be used like a regular function.

Using Lambda with Built-in Functions

Lambda functions are often used together with built-in functions such as map() and filter(). They can also be used with reduce(), which is available through the functools module.

Using Lambda with map()

The map() function applies a function to each item in an iterable. A lambda function can be used when the operation applied to each item is simple.

numbers = [1, 2, 3, 4, 5]

squares = list(map(lambda x: x ** 2, numbers))

print(squares)

The output is:

[1, 4, 9, 16, 25]

In this example, the lambda function calculates the square of every number in the numbers list.

Using Lambda with filter()

The filter() function can be used to select items from an iterable according to a condition. The lambda function determines which items should remain in the resulting collection.

numbers = [1, 2, 3, 4, 5]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(even_numbers)

The output is:

[2, 4]

The lambda expression checks whether each number is divisible by 2. Only the values satisfying the condition are included in the resulting list.

Using Lambda with reduce()

The reduce() function applies a function cumulatively to the items of an iterable. It is available through the functools module.

from functools import reduce

numbers = [1, 2, 3, 4, 5]

sum_numbers = reduce(lambda x, y: x + y, numbers)

print(sum_numbers)

The output is:

15

In this example, the lambda function repeatedly adds the values together until all elements in the list have been processed.

Practice Day – Applying What You’ve Learned

Practice is an important part of learning Python functions. After understanding function definitions, arguments, return values, and lambda functions, you can solve small programming problems to strengthen your understanding.

Basic Function Practice

• Write a function named is_even() that accepts an integer and returns True if the number is even and False otherwise.
• Create a function named factorial() that accepts a number and calculates its factorial using a loop.

Function Arguments

• Define a function named greet_user() that accepts a user’s first name and last name and displays a greeting. Call the function using keyword arguments.
• Write a function named calculate_area() that calculates the area of a circle using its radius. Use a default argument for the value of pi.

Working with Return Values

• Write a function named find_max() that accepts a list of numbers and returns the maximum value.
• Create a function named reverse_string() that accepts a string and returns the string in reverse order.

Lambda Functions

• Use a lambda function with map() to create a list containing the squares of numbers from 1 to 10.
• Write a lambda function with filter() to remove words shorter than 5 characters from a list.

Advanced Lambda Usage

• Use reduce() together with a lambda function to calculate the product of all elements in a list.
• Combine map() and filter() to create a list containing the squares of even numbers from 1 to 20.

Why Functions Are Important in Python

Functions help divide a larger program into smaller and more manageable parts. Instead of placing all program statements in one long block, developers can create separate functions for different tasks.

Reusable functions can also reduce repeated code. Once a function has been written, it can be called whenever the same operation is required. Arguments allow the function to work with different input values, while return statements allow the results to be used elsewhere in the program.

Lambda functions provide another option for simple operations, particularly when they are used with functions such as map(), filter(), and reduce().

Complete Advance AI Topics: Click Here
SQL Tutorial: Click Here
YT:- DecodeIT

Conclusion

Functions are a fundamental part of Python programming and provide an effective way to organize reusable code. In this chapter, we covered how to define and call functions, pass positional, keyword, and default arguments, and return results using the return statement.

We also explored lambda functions and learned how they can be combined with map(), filter(), and reduce() to perform concise operations on collections of values. The practice questions provide additional opportunities to apply these concepts and strengthen your programming skills.

Regular practice with functions will make it easier to write organized, reusable, and efficient Python programs. As you continue learning, solving function-based coding problems can help you become more confident with Python programming.

Frequently Asked Questions

1. What is a function in Python?

A function is a reusable block of code designed to perform a specific task. It is defined using the def keyword.

2. How do you call a Python function?

A function is called by writing its name followed by parentheses, such as greet().

3. What are function arguments?

Arguments are values supplied to a function when it is called. They allow the function to work with input provided by the caller.

4. What is a default argument in Python?

A default argument is a parameter that already has a predefined value. The default is used when the caller does not provide another value.

5. What does the return statement do?

The return statement sends a result from a function back to the code that called it.

6. What is a lambda function?

A lambda function is a small anonymous function created using the lambda keyword. It contains a single expression.

7. What is map() used for with lambda functions?

map() applies a function to each item in an iterable. A lambda function can be used to define the operation applied to each item.

8. What is filter() used for?

filter() selects items from an iterable based on a condition. A lambda function can be used to define that condition.

9. What is reduce() used for?

reduce() applies a function cumulatively to the elements of an iterable and is available through the functools module.

Keywords: Functions in Python With Free Notes, Functions in Python, Python functions, Python function arguments, positional arguments in Python, keyword arguments in Python, default arguments in Python, Python return statement, lambda functions in Python, Python map filter reduce, Python function notes, Chapter 8 Functions in Python