📓 About This Tutorial

This webpage is a static view of an interactive Jupyter Notebook tutorial. To get the full interactive experience where you can run Python code, modify examples and complete exercises, click the "Open in Colab" button. This will access the Google Colab notebook from a GitHub repository github.com/dchappell2/Computational-Physics and open it in Google Colab. You will need a Google account if you want to open it in Colab.

Note: You can download a pdf of the lecture slides for this chapter here: Chapter 0-3 slides

Chapter 9 - Functions

Goals:

• Explain and identify the difference between function definition and function call.
• Write a function that takes a number of arguments and produces a returned value.

9.0 Break programs down into functions to make them easier to understand.

• People can only keep a few items in working memory at a time.
• Understand larger/more complicated ideas by understanding and combining pieces. Think of components of a car or understanding nature through the division into physics, chemistry, biology and all their subfields.
• Functions serve the same purpose in programs.
• Encapsulate complexity so that we can treat it as a single “thing”.
• Functions also enables re-use: write it once, use it many times.

For example, you might design a program that does data analysis into functional parts:

• read in data
• preprocess data to make it easier to analyse
• perform analysys
• plot results
• save results

Each of these could be their own function (or multiple functions)

9.1 - Define a function using def

• Begin the definition of a new function with def.
• After def comes the name of the function. Function names follow the same rules as variable names (only letters, numbers and underscores; no spaces)
• Then parameters in parentheses. If the function doesn't have any parameters, just use umpty parentheses ().
• All function definitions must end with a colon (like if statements and loops)
• The body of the function comes next and must be indented

Here's an example:

def print_greeting():
    print('Hello!')

• If you run the above cell, you will not see any output. The reason is that you need to call the function to execute it as described in the next section.

9.2 Defining a function does not run it.

• Defining a function does not run it.
• You must call the function to execute the code it contains.
• The implementation of the function is called "the call". The call for the print_greeting function is made by simmply typing the function name followed by a pair of parentheses:

print_greeting()

• After running this code cell, you shoud see the greeting printed under it.
• If you get an error, double check that you ran the code cell above containing the function definition first.

9.3 Arguments in the calling function are matched to the parameters in the definition.

• Functions are most useful when they can operate on different data.
• Specify parameters when defining a function.
• These parameters become variables when the function is executed.
• The parameters are assigned the arguments in the call (i.e., the values passed to the function).
• If you don't name the arguments when using them in the call, the arguments will be matched to parameters in the order the parameters are defined in the function.

🔆 print_date() function

In this example, we define a function to print a date in MM/DD/YYYY format

• The passed parameters are the year, month and day
• In the call to the function we pass the year 1871, the month 3 (for March) and the day 19. The order of these passed parameters matches the order (year, month, day) in the function definition.

Run the code to see the output:

def print_date(year, month, day):
    print(f'{month}/{day}/{year}')

print_date(1871, 3, 19)

• Or, we can name the arguments when we call the function, which allows us to specify them in any order:
• In the following example, we pass the month first instread of the year.

print_date(month=3, day=19, year=1871)

• You can think of the function arguments as the ingredients for the function, while the body contains the recipe.

# your code here

9.4 Arguments can have default values

• You can create a default value by setting the passed parameter equal to a value in the function definition
• Parameters with default values cannot come before parameters without default values, i.e. they must be at the end of the parameter list

🔆 Example: weight() function

This example calculates the weight of an object (in Newtons) given the object's mass.

• An optional second parameter lets the user specifiy the acceleration of gravity if it differs from 9.8 m/s^2

def weight(m,g=9.8):
    return m*g

# weight of a 100 kg mass on Earth
# value of g is not specified (default is used)
# only the mass is passed to the weight() function
W = weight(100)
print(f"weight on Earth = {W:.0f} Newtons")

# weight of a 100 kg mass on the Moon (where g = 1.62 m/s^2)
# both the mass and the value of g are passed to the function
# you could also call the function like this:  weight(100,1.62) without specifying "g="
W = weight(100,g=1.62)
print(f"weight on Moon = {W:.0f} Newtons")

9.5 Functions may return a result using the return command.

