## DEV Community is a community of 901,019 amazing developers

We're a place where coders share, stay up-to-date and grow their careers. Otu Michael

Posted on • Updated on

# Python3 Programming - Exercise 12 b - Function that returns a value

This is a continuation of `exercise 12 a (A function and its definition)`

## Function that returns a value

So far, we have written functions that print values to the screen. We can also return a value from a function, assign that value to a variable and make use of it in the future.

### Example 1

Previously when we wrote the `calc_area` function, it prints out a string, detailing the input and the output. Say, we are only interested in the computed result, we can return the computed result using the `return` keyword followed by the computed value. The snippet below is only modified to return the computed by `calc_area`.

``````def calc_area(base, height):
return 0.5 * base * height

# take the base and height from the user
base = float(input("Enter base: "))
height = float(input("Enter height: "))

# call the function here and pass base and height
# to it as the base and height are required
# the value is then assigned to a variable, `area`
area = calc_area(base, height)

# We then make use of the `area`
print(
f"The area of a triangle of base, {base} and height, {height} is {area}")

``````

`calc_area` is now not associated with printing a user-friendly text, telling what input and output were involved. This is left in the hands of the user to decide. This makes it easier to write unit tests for `calc_area` and also import it as a script in other programs.

### Example 2

This is a function that takes a list as an argument and then sorts it from the lowest to the highest. How does this sorting function work?

Say that we are given a list of size, `n`, numbers, using two loops, nested actually. The first loop loops through the list `n - 1` times. The second does, `n - 2` times. In the second loop, we check if the first value is greater than the second value. If it is, we `swap` the values and then we compare the second with the third and then the third and fourth and so on until we reach the end of the list. The first loop moves (i.e steps 1) then the process starts again.

``````def sort_func(nums):
"""
This function takes a list as an argument and
returns a sorted version of it
"""
n = len(nums)

for i in range(n):
for j in range(1, n):
if nums[j - 1] > nums[j]:
# swap
nums[j - 1], nums[j] = nums[j], nums[j - 1]

return nums

print(sort_func([6, 3, 2, 4, 1]))
print(sort_func(['w', 't', 'a', 'i']))

``````

On this line, `nums[j - 1], nums[j] = nums[j], nums[j - 1]`, we swap values here if `nums[j - 1] > nums[j]`. This is a "technique" used for swapping in python without introducing an helping variable.

We could have done,

``````temp = nums[j - 1]
nums[j - 1] = nums[j]
nums[j] = temp
``````

## Function with many arguments

We have passed single value (data) or a list into our function as arguments so far. Now, say we would like to pass several arguments into a function (we can still use a list - sort of), we are forced to give the function numerous parameters on creation but there is a simple approach in Python.

### Example 3

A function that takes several strings as an argument and prints the number of characters in each argument.

``````def many_args(s1, s2, s3, s4, s5):
print(len(s1))
print(len(s2))
print(len(s3))
print(len(s4))
print(len(s5))

many_args('sandy', 'jude', 'mani', 'desmond', 'peter')
``````

We did it right? No. What if we want to pass a sixth argument? We have to update the `many_args` function. Any other program that has used `many_args` function has to update the number of arguments passed. We don't want that. We should never write such functions. This is an opinion and a style choice.

## `*args` and `**kwargs`

In the next `exercise` we shall discuss more on data structures in python such as list, dictionary, set and tuple into some details. These data structures help in organization and management of data. We came across the word "iterable". The previously mentioned data structures also allow iteration.

### list, tuple, set and dictionary in brief

In this context, we are interested in data structures as arguments so these should be enough.

• A list is a comma-separated collection of data delimited by square brackets, `[data1, data2, ...]` where data can be of any data type or data structure. This implies we can have a list that has other lists as data.
• A tuple is just list but is delimited by brackets, `(data1, data2, ...)`
• A set is just like a list but without duplicates, delimited by curly brackets, `{data1, data2, ...}`.
• A dictionary is a key-name pair kind of data structure. So far, list, tuple and set are indexed (enumerated) from 0 to `n - 1`, where `n` is the size. For a dictionary, we use a key to access a value. `{key1:value2, key2:value2, ...}`. We can loop through the keys, the values and the keys and values. A dictionary is more like a set, with uniqueness in the keys.

