What are the functions in Python?
In Python, function is a set of related statements that perform a specific task.
Function helps to decompose our program into smaller modular blocks. As our plans grow, features make them more organized and manageable.
In addition, it avoids duplication and makes code reusable
Syntax for creating functions
def function_name(parameters): """docstring""" statement(s)
Shown above is a function definition, which consists of the following components.
- The keyword def marks the beginning of the function header.
- The name of the function that uniquely identifies it. Function naming follows the same rules as writing identifiers in Python.
- Parameter (parameter), through which we pass the value to the function. They are optional.
- A colon (:) marks the end of the function header.
- Optional document string (docstring) used to describe the function function.
- One or more valid python statements that make up the body of a function. Statements must have the same indentation level (usually 4 spaces).
- An optional return statement used to return a value from a function.
How do I call functions in python?
Once we define a function, we can call it from another function, program or even Python prompt. To call the function, we simply type the function name with the appropriate parameters
name = "Emma" def greet(name): """This function greets to the person passed in as parameter""" print("Hello, " + name + ". Good morning!") greet(name)
Hello, Emma. Good morning!
The first string after the function header is called docstring, which is the abbreviation of document string. It is used to briefly explain the function.
Although optional, documentation is a good programming habit. Unless you can remember the dinner you had last week, please record your code.
In the above example, we have a docstring directly below the function header. We usually use three quotation marks so that docstring can be extended to multiple lines. We can use this string as the of the function__ doc__ Property use.
This function greets to the person passed in as parameter
The return statement is used to exit the function and return to the location where the function was called. As follows:
This statement can contain an expression that requires evaluation and return a value. If there is no expression in the statement, or the return statement itself does not exist inside the function, the function returns a None object.
Hello, May. Good morning! None
Here, None is the return value
def absolute_value(num): """This function returns the absolute value of the entered number""" if num >= 0: return num else: return -num # Output: 2 print(absolute_value(2)) # Output: 4 print(absolute_value(-4))
Range and life of variables
The range of variables is the part of the program that identifies variables. Parameters and variables defined within a function are not visible externally. Therefore, they have local scope.
The life cycle of a variable is the time period during which the variable exits in memory. The life cycle of internal variables of a function is as long as the execution time of the function.
Once we return from the function, they are destroyed. Therefore, the function does not remember the value of the variable previously called.
The following is an example to illustrate the range of variables inside a function.
def my_func(): x = 10 print("Value inside function:",x) x = 20 my_func() print("Value outside function:",x)
('Value inside function:', 10) ('Value outside function:', 20)
Here, we can see that the value of x is initially 20. Even if the function my_func() changes the value of x to 10, and it does not affect values outside the function.
This is because the variable x inside the function is different from the external variable x (local to the function). Although they have the same name, they are two different variables with different ranges.
On the other hand, variables outside the function are visible from the inside. They have global scope.
We can read these values from within the function, but we cannot change (write) them. In order to modify the values of function external variables, they must be declared as global variables using the keyword global.
In the above case, we learned to define a function and call it. Otherwise, the function call will cause an error. This is an example.
def greet(name,msg): """This function greets to the person with the provided message""" print("Hello",name + ', ' + msg) greet("Monica","Good morning!")
('Hello', 'Monica, Good morning!')
Here, the function greet () has two parameters.
Because we call this function with two parameters, it runs smoothly and we won't receive any errors.
If we call it with a different number of parameters, the interpreter will report an error. The following is the call to this function, which contains a parameter without parameters and their respective error messages.
TypeErrorTraceback (most recent call last)<ipython-input-9-7765bb020128> in <module>() ----> 1 greet("Monica") 2 3 greet() TypeError: greet() takes exactly 2 arguments (1 given)
Variable function parameters
So far, the function has a fixed number of arguments. In Python, there are other ways to define a function that can accept a variable number of parameters.
Three different forms of this type are described below.
Python default parameters
Function parameters can have default values in Python.
We can use the assignment operator (=) to provide default values for parameters. This is an example.
def greet(name, msg = "Good morning!"): """ This function greets to the person with the provided message. If message is not provided, it defaults to "Good morning!" """ print("Hello",name + ', ' + msg) greet("Kate") greet("Bruce","How do you do?")
('Hello', 'Kate, Good morning!') ('Hello', 'Bruce, How do you do?')
In this function, the parameter name has no default value and is required during the call (required).
On the other hand, the default value of the parameter msg is "good morning!". Therefore, it is optional during a call. If a value is provided, it overrides the default value.
Any number of parameters in a function can have default values. However, once we have a default parameter, all parameters on the right must also have default values.
This means that non default parameters cannot follow the default parameters. For example, if we define the above function header as:
def greet(msg = "Good morning!", name):
We will receive an error:
SyntaxError: non-default argument follows default argument
Python keyword parameters
When we call a function with certain values, these values are assigned to parameters according to their location.
For example, in the above function greet (), when we call it greet ("Bruce", "how do you do?") The value "Bruce" is assigned to the parameter name, similarly to the how do you do message
Python allows functions to be called with keyword parameters. When we call a function in this way, we can change the order (position) of the parameters. The following calls to the above functions are valid and produce the same results.
>>> # 2 keyword arguments >>> greet(name = "Bruce",msg = "How do you do?") >>> # 2 keyword arguments (out of order) >>> greet(msg = "How do you do?",name = "Bruce") >>> # 1 positional, 1 keyword argument >>> greet("Bruce",msg = "How do you do?")
We can see that we can mix positional parameters with keyword parameters during function calls. But we must remember that keyword parameters must follow positional parameters.
Using positional parameters after keyword parameters will result in errors.
Python arbitrary parameters
Sometimes we don't know in advance the number of arguments to be passed to the function Python allows us to handle this situation through function calls with any number of arguments.
In the function definition, we use an asterisk (*) before the parameter name to represent this parameter. This is an example.
def greet(*names): """This function greets all the person in the names tuple.""" # names is a tuple with arguments for name in names: print("Hello",name) greet("Monica","Luke","Steve","John")
('Hello', 'Monica') ('Hello', 'Luke') ('Hello', 'Steve') ('Hello', 'John')
Here, we call the function with multiple parameters. These parameters are wrapped in tuples before being passed to the function. Inside the function, we use the for loop to retrieve all parameters.
Python functions: removing duplicate objects from the list
# Python code to remove duplicate elements from list def remove_duplicates(duplicate): uniques =  for num in duplicate: if num not in uniques: uniques.append(num) return(uniques) duplicate = [2, 4, 10, 20, 5, 2, 20, 4] print(remove_duplicates(duplicate))
[2, 4, 10, 20, 5]
Another thing worth mentioning when you use the return statement is that you can use it to return multiple values. Therefore, you can use tuples.