What are the Python Functions with Examples

Python Functions

Python functions are essential building pieces that help arrange code and improve its readability and efficiency. They are named code blocks or units that perform a certain function. Functions segregate functionality from the rest of your application. They may return a value or collection of values after receiving inputs, also referred to as parameters.

Why Use Functions?

Functions organize and reuse code, among other benefits:

Code Reusability: Functions reduce code duplication and improve code reuse. You can declare a function once and use it throughout your program without modifying the code. Programmer error and development time are decreased as a result. The function definition is the only place in the code that has to be changed, and it will be reflected anywhere the function is invoked.

Code Organization and Modularity: Functions aid in the division of more complex programs into smaller, easier-to-manage, and modular sections. The code is simpler to read and comprehend because of this arrangement of logical statements. Because function calls summarise component functions, descriptive function names simplify the main program.

Easier Testing and Debugging: Breaking a program into functions lets you test and debug each code piece before assembling it. Variables inside functions normally have local scopes, so code in one function doesn’t affect variables in others. This helps limit what code could be modifying variable values, which facilitates debugging.

Defining Functions

Python functions are defined using def. Use the def keyword, function name, optional parameters in parenthesis, and a colon to define a function. In function bodies, code is indented below the header.
The first string literal after the function header is usually a “docstring,” which describes the function’s capabilities. While not essential, a docstring is best practice for code documentation and compatibility with documentation tools.

Here is the basic syntax for defining a function:

def function ame(parameters):
    Optional docstring
    # Function body  statements to be executed
    statement1
    statement2
    #
    return value

When Python runs that line, the def statement generates the function object. Only when the function is called does the code inside the function body run; it is not run during definition.

Calling Functions

You “call” or “invoke” a function to run the code inside of it. To invoke a function, write its name in parenthesis (). You pass values, often referred to as arguments, inside the brackets during the call if the function specification contains parameters. Within the local scope of the function, these arguments are allocated to the appropriate parameters.

The program’s execution flow leaps from the point of the call to the first statement in the function’s body when a function is called. The function body’s assertions are carried out one after the other. The flow of execution returns to the location where the function was called and proceeds from there once the function has completed running (either by reaching a return statement or the end of the function body).

Code Examples

Defining and calling a simple function with no parameters:

# Function definition
def hello(): 
    This function prints a greeting
    print("Hello World!") 
# Function call
print("Before the function call.")
hello() 
print("After the function call.")
hello()

The body of the hello() function runs each time this code is executed.

Output:

Before the function call.
Hello World!
After the function call.
Hello World!

Defining and calling a function with a parameter:

# Function definition with a parameter 'msg'
def display message(msg)
    This function prints the message passed to it
    print(msg) 
# Function calls with arguments
display message("Hello from the first call!") 
message text = "This is a different message."
display message(message text) 
for i in range(2):
    display message("Hello from inside a loop.")

The parameter in the function definition in this instance is message. The string enclosed in parenthesis is the argument when display message(“…”) is called, and its value is allocated to the msg parameter for that particular function execution.

Defining and calling a function that returns a value (a “fruitful” function):

# Function definition that returns a value
def add numbers(a, b)
  This function adds two numbers and returns the result
    total = a + b 
    return total 
# Function calls and using the returned value
result1 = add numbers(5, 3) 
print("The sum is:", result1)
num1 = 10
num2 = 20
result2 = add numbers(num1, num2) 
print("The sum is:", result2)
print("Another sum:", add numbers(1, 1))

This function add numbers computes a sum and returns the result to the function’s call location via the return statement. The function call’s returned value can subsequently be assigned to a variable or utilised in an expression.
These examples demonstrate the use of def to define functions, the use of arguments to take information, the use of () to execute functions when called, and return to send information. Writing structured, reusable, and effective Python code requires a methodical approach to function definition and calling.

Page Content

Tutorials