O

Functions

Functions are one of the cornerstones of programming. They provide a way to reuse code. If you’ve ever copy-pasted lines of code just to change a few parameters, then turning those lines of code into a function not only makes your code more readable but also prevents you from making mistakes later on. Every time code is copy-pasted, it adds another place to look if a correction is needed, and puts that burden on the programmer. When you use a function, you need to make a correction only once, and it will be applied every time the function is called.

I highly suggest the Software-Carpentry Python episode on functions for more details.¹ An empty function looks like this:

1. https://swcarpentry.github.io/python-novice-inflammation/08-func/index.html

def empty_function():
  pass

The function begins with the def keyword, then the function name (i.e., how the function will be called and used), a set of round brackets, and a colon. The body of the function is indented (one tab or four spaces). This indentation is extremely important. If you omit it, you will get an error. In this example, pass is used as a placeholder to do nothing.

Typically functions will have what’s called a “docstring”—a multiple-line comment that describes the function’s purpose, parameters, and output, and that sometimes contains testing code. When you look up help documentation about a function in Python, the information contained in the function docstring is usually what shows up. This allows the function’s documentation and code to travel together, which makes the documentation easier to maintain.

Click here to view code image

def empty_function():
  """This is an empty function with a docstring.
  These docstrings are used to help document the function.
  They can be created by using 3 single quotes or 3 double quotes.
  The PEP-8 style guide says to use double quotes.
  """
  pass # this function still does nothing

Functions need not have parameters to be called.

Click here to view code image

def print_value():
  """Just prints the value 3
  """
  print(3)

# call our print_value function
print_value()

3

Functions can take parameters as well. We can modify our print_value() function so that it prints whatever value we pass into the function.

Click here to view code image

def print_value(value):
  """Prints the value passed into the parameter 'value'
  """
  print(value)

print_value(3)

3

print_value("Hello!")

Hello!

Functions can take multiple values as well.

Click here to view code image

def person(fname, lname):
  """A function that takes 3 values, and prints them
  """
  print(fname)
  print(lname)

person('Daniel', 'Chen')

Daniel
Chen

The examples thus far have simply created functions that printed values. What makes functions powerful is their ability to take inputs and return an output, not just print values to the screen. To accomplish this, we can use the return statement.

Click here to view code image

def my_mean_2(x, y):
  """A function that returns the mean of 2 values
  """
  mean_value = (x + y) / 2
  return mean_value

m = my_mean_2(0, 10)
print(m)

5.0

def my_mean_3(x, y, z=20):
  """A function with a parameter z that has a default value
  """
  # you can also directly return values without having to create
  # an intermediate variable
  return (x + y + z) / 3

print(my_mean_3(10, 15))

15.0

print(my_mean_3(0, 50, 100))

50.0

def my_mean(*args):
  """Calculate the mean for an arbitrary number of values
  """
  # add up all the values
  sum = 0
  for i in args:
      sum += i
  return sum / len(args)

print(my_mean(0, 10))

5.0

print(my_mean(0, 50, 100))

50.0

print(my_mean(3, 10, 25, 2))

10.0

def greetings(welcome_word, **kwargs):
  """Prints out a greeting to a person,
  where the person's fname and lname are provided by the kwargs
  """
  print(welcome_word)
  print(kwargs.get('fname'))
  print(kwargs.get('lname'))

greetings('Hello!', fname='Daniel', lname='Chen')

Hello!
Daniel
Chen