What is your Function?

• As discussed in the context of Karel, a function is a sequence of commands that have been collected together and given a name.
• Unlike in Karel though, functions typically go beyond that and can have inputs and outputs
• At times we are concerned about what happens in the function, but at other times we can treat it as a mysterious “black-box”

Writing your own functions

• The more general form of a function definition looks like:

  def |||name|||(|||parameters|||):
      |||statements in function body|||

  • |||name||| is your chosen name for the function
  • |||parameters||| is a comma-separated list of variable names that will have each input value assigned to them

• You can return or output a value from the function by including a return statement in the function body

  return |||some expression|||

  • |||some expression||| is the value you want to return or output
  • If no return statement is included, Python will by default return None

A Functional Diagram

Simple function examples

• Convert Fahrenheit temperatures to their Celsius equivalent

  def f_to_c(f):
      return 5 / 9 * (f - 32)

  • Using the function:

    print(f_to_c(45))

• Computes the volume of a cylinder of height h and radius r

  def cylinder_volume(r, h):
      return 3.14159 * r**2 * h

  • Using the function:

    vol1 = cylinder_volume(2,10)
    vol2 = cylinder_volume(10,2)
    print(vol1 + vol2)

Using Functions: Built-ins

• All modern languages include a collection of pre-defined functions for convenience
• In Python, common build-in functions that operate on numbers include:

Visiting the library(ies)

• A huge strength of Python is that it offers a very large number of code collections called libraries
  • Can save you the effort from writing that code yourself!
• Requires you to import that library, which can take several different forms

  • Most common is to use import |||lib||| to grab everything in a library

    import math

    • You must then access any function in that library using its fully qualified name, which includes the library name (var = math.sqrt(4))

  • Can also use from |||lib||| import |||function||| to grab specific functions from the library

    from math import sqrt

    • You do not need to use the library name then when you call it (var = sqrt(4))

Useful math definitions

Python’s Path

• Wherever possible, Python runs code one line at a time, from top to bottom

• It will not, however, enter indented blocks unless it has to

  • The code inside a function definition, for example, is only run when the function is called

• A common paradigm then is to define functions first, and then include the code to run those functions beneath

  def func1(a):
      return a + 1
  
  def func2(b):
      return b // 2
  
  print(func1(2) + func2(2))

Collections on Constants and Functions

• A library should generally just be a collection of defined functions and constants
  • You don’t want any code to actually run when you import the library, you just want to access the desired pieces
• If you place everything inside a function definition though, nothing actually happens when you run the library code!
  • You just defined a bunch of functions, but never did anything with them
• Commonly, we want the best of both worlds:
  • I can use a program easily as a library, if I want to import a defined function
  • I can run the program directly and have something actually happen

Running a Program

• Karel programs always run the first defined function in the code when the program was run. General Python programs do not follow the same convention.

• Python programs need to specify what part of the code is supposed to be executed when a program is run if everything is just function definitions. This commonly happens at the bottom of the program:

  if __name__ == '__main__':
      |||function_to_run()|||

  • |||function_to_run||| is the name of whatever function you want to execute when the program is run directly

• Patterns of this sort are commonly called boilerplate

  • Less important to fully understand all the pieces of it now
  • Is important to understand what it is doing and how to implement it correctly

Sample Program

def print_odds(des_num):
    """
    Prints the first desired number of odd numbers 
    starting from 1.
    """
    value = 1
    for i in range(des_num):
        print(value)
        value += 2

if __name__ == '__main__':
    print_odds(100)

Practice

• Most people have seen or had to memorize the quadratic formula at some point in time. As a reminder, the equation \[a\cdot x^2 + b\cdot x + c = 0\] can be solved for \(x\) according to \[x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]
• Take some time with a neighbor to work out how you could define a function quad which takes 3 arguments a,b,c and returns the greater of the two solutions (the \(+\) one)
  • Tip: writing out complicated equation on a single line in Python can get real ugly and hard to understand. Consider breaking up the equation and assigning pieces of it to variables that you can combine later.