Functions in Python

Functions in Python are blocks of reusable code that you can access by calling the function name and passing arguments. Using functions in Python significantly simplifies a programmer's work because, instead of writing code repeatedly, one can simply call a function.

How to Create a Function in Pyhton

Let's start with an example and then move on to the explanation:

def multiply(first, second):
    return first * second

We have just written a function that performs a simple task: it multiplies the values (arguments) passed to it. These values can then be entered after the function name in the program to get the product of the factors. Now, enter the following in IDLE:

>>> multiply(7, 8)

Arguments can include not only whole numbers but also decimal numbers, for example:

>>> multiply(7.4, 8.2)
60.68

Now, let's break down the code. Here, we define a Python function using the def keyword and the function name. In parentheses, we specify parameters that will accept various arguments from user input. A colon must follow the closing parenthesis, after which a new line with indentation starts the function body, describing what the function does. If you're writing code in an editor, the indentation will be added automatically.

We used the return operator, which explicitly returns arguments. Note that after return, there is an instruction on what the program should do with the arguments. In this case, it multiplies them.

Practical Example of Using Python Functions

Here, we will demonstrate how Python functions help optimize routine tasks. The following example is simplified but illustrative. By understanding how functions work, you can learn to solve your own tasks, which will become more complex and interesting as you progress in the language.

Let's say we opened a bookstore and purchased a cash register, and the cashier had already issued receipts for the first customers. Initially, a receipt might look like this:

print("Learn Now, LLC")
print("Programming Book", end=" ")
print(1, end=" pcs. ")
print(50, end=" euro")
print("\nAdvanced Programming Book", end=" ")
print(1, end=" pcs. ")
print(100, end=" euro")
print("\nTotal:", 150, end=" euro")
print("\nThank you for your purchase!")

Output:

Learn Now, LLC
Programming Book 1 pcs. 50 euro
Advanced Programming Book 1 pcs. 100 euro
Total: 150 euro
Thank you for your purchase!

Now, imagine that a whole stack of books has been purchased, and the number of customers is increasing daily. While you manually calculate the total for one customer, others start getting impatient. This is where automation comes in. 

Let's say someone buys seven different books, with some books purchased in multiple copies:

def check(book_attr):
    total = 0
    print("Learn Now, LLC")
    for book in book_attr:
        a = book[0]
        b = book[1]
        c = book[2]
        print(f"{a} ({b} pcs.) - {c} euro")
        total += b * c
    print(f"\nTotal: {total} euro")
    print("Thank you for your purchase!")
book_attr = [
    ("Programming Book", 2, 50),
    ("Advanced Programming Book", 2, 100),
    ("Programming Book 80 lvl", 2, 195),
    ("Beginner's Guide to Python", 1, 120),
    ("You Can Become a Programmer", 1, 98),
    ("Functional Programming in Python", 1, 95),
    ("Secrets of Clean Code", 1, 80),
]

As we can see, new variables appeared, and the purchase list was placed in a separate block. Now, when generating a new receipt, all we need to do for automatic total calculation is enter the book names, quantities, and prices per unit. Once all items are entered, we call our function with the parameter formatted as a tuple above:

check(book_attr)

This produces the following output:

Learn Now, LLC
Programming Book (2 pcs.) - 50 euro
Advanced Programming Book (2 pcs.) - 100 euro
Programming Book 80 lvl (2 pcs.) - 195 euro
Beginner's Guide to Python (1 pcs.) - 120 euro
You Can Become a Programmer (1 pcs.) - 98 euro
Functional Programming in Python (1 pcs.) - 95 euro
Secrets of Clean Code (1 pcs.) - 80 euro

Total: 1083 euro  
Thank you for your purchase!  

That's it! The total amount was calculated automatically. Let’s break down the code:

• The variable total stores the purchase total and changes as new values are added to the tuple.
• A for loop is used to define a set of variables that store the following values:
  • a: product name
  • b: quantity
  • c: price per unit
