Functions in Python
Functions are a fundamental concept in any programming language, and Python is no exception. Functions allow us to write a block of code that can be executed multiple times, improving the readability and maintainability of our code.
Functions in Python follow the DRY (Don’t Repeat Yourself) principle by eliminating duplicate code and encapsulating logic into reusable blocks.
Types of Functions
In Python, we have two types of functions:
- Built-in functions – Functions that are already defined in Python and can be used directly without any additional code.
- User-defined functions – Functions that we create ourselves to perform a specific task.
Creating a Function
Creating a function in Python is simple. It starts with the “def” keyword followed by the function’s name and parentheses.
The function body, which contains the block of code that the function will execute, is indented. Let’s create a simple function that returns the sum of two numbers:
def add_numbers(a, b):
return a + b
Calling a Function
Once a function is defined, it can be called by its name followed by the parentheses containing any required parameters.
sum = add_numbers(3, 5)
print(sum)
Docstrings
Docstrings are used to describe the purpose of a function, and they’re placed directly below the function definition. They’re used by the “help” function to display information about a particular function or module.
def add_numbers(a, b):
"""
This function adds two numbers together.
"""
return a + b
help(add_numbers)
Return Value From a Function
A function can return a value that can be used in other parts of the code. The “return” statement is used to return the function’s output.
def add_numbers(a, b):
return a + b
sum = add_numbers(3, 5)
print(sum) # Output -> 8
The pass Statement
When defining a function, sometimes we may not have the code block ready yet. In such cases, we use the “pass” keyword to indicate that we’re working on it and move on.
def add_numbers(a, b):
pass
How does Function work in Python? When a function is called, it executes a particular set of instructions.
A function has its own local scope, and any variables defined within a function are local to the function. When the function is done executing, any local variables defined within the function are destroyed.
Local Variables in Function
Local variables in functions are limited to the function in which they’re defined and cannot be accessed outside the function.
def add_numbers(a, b):
result = a + b
return result
sum = add_numbers(3, 5)
print(result) # Throws an error since result is local to the add_numbers function
Global Variables in Function
Global variables are defined outside of a function and can be accessed from any part of the code, including inside functions.
value = 10 # Global variable
def print_value():
print(value)
print(value) # Output -> 10
print_value() # Output -> 10
Global Keyword in Function
We can use the “global” keyword inside a function to access or modify global variables.
value = 10 # Global variable
def modify_value():
global value
value += 5
print(value) # Output -> 10
modify_value()
print(value) # Output -> 15
Nonlocal Variable in Function
When we have a nested function, we can use nonlocal variables to modify variables in the outer function scope.
def outer_function():
num = 10 # Variable in outer function scope
def inner_function():
nonlocal num
num += 5 # Modify the variable in outer function scope
return num
return inner_function()
print(outer_function()) # Output -> 15
Python Function Arguments
Function arguments are the input values received by the function. In Python, we have four types of arguments:
- Positional arguments – Arguments passed in the proper positional order. The order matters.
- Keyword arguments – Arguments passed with a keyword, so the order doesn’t matter.
- Default arguments – Arguments that have a default value in case the argument isn’t provided.
- Variable-length arguments – Arguments that are passed in as a tuple or dictionary.
Positional Arguments
Positional arguments are passed in the order that they’re defined in the function. For example, let’s consider our add_numbers function from earlier:
def add_numbers(a, b):
return a + b
sum = add_numbers(3, 5)
print(sum) # Output -> 8
The first value that we pass in will map to the “a” parameter, and the second value will map to the “b” parameter. Examples of
Positional Arguments
Let’s take a look at a few more examples of positional arguments:
def greetings(name, message):
print(f"{message}, {name}!")
greetings("John", "Hello") # Output -> Hello, John!
def multiply_numbers(a, b, c):
return a * b * c
result = multiply_numbers(2, 3, 4)
print(result) # Output -> 24
In the greetings function, we’re passing in two positional arguments, “John” and “Hello,” that map to the “name” and “message” parameters, respectively.
In the multiply_numbers function, we’re passing in three positional arguments that map to the “a,” “b,” and “c” parameters.
Conclusion
In conclusion, functions are a fundamental component in Python that enable us to write reusable code blocks, improve the readability of our code, and follow the DRY principle. Be sure to understand the different types of functions, the steps involved in creating and calling a function, and the use of arguments, including positional arguments, to ensure that your Python code is efficient and effective.
Keyword Arguments
In Python, keyword arguments are a way to pass values to a function based on variable names. This allows us to pass the arguments in any order, regardless of how they were defined in the function signature.
Keyword arguments are useful when we have functions with multiple parameters where it’s difficult to remember the order of the values.
Definition of
Keyword Arguments
Keyword arguments are simply arguments passed to a function with each argument having a corresponding variable name.
They are created by writing the name of the argument, followed by an equals sign, and then the argument’s value. Let’s take a look at an example:
def message(name, greeting):
print(greeting + ', ' + name)
message(name='John', greeting='Hello')
In this example, instead of passing in positional arguments, we use the variable names ‘name’ and ‘greeting’ to indicate which argument values correspond to which variables.
Therefore, the order in which we pass in the arguments does not matter because each one is explicitly named. Keyword arguments provide a clearer and concise way of understanding the values we are passing on the function, hence easier tracing of errors in the parameters.
Examples of
Keyword Arguments
Let’s take a look at some examples to understand keyword arguments better:
def message(name, greeting, question):
print(greeting + ', ' + name + '! ' + question)
# Without keyword arguments
message('John', 'Hello', 'How are you?')
# With keyword arguments
message(greeting='Hello', name='John', question='How are you?')
As you see without keyword argument, it is so much harder to understand which value corresponds to which variable. Alternatively, by using keyword arguments, we can pass the values in any order, and it is easy to understand which passed value links to which parameter.
Default Arguments
Default Arguments are arguments that already have a value set. If a parameter is not passed, the default value is used instead.
This can be useful when you want a specific value in a parameter most of the time. Definition of
Default Arguments
Default arguments are parameters that have a pre-defined value in case a value is not passed when the function is called.
This means that if the value isn’t specified, the function will use the default value instead.
def employee_salary(name, salary=55000):
print('Employee Name:', name)
print('Employee Salary:', salary)
employee_salary('John', 65000)
employee_salary('Jane')
In this example, the parameter ‘salary’ has been given a default value of 55,000.
This value is only used if the second argument is not given at the time of function call. Examples of
Default Arguments
Here’s an example of a default argument in a message function.
def message(name, greeting, question='How are you?'):
print(greeting + ', ' + name + '! ' + question)
message('John', 'Hello')
In this example, the question parameter has a default value specified in the function definition. Therefore, no argument needs to be passed for the question parameter when calling the function.
Default arguments are useful when a specific value is needed for a parameter in most cases. This way, it saves time for the programmer to input the value every time a function is called.
Conclusion
In this article, we’ve explored two types of arguments in Python, namely
Keyword Arguments and
Default Arguments. Keyword arguments allow us to pass values to a function based on variable names regardless of their order, whereas default arguments assign values to parameters when no input is provided to the function during invocation.
By making use of both keyword and default arguments, we can write better and more efficient code in Python. They are useful since they can reduce errors and make the code easier to read, maintain, and debug.
Variable-length Arguments
In Python, variable-length arguments are used to pass a variable number of arguments to a function. This is useful when we don’t know how many arguments will be passed to a function or when the number of arguments can vary.
Python provides two ways of passing variable-length arguments to a function: `*args` and `**kwargs`.
Definition of Variable-Length Arguments
Variable-length arguments are used when we want to pass a variable or unknown number of arguments to a function. There are two types of variable-length arguments in Python, and they are;
- `*args`: This syntax is used when we want to pass a variable number of arguments to a function as a tuple.
- `**kwargs`: This syntax is used when we want to pass a variable number of arguments to a function as a dictionary.
Examples of Variable-Length Arguments
Let’s take a look at a few examples to understand variable-length arguments better:
# *args example
def arithmetic(*args):
result = args[0] # set initial value of result
for number in args[1:]:
result += number # increment result by each number
return result
sum = arithmetic(3, 5, 7, 9)
print(sum) # Output -> 24
# **kwargs example
def personal_info(name, **kwargs):
print("Name:", name)
for key, value in kwargs.items():
print(key.capitalize() + ":", value)
personal_info("John", age=25, city="New York", occupation="Software Engineer")
In the first example, we’re using the `*args` syntax to pass a variable number of arguments to a function. We define the function with a tuple `*args`, which can accept any number of arguments, then we set the initial value `result` to the first element of `args`, and we increment `result` by each number in `args`.
In the second example, we’re using the `**kwargs` syntax to pass a variable number of keyword arguments to a function. We define the function with `**kwargs`, which can accept any number of keyword arguments, and we use a `for` loop to print the key-value pairs in the dictionary.
Passing variable-length arguments can be very useful when we want to pass an unknown or variable number of arguments to a function.
Tuples and Dictionaries
As mentioned earlier, the `*args` syntax is used when passing a variable number of arguments to a function as a tuple. A tuple is an ordered, immutable sequence of elements.
Let’s look at an example:
def print_elements(*args):
for element in args:
print(element)
print_elements(1, 2, 3)
In this example, we define a function called `print_elements` that takes an unknown number of arguments. These arguments are passed to the function using the `*args` syntax, which turns them into a tuple.
We then use a for loop to iterate over the elements of the tuple and print each one. On the other hand, `**kwargs` syntax is used when passing a variable number of keyword arguments to a function as a dictionary.
A dictionary is an unordered, mutable collection of key-value pairs. Let’s look at an example:
def print_values(**kwargs):
for key, value in kwargs.items():
print(key, ':', value)
print_values(name='John', age=25, city='New York')
In this example, we define a function called `print_values` that takes an unknown number of keyword arguments.
These arguments are passed to the function using the `**kwargs` syntax, which turns them into a dictionary. We then use a for loop to iterate over the key-value pairs of the dictionary and print each one.
Conclusion
In summary, variable-length arguments in Python are useful when we don’t know how many arguments will be passed to a function. This can happen when there is a variation of the number of arguments expected, and having to implement a function to capture all required arguments can be cumbersome.
Python provides two ways of passing variable-length arguments to a function, using the `*args` syntax, which allows for passing an unknown number of arguments as a tuple, and the `**kwargs` syntax, which allows for passing an unknown number of keyword arguments as a dictionary. By using these syntaxes, we can write more dynamic and versatile code in Python.
In this article, we explored three types of arguments in Python: Keyword arguments, Default arguments, and Variable-length arguments. We learned that keyword arguments help us pass arguments based on variable names, while default arguments assign values to parameters when no input is provided.
Variable-length arguments allow us to pass an unknown number of arguments to a function using either the `*args` or `**kwargs` syntax. The importance of these arguments lies in the flexibility it provides when writing Python code, allowing us to create more dynamic and versatile applications.
By understanding these concepts, we can maximize the potential of Python and write more efficient and error-free code.