{"id":94,"date":"2020-10-03T01:29:33","date_gmt":"2020-10-03T01:29:33","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=94"},"modified":"2025-03-26T12:42:34","modified_gmt":"2025-03-26T12:42:34","slug":"python-functions","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-basics\/python-functions\/","title":{"rendered":"Python Functions"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn to develop Python functions by using the def<\/code> keyword.<\/p>\n\n\n\n

What is a function #<\/a><\/h2>\n\n\n\n

A function is a named code block that performs a job or returns a value.<\/p>\n\n\n\n

Why do you need functions in Python #<\/a><\/h2>\n\n\n\n

Sometimes, you need to perform a task multiple times in a program. And you don’t want to copy the code for that same task all over places. <\/p>\n\n\n\n

To do so, you wrap the code in a function and use this function to perform the task whenever you need it.<\/p>\n\n\n\n

For example, whenever you want to display a value on the screen, you need to call the print()<\/code> function. Behind the scene, Python runs the code inside the print()<\/code> function to display a value on the screen.<\/p>\n\n\n\n

In practice, you use functions to divide a large program into smaller and more manageable parts. The functions will make your program easier to develop, read, test, and maintain.<\/p>\n\n\n\n

The print()<\/code> function is one of many built-in functions in Python. It means that these functions are available everywhere in the program.<\/p>\n\n\n\n

In this tutorial, you’ll learn how to define user-defined Python functions.<\/p>\n\n\n\n

Defining a Python function #<\/a><\/h2>\n\n\n\n

Here’s a simple function that shows a greeting:<\/p>\n\n\n

def<\/span> greet<\/span>()<\/span>:<\/span>\n    \"\"\" Display a greeting to users \"\"\"<\/span>\n    print('Hi'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This example shows the simplest structure of a function. A function has two main parts: a function definition and body.<\/p>\n\n\n\n
1) Function definition #<\/a><\/h3>\n\n\n\n
A function definition starts with the def<\/code> keyword and the name of the function (greet<\/code>).<\/p>\n\n\n\n
If the function needs some information to do its job, you need to specify it inside the parentheses ()<\/code>. The greet<\/code> function in this example doesn’t need any information, so its parentheses are empty.<\/p>\n\n\n\n
The function definition always ends in a colon (:<\/code>).<\/p>\n\n\n\n
2) Function body #<\/a><\/h3>\n\n\n\n
All the indented lines that follow the function definition make up the function’s body.<\/p>\n\n\n\n
The text string surrounded by triple quotes is called a docstring<\/a>. It describes what the function does. Python uses the docstring to generate documentation for the function automatically.<\/p>\n\n\n\n
The line print('Hi')<\/code> is the only line of actual code in the function body. The greet()<\/code> function does one task: print('Hi')<\/code>.<\/p>\n\n\n\n
Calling a function #<\/a><\/h2>\n\n\n\n
When you want to use a function, you need to call it. A function call instructs Python to execute the code inside the function. <\/p>\n\n\n\n
To call a function, you write the function’s name, followed by the information that the function needs in parentheses.<\/p>\n\n\n\n
The following example calls the greet()<\/code> function. Since the greet()<\/code> function doesn’t need any information, you need to specify empty parentheses like this:<\/p>\n\n\n
greet()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
If you run the program: <\/p>\n\n\n
def greet():\n    \"\"<\/span>\" Display a greeting to users \"<\/span>\"\"<\/span>\n    print<\/span>('Hi'<\/span>)\n    \ngreet()<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
it’ll show a greeting on the screen:<\/p>\n\n\n
Hi<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Passing information to Python functions #<\/a><\/h2>\n\n\n\n
Suppose that you want to greet users by their names. To do it, you need to specify a name in parentheses of the function definition as follows:<\/p>\n\n\n
def<\/span> greet<\/span>(name)<\/span>:<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The name<\/code> is called a function parameter or simply a parameter.<\/p>\n\n\n\n
When you add a parameter to the function definition, you can use it as a variable inside the function body:<\/p>\n\n\n
def<\/span> greet<\/span>(name)<\/span>:<\/span>\n    print(f\"Hi {name}<\/span>\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
And you can access the name<\/code> parameter only within the body of the greet()<\/code> function, not the outside.<\/p>\n\n\n\n
When you call a function with a parameter, you need to pass the information. For example:<\/p>\n\n\n
greet('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Here’s the complete program:<\/p>\n\n\n
def greet(name):\n    print<\/span>(f\"Hi {name}\"<\/span>)\n    \ngreet('John'<\/span>)<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi John<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The value that you pass into a function is called an argument<\/strong>. In this example 'John'<\/code> is an argument.<\/p>\n\n\n\n
Alternatively, you can call the function by passing a variable into it:<\/p>\n\n\n
def<\/span> greet<\/span>(name)<\/span>:<\/span>\n    print(f\"Hi {name}<\/span>\"<\/span>)\n    \nfirst_name = 'Jane'<\/span>\ngreet(first_name)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi Jane<\/code><\/span><\/pre>\n\n\n
In this example, the first_name<\/code> variable is also the argument of the greet()<\/code> function.<\/p>\n\n\n\n
Parameters vs. Arguments #<\/a><\/h3>\n\n\n\n
Sometimes, parameters and arguments are used interchangeably. It’s important to distinguish between the parameters and arguments of a function. <\/p>\n\n\n\n
A parameter is a piece of information that a function needs. And you specify the parameter in the function definition. For example, the greet()<\/code> function has a parameter called name<\/code>.<\/p>\n\n\n\n
An argument is a piece of data that you pass into the function. For example, the text string 'John'<\/code> or the variable jane<\/code> is the function argument.<\/p>\n\n\n\n
Returning a value #<\/a><\/h2>\n\n\n\n
A function can perform a task like the greet()<\/code> function. Or it can return a value. The value that a function returns is called a return value<\/strong>.<\/p>\n\n\n\n
To return a value from a function, you use the return<\/code> statement inside the function body.<\/p>\n\n\n
return<\/span> value<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following example modifies the greet()<\/code> function to return a greeting instead of displaying it on the screen:<\/p>\n\n\n
def<\/span> greet<\/span>(name)<\/span>:<\/span>\n    return<\/span> f\"Hi {name}<\/span>\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When you call the greet()<\/code> function, you can assign its return value to a variable:<\/p>\n\n\n
greeting = greet('John'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
And show it on the screen:<\/p>\n\n\n
print(greeting)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The new greet()<\/code> function is better than the old one because it doesn’t depend on the print()<\/code> function.<\/p>\n\n\n\n
Later, you can reuse the greet()<\/code> function in other applications. For example, you can use it in a web application to greet users after they log in.<\/p>\n\n\n
def greet(name):\n    return<\/span> f\"Hi {name}\"<\/span>\n    \ngreeting = greet('John'<\/span>)\nprint<\/span>(greeting)<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi John<\/code><\/span><\/pre>\n\n\n
Python functions with multiple parameters #<\/a><\/h2>\n\n\n\n
A function can have zero, one, or multiple parameters. <\/p>\n\n\n\n
The following example defines a function called sum()<\/code> that calculates the sum of two numbers:<\/p>\n\n\n
def<\/span> sum<\/span>(a, b)<\/span>:<\/span>\n    return<\/span> a + b\n\n\ntotal = sum(10<\/span>,20<\/span>)\nprint(total)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
30<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the sum()<\/code> function has two parameters a<\/code> and b<\/code>, and returns the sum of them.<\/p>\n\n\n\n
When a function has multiple parameters, you need to use a comma to separate them. <\/p>\n\n\n\n
When you call the function, you need to pass all the arguments. If you pass more or fewer arguments to the function, you’ll get an error.<\/p>\n\n\n\n
In the following function call, a<\/code> will be 10<\/code> and b<\/code> will be 20<\/code> inside the function body:<\/p>\n\n\n
total = sum(10<\/span>, 20<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n