• Next, we give the print command. The letter f in print statements (which is itself a built-in function, by the way) means that f-strings are used. For now, it's enough to know that they are a convenient formatting method, and the code is self-explanatory.
• The next line should not be surprising: it calculates the total by multiplying the quantity of each item by its price and adding the result to the running total.
• Finally, we use another f-string for text formatting, and we have already discussed the tuple block that stores the necessary data for purchase calculations.

Features of Functions in Python

Key Advantages:

• No need to repeat specific blocks of code, which can sometimes be quite large.
• Functions can be called as many times as needed, even consecutively.
• When divided into multiple functional blocks, large programs become much easier to track.

There are almost no downsides to functions in Python, except that they may not always be convenient. In some cases, it is easier to use generators, as certain functions (e.g., filter) may return iterators, requiring additional code to process them.

For example, if we enter the following in IDLE:

>>> numbers = [2, 4, 6, 8, 10, 12, 14]
>>> filter(lambda num: num >= 10, numbers)

We get this result:

<filter object at 0x00000000030C3220>

To correctly display elements that meet the condition, we need to wrap this expression as follows:

>>> list(filter(lambda num: num >= 10, numbers))
[10, 12, 14]

Built-in Functions in Python

You have almost certainly used them in your first Python lesson. Here’s an example:

print("Hello, World!")

The print function is a built-in function, and "Hello, World!" is its argument.

Python has hundreds, even thousands, of built-in functions, especially when additional libraries are included. You don't need to know all of them; you can always check the documentation if you encounter an unfamiliar function. However, you will need to learn some common built-in functions, as these core elements are essential for writing any useful program.

Here are some commonly used built-in functions:

• len returns the length (number of elements) of a sequence such as a string, list, tuple, range, or array:

flowers = ["bellflower", "cornflower", "buttercup", "forget-me-not", "daisy"]
len(flowers)

Output: 5

• str converts numbers into strings (since Python does not allow direct concatenation of strings and numbers):

year = 2008
"Euro " + str(year)

Output: 'Euro 2008'

• int converts strings into integers. It also rounds floating-point numbers to the nearest integer, always towards zero:

int(554.995)

Output: 554

• float converts integer values into floating-point numbers, which can be useful for certain calculations:

float(55)

Output: 55.0

• tuple converts lists into tuples:

flowers = ["bellflower", "cornflower", "buttercup", "forget-me-not", "daisy"]
tuple(flowers)

Output:

('bellflower', 'cornflower', 'buttercup', 'forget-me-not', 'daisy')

• dict allows you to create dictionaries. Here’s an example of creating a dictionary from a list of tuples using dict:

clubs = [('Barcelona', 1), ('Juventus', 3), ('Liverpool', 2), ('Real Madrid', 5), ('Bayern München', 4)]
dict(clubs)

Output:

{'Barcelona': 1, 'Juventus': 3, 'Liverpool': 2, 'Real Madrid': 5, 'Bayern München': 4}

• range creates number sequences, which can be useful for iterating through numeric values:

for number in range(0, 30, 3):
    print(number)

Output:

0
3
6
9
12
15
18
21
24
27

The range function takes three parameters:

• The first two define the range limits.
• The third (optional) parameter specifies the step.

In this case, numbers from 0 to 30 are printed in steps of 3. The upper bound is not included in the output. To include it, the range should be extended slightly:

for number in range(0, 31, 3):
    print(number)

Output:

0
3
…
27
30

Using the Result of One Function in Another Python Function

Finally, let’s look at another interesting technique. Since functions in Python are objects, they can be passed as arguments to other functions and referenced.

def check(company="Learn Now"):
    """Allows inserting different company names in the receipt"""
    print(f"{company}, LLC")

Let’s enter the name of another company:

check("Enlightenment")

Output:

Enlightenment, LLC

Now, let’s pass the created function to the built-in help function to learn what it does:

help(check)

Output:

Help on function check in module __main__:

check(company='Learn Now')
    Allows inserting different company names in the receipt

As we can see, it is quite simple.

What We Learned

In this tutorial, we explored how functions work in Python 3 and learned how to create and use them. We discussed built-in tools and examined an example of passing functions as objects to other functions.

By studying functions more deeply, you will appreciate their usefulness even when writing relatively small applications.