Introduction to Functions

cereal = pd.read_csv('data/cereal.csv')
cereal.head()

	name	mfr	type	calories	...	shelf	weight	cups	rating
0	100% Bran	N	Cold	70	...	3	1.0	0.33	68.402973
1	100% Natural Bran	Q	Cold	120	...	3	1.0	1.00	33.983679
2	All-Bran	K	Cold	70	...	3	1.0	0.33	59.425505
3	All-Bran with Extra Fiber	K	Cold	50	...	3	1.0	0.50	93.704912
4	Almond Delight	R	Cold	110	...	3	1.0	0.75	34.384843

5 rows × 16 columns

addition = sum([1, 2, 3, 4, 5])
addition

15

Functions may feel like we are introducing something new, but we have been using them for the last 4 and a half modules.

Back in Module 1, we compared functions and methods to verbs as they both complete actions.

pd.read_csv() is a function which reads in a dataframe.

And sum() is a function that adds all the values in a list.

Functions and the DRY principle

numbers = [ 2, 3, 5]
squared = list()

squared.append(numbers[0] ** 2)
squared.append(numbers[1] ** 2)
squared.append(numbers[2] ** 2)
squared

[4, 9, 25]

squared = list()
for number in numbers: 
    squared.append(number ** 2)
squared

[4, 9, 25]

In the last section, we discussed how loops helped avoid redundant code.

We wrote code, which created a new list containing the square of the elements.

Using a loop for this helped our coding style somewhat, but now we have a new problem.

What happens if we want to do the same process to multiple lists all named differently?

larger_numbers = [5, 44, 55, 23, 11]
promoted_numbers = [73, 84, 95]
executive_numbers = [100, 121, 250, 103, 183, 222, 214]

Perhaps I have 3 other lists that I want to do the same operations on?

larger_numbers_squared = list()
for number in larger_numbers: 
    larger_numbers_squared.append(number ** 2)
larger_numbers_squared

[25, 1936, 3025, 529, 121]

even_larger_numbers_squared = list()
for number in promoted_numbers: 
    even_larger_numbers_squared.append(number ** 2)
even_larger_numbers_squared

[5329, 7056, 9025]

extra_larger_numbers_squared = list()
for number in executive_numbers: 
    extra_larger_numbers_squared.append(number ** 2)
extra_larger_numbers_squared

[10000, 14641, 62500, 10609, 33489, 49284, 45796]

Now I will have to repeat the same code just so it applies to these lists too.

This definitely violates the DRY principle. The question now is “Is there a better way?” and luckily, there is!

squared = list()
for number in numbers: 
    squared.append(number ** 2)
squared

def squares_a_list(numerical_list):
    new_squared_list = list()
    
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    
    return new_squared_list

numbers = [ 2, 3, 5]
squares_a_list(numbers)

[4, 9, 25]

We have the ability to make our own function and use them just like how we use functions like pd.read_csv() and len().

We can convert the code in the last slide into our very own function and use it like we use Python built-in ones.

We can call our new function using the same syntax as a Python built-in function too.

Syntax

def squares_a_list(numerical_list):
    new_squared_list = list()
    
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    
    return new_squared_list

Let’s take a look at the how we define a function:

Let’s take a look at how we define a function:

• def is a python keyword that tells Python that anything indented after this belongs to a function.

• Next, we give it a Function name. Like any object, we need to name it.

  • In this case, we have named our function squares_a_list.
    
  • We cannot name it any existing function names.

• Following our function name, we specify any Parameters/Arguments that the function requires.

  • Python calls these “parameters”; however, we have been calling these “arguments”.
    
  • This is what the function needs as an input in order for us to perform some actions on an existing object.
    
  • We can have multiple parameters or no parameters at all.
  • In our function, we have a single parameter named numerical_list.

• Lastly, we end the line with a Colon

  • Just like loops and conditionals, a function required its first defining line to end with a colon.

def not_a_great_function(numerical_list):
    new_squared_list = list()
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    new_squared_list

not_a_great_function([1, 2, 3])

In the body of a function, all the code is indented 4 spaces and further indented for loops and conditions.

The return statement is crucial to a function for returning the desired output.

In our previous function, a new list was returned.

If the function does not return anything, then you won’t get a value to assign to an object.

It does all the work, but never sends the result back to the code that called it.

(See no value is returned when we call it!)

def squares_a_list(numerical_list):
    new_squared_list = list()
    
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    
    return new_squared_list

We can now call this function and specify each of our lists of interest as the input argument:

• numbers.
• larger_numbers
• promoted_numbers
• executive_numbers

numbers = [ 1, 2, 3, 4]
squares_a_list(numbers)

[1, 4, 9, 16]

larger_numbers = [5, 44, 55, 23, 11]
squares_a_list(larger_numbers)

[25, 1936, 3025, 529, 121]

promoted_numbers = [73, 84, 95]
squares_a_list(promoted_numbers)

[5329, 7056, 9025]

executive_numbers = [100, 121, 250, 103, 183, 222, 214]
squares_a_list(executive_numbers)

[10000, 14641, 62500, 10609, 33489, 49284, 45796]

This function is now recycled on all of our lists and meets the DRY principle.

numbers = [ 1, 2, 3, 4]
larger_numbers = [5, 44, 55, 23, 11]
promoted_numbers = [73, 84, 95]
executive_numbers = [100, 121, 250, 103, 183, 222, 214]

for list_of_numbers in [numbers, larger_numbers, promoted_numbers, executive_numbers]:
    print(squares_a_list(list_of_numbers))

[1, 4, 9, 16]
[25, 1936, 3025, 529, 121]
[5329, 7056, 9025]
[10000, 14641, 62500, 10609, 33489, 49284, 45796]

We could get even more fancy and put all the lists into one large list (so now you have a list of lists).

Then you could loop over the list and call the function each time.

This example leads us to our next point.

Just because we could do this doesn’t necessarily mean we should.

Designing Good Functions

There is some ambiguity for how and when to design a function.

• Should squares_a_list() be a function if I’m only ever using it once?
• Should the loop be inside the function, or outside?

def squares_a_list(numerical_list):
    new_squared_list = list()
    
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    
    return new_squared_list

There is some ambiguity for how and when to design a function.
For instance:

• Should squares_a_list() be a function if I’m only ever using it once? What about Twice?
• Should the loop be inside the function, or outside?

This comes down to personal opinion.

Some may say that the function squares_a_list() does a bit too much to keep things understandable.

Designing effective functions will be discussed in Module 6.

Let’s apply what we learned!