Python: Functions

One of the key features that make Python so popular is its support for functions.

In this blog post, I’ll explain the basics of Python functions and provide some tips for writing effective and efficient functions.

What are Python Functions?

Functions are a way to group a set of related code statements and execute them together. They provide a convenient way to reuse code, reduce the complexity of the code, and make it more modular. In Python, functions are defined using the “def” keyword, followed by the function name, and the arguments inside parentheses. The body of the function is indented and contains the code statements that are executed when the function is called.

Here is an example of a simple Python function that takes two arguments and returns their sum:

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

In this example, the add_numbers function takes two arguments a and b and returns their sum using the + operator. To call this function, we can pass two numbers as arguments:

result = add_numbers(2, 3)
print(result) # Output: 5

Overall program (save the below code in a file names

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

result = add_numbers(2, 3)

Run in terminal


Python functions can also have default arguments that are used if the argument is not provided:

def say_hello(name="Sachin"):
    print("Hello, " + name + "!")

In this example, the say_hello function takes a single argument name, which has a default value of Sachin. If we call this function without any arguments, it will use the default value:

say_hello() # Output: Hello, Sachin!

If we call the function with an argument, it will use the provided value:

say_hello("Nancy") # Output: Hello, Nancy!

Python functions can also return multiple values using tuples. Here is an example:

def square_cube(num):
    square = num ** 2
    cube = num ** 3
    return square, cube

This function takes a number as input and returns its square and cube as a tuple. To call this function and unpack the returned tuple, you can do:

s, c = square_cube(3)
print(s, c) # Output: 9 27

Recursive functions

Python functions can also call themselves, which is known as recursion. Here is an example of a recursive function that calculates the factorial of a number:

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

This function calculates the factorial of a number by recursively calling itself with a smaller input. To call this function, you can do:

result = factorial(5)
print(result) # Output: 120

Lambda functions

Lambda functions, also known as anonymous functions, are functions without a name. They are used for short and simple operations that do not require a separate function definition. Here is an example:

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

This lambda function takes a number as input and returns its square using the ** operator. Lambda functions are useful when you need to define a small function quickly and do not want to clutter your code with unnecessary function definitions.

Functions as arguments

Python functions can also be passed as arguments to other functions. This is a powerful feature that allows you to write higher-order functions that can take other functions as inputs. Here is an example:

def apply_operation(num1, num2, operation):
    return operation(num1, num2)

def add(num1, num2):
    return num1 + num2

result = apply_operation(3, 5, add)
print(result) # Output: 8

In this example, the “apply_operation” function takes two numbers and a function as inputs. It applies the function to the numbers and returns the result.

Best Practices

  1. Use meaningful names for your functions: The name of your function should describe what the function does. This makes your code more readable and easier to understand.

  2. Use function arguments and return values effectively: Your function arguments should be well-defined and describe what inputs the function expects. The return value of your function should also be well-defined and describe what output the function produces.

  3. Keep your functions small and focused: Functions should ideally perform a single task and be easy to understand. If your function becomes too complex, consider breaking it down into smaller, more manageable functions.

  4. Use default values for function arguments: If your function takes multiple arguments, consider using default values for some of the arguments. This allows the user to call the function with fewer arguments, making the function more versatile.

  5. Use docstrings to document your functions: Docstrings are a way to document your code within the code itself. They provide information on the purpose of the function, what inputs it expects, and what output it produces. This makes it easier for others (and yourself) to understand and use the function.

  6. Avoid using global variables within your functions: Global variables can make your code harder to understand and maintain. Instead, pass variables as arguments to your function or use local variables within your function.

  7. Use built-in functions and modules when possible: Python has a vast library of built-in functions and modules that can save you time and effort when writing code. Before writing your own function, check to see if there is a built-in function or module that can perform the same task.

  8. Use exception handling to handle errors: If your function can encounter errors, use exception handling to catch and handle these errors. This will make your code more robust and prevent unexpected behavior.

  9. Test your functions thoroughly: Before using your function in production, test it thoroughly with a variety of inputs to ensure that it produces the expected output. This will help you catch any bugs or errors before they become a problem.