2b: Functions in Python

A function is a sequence of statements that will be executed once it is invoked/called.

Python has some built-in functions. For example:

• Checking the data type of a variable:
  • type()
  • isinstance()
• Turning variables into a specific data type:
  • int()
  • float()
  • str()
• Many others:
  • abs()
  • pow
  • round()
  • len()
• With sequences (which we will treat later):
  • max()
  • min()

var1 = type(True)
var1 = isinstance(True, bool)

var1 = float(5)

print(var1)

print(type(var1))

print(abs(-4))

# doing the same thing
print(2**3)
print(pow(2,3))

print(round(3.51))

#length of string
print(len("hi"))

list1 = [1, 2, 5, 9]

print(max(list1))
print(min(list1))

A function takes one or more arguments.

It is important to seperate the arguments with a comma.

var1 = pow(2,3)

print(var1)

Remember that one of you "discovered" this functionality of the functin "print" last Tuesday.

print("this", "class", "has", "many", "students", sep = "?")

Some functions only take arguments of a particular kind:

print(int("hello"))

In Spyder, you can use ctrl+i (with cursor on function) to get more information on the function.

Many commonly used functions are available in external modules.

A module is a file that contains a collection of functions.

They become accesible after importing the appropiate module with the following syntax:

import module

All functions in a module are available, but we need to prefix them with the name of the module (and a dot) to identiy their source.

import math

print(math.cos(10))

You can also import a few objects from the module:

from math import pi

print(pi)

(This does not work)

print(pi)

Important: by convention, import-statements are at the very top of a program.

A function might or might not "return" a value.

A function that does not return a value, is called void.

A function that does yield results are sometimes called 'fruitful'.

Remember the difference between an expression and a statement.

A piece of code that runs a fruitful function is an expression: it produces a value.

A piece of code that runs a void function is a statement: it does not produce a value.

You can save the output of fruitful function in a variable. For a void function that would not make sense.

The basic format for creating your own function in Python is:

def <function_name>(<parameters>):
    <statement>
    ...
    <statement>

In the definition of a function, the input variables are called parameters. When executing the function, the variables that you feed to the function are called arguments.

You can say that the parameters (within the function) receive their values when the function is called with an actual argument.

The collections of statements is called block. In Python, a block is marked by indentation, and announced by a colon (:).

def doge_function(s):
        return len(s)

def doge_function(s):
    if "DEI" in s:
        print("delete document")

var1 = doge_function("The FAPdei is the main document in the AUC that describes how, as a community we deal with issues of diversity, inclusivity and equity")        

print(var1)
print(type(var1))

Is this a void or a fruitful function?

A fruitful function returns a value. To do this you use the keyword <return>:

from math import pi

def surface_circle(r):
    surface = 2 * pi * r**2
    return surface

var1 = surface_circle(3)
print(var1)

Important: the position of the arguments determines to which parameter they are assigned.

from math import pi

def surface_cilinder(r,h):
    top = 2 * pi * r**2
    bottom = 2 * pi * r**2
    side = 2 * pi * r**2 * h
    return top+bottom+side

radius = 3
height = 2

var1 = surface_cilinder(height, radius)

print(var1)

Most programming languages distinguish local from global variables.

Global variables: are available to the entire program.

Local variables: are only visible inside the block where they are declared.

The program part in which a variable can be used, is called the scope of that variable.

By assigning a value to a variable in the block (‘body’) of a function definition, a local copy of that variable is created in the function. This copy is only available within that function.

from math import pi

def surface_cilinder(r,h):
    top = 2 * pi * r**2
    bottom = 2 * pi * r**2 #<- declared within the function. Local variable. Only available within the function
    side = 2 * pi * r**2 * h
    radius = "blablabla"
    print("Inside the function: bottom =",bottom)
    print("Inside the function: radius =",radius)
    return top+bottom+side

radius = 3 #<- declared outside the function in the main program. Global variable. Available everywhere.
height = 2

var1 = surface_cilinder(radius, height)

print("Outside the function: radius =", radius)
print("Outside the function: bottom =", bottom)

There are several reasons to build a program composed of several functions that work together.

• Breaking the program into functions make the program easier to read and debug
• Help to eliminate/reduce repetitive code
• It is easier to debug independent functions, one by one, and then assemble them all toegther.
• Functions can be reused in the same code or in other programs.