### `*args`

We discussed passing multiple data into a function as arguments and we saw some of the limitations.

`*args` means a collection of data, such as list, tuple or set. The parameter name, `*args`, is a conversion. The variable name, `args`, is preceded by an asterisk, `*`. It is the `*` that makes the variable a collection of data. So we can use any name as far as it is preceded by an asterisk, `*`. `*pancakes` works fine as `*args`.

The number of data in the variable is unspecified. This solves the issue we had - we had to update the function when we wanted to pass another data to the function.

One of the key concepts here is, limiting the number of parameters a function takes. No more, `func(arg1, arg2, arg3, ...)`. At most four and these four should be named arguments if something like that happens.

#### Example 4

We shall we implement `example 3` but this time using the `*args` concept.

``````def many_args(*s):
for i in s:
print(i, "=", len(i))

many_args(
'sandy', 'jude', 'mani', 'desmond', 'peter',
'milo', 'john', 'kobby', 'hannah', 'alvin',

``````

We were able to pass several arguments to `many_args` but our function just has `*s` as a parameter.

#### Passing a list into a function that takes `*args`

We can also pass a list into `many_args`

``````largs = ['candy', 'foo', 'bar', 'swift', 'python',
'ryder', 'horse', 'rubber-duck', 'pizza']

many_args(largs)
``````

But what was the output? Try it out and see. What do you think happened (Look at example 4)? How do we fix this?

#### making a list argument as *list_arg

This `'candy', 'foo', 'bar', 'swift', 'python', 'ryder', 'horse', 'rubber-duck', 'pizza'] = 9`, was the output from Example 5. What this means is that we passed one argument to `many_args` and this argument is a list of nine strings. We did not pass nine strings as an argument to `many_args`.

To pass a list or tuple as `*args`, we only have to precede the variable name by an asterisk. Try it out and see for yourself.

``````many_args(*largs)

# output of *largs
# candy = 5
# foo = 3
# bar = 3
# swift = 5
# python = 6
# ryder = 5
# horse = 5
# rubber-duck = 11
# pizza = 5

``````

### **kwarg

`**kwarg` stands for keyword arguments. `**kwarg` is basically `*args`, but we pass keys alongside the values. So the values are accessed by the keys. This is sounds like a dictionary, right?.

#### Example 5

``````def many_args(**s):

for key, value in s.items():
print(f"{key}: {value}, has {len(value)} chars")

many_args(title="Swift python", author="Otu Michael",
hobby="Staring at the screen")

``````

Now we can access the values passed, with their keys.

#### passing a dictionary as data

We said lamely, that a dictionary is a key-name pair data structure. Consider the snippet below, where we create a dictionary.

``````dict_data = {
'title': "Swift python",
'author': "Otu Michael",
'hobby': "Staring at the screen"
}
``````

Let's pass `**dict_data` into many_args

``````many_args(**dict_data)

# output
# title: Swift python, has 12 chars
# author: Otu Michael, has 11 chars
# hobby: Staring at the screen, has 21 chars
``````

What will happen when `**` is omitted? Try it out. Does adding a key, solve the issue? What did you notice?

### Default arguments

So what do you think would happen when we don't pass an argument to the function that takes an argument?

Of course an error. We want our functions to "function" with default data so that the function will assume (use) this value when none is passed.

#### Example 6

Let's make use of the `calc_area` function. We would assign a default value to the parameters.

``````def calc_area(base=1, height=1):
return 0.5 * base * height

# passed no args
print(calc_area())  # 0.5

# passed base but not height
print(calc_area(base=12))  # 0.6

# passed height but not base
print(calc_area(height=14))  # 0.7

``````

Here the default parameters are 1.

### Note

• You can do `some_name = func_name` then call, `some_name()`. This will work just like `func_name()`