• Use return to give a value back to the caller.
• The return command can occur anywhere in the function, but..
• Functions are easier to understand if return occurs either (1) at the start to handle special cases or (2) at the very end, with a final result.

🔆 Example: Kinetic Energy

• This example calculates and returns the kinetic energy of a particle given its mass and velocity.

# define a function to calculate the kinetic energy
# given the mass m and velocity v
#
def KE(m,v):
    return 1.5 * m * v**2

m = 100           # mass in kg
v = 10            # velocity in m/s
my_KE = KE(m,v)   # calculate kinetic energy

print(f'Kinetic energy = {my_KE}')

# your code here

# your code here

9.6 Write functions robustly, so they can handle all the ways a user might use them

• In the previous example we saw that the average() function threw an error if we passed it an empty array.
• Let's modify our function so that it can handle empty arrays.
• We'll test to see if the length of the passed list is zero and return a None if it is.

🔆 Average() function

• Here's our function that takes the average of a list of numeric values
• It checks to make sure the list isn't empty by making sure the length of the list is > 0
• If the passed list is empty, the function will return None instead of a numeric value

def average(values):
    if len(values) == 0:              # check to see if passed array is empty
        return None
    return sum(values) / len(values)

print('average of empty list:', average([]))

• Every function returns something.
• A function that doesn't explicitly return a value automatically returns None.

9.7 Use functions to modularize your code

It is tempting to just start writing the final version of your code that does everything you want. However experience suggests that (for all except the simplest programs) it is better to break your code into pieces and test each piece before combining them together into your final program.

• This philosophy is like experimental physics: only vary one variable at a time
• It is much harder to debug a program that has multiple errors instead of just one.
• Writing functions to handle dedicated tasks allows you to fully test each function before combining them into more complex applications

Here's an example that shows how a function can help simplify code:

🔆 Example: Spring Force

The function spring_force() calculates the force in 3D space applied by a spring with spring constant k. In vector form, the spring force is given by

$\vec{F}=-k(\vec{r}-\vec{r}_0)$.

Passed parameters:

• r0 = NumPy array containing x, y, z components of position where the spring is anchored
• r = NumPy array containing x, y, z components of the other end of the spring (where the force is calculated)
• k = spring constant

Returned array:

• F = NumPy array containing x, y, z components of the force exerted by the spring

import numpy as np

def spring_force(r,r0,k):
    d = r-r0                 # vector displacement of spring (r0 to r)
    F = -k*d                 # vector force acting on point r
    return F

r  = np.array([1,1,0])       # 3D position of end of spring
r0 = np.array([0,0,0])       # 3D position where spring is anchored
k  = 2                       # spring force

F0 = spring_force(r,r0,k)    # calculate and print the spring force
print("force = ",F0)

Running this code shows that the spring pulls the free end, down and to the left (both x and y are negative).

We can now use our spring function to add a second spring at (2,0,0) and calculate the net force.

• This time, we'll pass the position vector of the second spring's anchor [2,0,0] directly to the function.

# Calculate force from a second spring
F1 = spring_force(r,[2,0,0],k)

# add the two spring forces to get net force
Fnet = F0 + F1

print("first force  = ",F1)
print("second force = ",F1)
print("net force    = ",Fnet)

• We see that the second force pulls down and to the right.
• The net force pulls straight down since the x components of the first two forces cancel

#  Your code here

import numpy as np

# noisy_sin() function returns a noisy sine wave
#
# passed parameters:
#    SNR     = signal-to-noise ratio
#    N       = number of data points
#    tmax    = maximum time
#    P       = period of sine wave
#    A       = amplitude of sine wave
#    verbose = flag to print statistics about the generated wave
#
# returned parameters:
#    data    = 2D array where: column 1 = time values,
#                              column 2 = noise sine wave values
#


# your code here

Key Points

• Break programs into functions to make them easier to undertsand
• Functions are created with a def statement, and the body is indented
• Defining a function does not run it. You need to call the function once it is defined
• Arguments in the calling function are matched to the parameters in the definition
• Alternatively, if you name the arguments when you call the function, you can pass them in any order
• Functions may return a result using the return statement
• Write functions robustly, so they can handle all the ways a user might use them
• Use functions to modularize your code

This tutorial is an adaptation of "Python for Physicists"

© Software Carpentry