Computer Brains and Python Functions

Intro to Robots
Computers are useless tools.
But given a program to run they
become highly specialized and
useful tools.

Intro to Robots
Computers, Robots and Python

• There is a close relationship between computers and

robots.
• Python can be used to program both.
• We are working with a robot but really learning to
program computers in general.
• Programming a robot is much like “wiring” its brain.
• Wiring a brain is much like actually creating a brain.
• Programming a robot is giving it a brain. But a brain that
only knows how to do one thing.
• Remember Homer Simpson.

Intro to Robots
How do Robots Think?

• Imagine a robot that operates a Zamboni machine.

• Imagine your own brain on “automatic pilot” when you
are mowing the lawn.
• Imagine a robot vacuum cleaner that cleans the floor in a
room empty of furniture.

...

Intro to Robots
Possible Work Algorithms:

• Distance:
M = width of robot
L = outside length of surface area
W = outside width of surface area
D = distance to travel in a straight line

point robot along longest side

D=L each time the machine proceeds
travel in a straight line distance D
while W > 0:
along one side, the length to travel
if D == L : is reduced by one robot width.
W = W – M; D = W
else:
L = L – M; D = L
turn left 90 degrees
travel in a straight line distance D

Intro to Robots
Possible Turning Algorithms:

• Timing:
M = time to travel width of robot
L = time to travel outside length of surface area
W = time to travel outside width of surface area
D = time to travel in a straight line

point robot along longest side

D=L
travel in a straight line for time D
while W > 0:
if D == L : NOTE: This algorithm is very
W = W – M; D = W similar to the previous. This is
else: because there is such a strong
L = L – M; D = L relationship between distance
turn left 90 degrees and time that knowing one often
travel in a straight line for time D determines the other.

Californian: How far do you live from New York City?

New Yorker: I live 90 minutes from New York City.
Californian: You tell me how far away it is and I’ll
tell you how long it will take me to get there.

Intro to Robots
Possible Turning Algorithms:

• Cleanliness:
# This algorithm requires a sensor on the left side of the robot to determine
# if the work surface to the left of the robot has been processed

point robot along one side

travel in straight line
while sensor detects unprocessed surface:
turn left
travel in a straight line

NOTE: This algorithm is simpler than the other algorithms

because the robot is more complex (it has a “dirt” sensor).
In general, programs that have a complicated set of variables
are simpler than programs that try to do everything with program
code.

Intro to Robots
Python Program Structure:

• It is common to start every program by calling a function

called main().
def main():
<do something> # perhaps a function call
<do something> # perhaps a function call
<do something> # perhaps a function call

...

main()

• There is really no difference between main() and any

other function. It is just custom that makes a program
begin with main().

Intro to Robots
Python Program Structure:
every robot program starts
with this.
from myro import *
# import other modules

initialize('com4')

# define extra functions you may need

def main():

# do something
...

main()

Intro to Robots
Function Calls:

• Recall
>>> type(“32”)
<type ‘string’>

• type() is a function
– Its name is type
– You can pass an argument that can be any expression
– Entering the name, followed by an expression in
parentheses is called “calling the function” or a
“function call”.
– Function calls “return” a value; in the case of type() the
value is a “type” object that prints out as:
<type ‘type_name’>

Intro to Robots
Another Type Example:

The type(type) is a <type ‘type’>

Intro to Robots
The id() function:

• Every object has a unique identifier called its id.

• In this example 3, x, y and z are all the same object with

the same id.

Intro to Robots
Converting from one Type to Another:

• We know 32 is an integer and “32” is a string but

int(“32”)

is an integer and
str(32)

is a string

Intro to Robots
Converting from one Type to Another (cont):

• You can’t convert what doesn’t match

Intro to Robots
Converting from one Type to Another (cont):

• Converting is a way of truncating the decimal part of a

floating point number. This is NOT the same as
rounding.

Intro to Robots
Converting from one Type to Another (cont):

• Automatic type conversion is called type coercion.

integer division

floating point division forced on

Python by the real operand;
called type coercion.

Intro to Robots
Modules:

• A module is a file containing many definitions.

• It usually has the file extension .py.
• myro is a module.
• To use the contents of a module you must “import” it.
import myro # must use “dot notation” to use functions
from myro import * # don’t need the “dot notation” to use functions

• “Dot Notation” means naming things with both module

and function name
module name.function name

• Dot notation is much like the naming conventions for

Internet names www.newpaltz.edu
www.vassar.edu

Intro to Robots
Math Functions:

• Math functions are found in the module called math.

• You can use them if you “import math”.

dot notation
module name.function name

Intro to Robots
Math Module contents:

• In addition to pi, the math module contains trig functions

like sine (sin()) and cosine (cos()), absolute value
(abs()), square root (sqrt()) as well as various log and
exponentiation functions.

Intro to Robots
Other useful Functions:

• Python has a useful function called range().

Intro to Robots
Versions and Uses of range([start],stop,[step]):

• range(10) # returns [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• range(4,10) # returns [4, 5, 6, 7, 8, 9]
• range(5,7,0.3) # returns [5, 5.3, 5.6, 5.9, 6.2, 6.5, 6.8]
• range(5,-4,-2) # returns [5, 3, 1, -1, -3]

• If L is a list/sequence object then

L.slice([start],stop,[step])
returns the elements of L with indexes
returned by range([start],stop,[step])
Alternative notation:
L[start:stop:step]

http://docs.python.org/library/functions.html

Intro to Robots
Slicing Lists and Other Things:

• L[negative] indexes the list from the end starting at -1.

• L[1:3] is a new list consisting of [L[1], L[2], L[3]]. With the
third argument missing, the default value for step is 1.
• L[1:] is a new list consisting if [L[1], ... ]
• L[:] is the entire list
• L[2:-1] is the new sublist [L[2], ..., L[-2]] and does not
include the last element
• L[3:3] is an empty sublist just before L[3]. We can assign
to it:
L[3:3] = [a,b,c] inserts a new sublist just before L[3]

http://www.diveintopython.org/native_data_types/lists.html
Intro to Robots
More List Stuff

starting at the second last

element in the list and stepping
L = [1,2,3,4,5,6,7]
down by 2, stopping before
M = L[-2:-7:-2]
L[-7] == L[0]
print M
N = L[1:-1:2]
print N Observation:
If len(L) == n and -n <= a <= -1
[6, 4, 2] then L[a] is really L[n+a]
[2, 4, 6]
Exercise: Write a python function that returns a list
in reverse order.

def rev(L):
stop = -1*len(L)-1
return L[-1:stop:-1]

Intro to Robots
Defining Functions:

• General Syntax:
def function_name (list of parameters):
statements # indented

• A function is a named sequence of statements that do

something desired.
• You can’t use any of the 28 key words as function
names.
• You can put the function definitions anywhere you want
but you must define a function before you use it.
• Until now, most of the functions we have used have
been defined for us in modules like myro.

Intro to Robots
More Functions:

def newline():
print

• Defining newline() gives a “mneumonic” name for an

activity. print does the same thing but is less intuitive.
• print is a key word, not a function, so doesn’t need ().
• A programmer might call newline() by a different name,
nl().
def nl():
print

Intro to Robots
Functions of functions:

• You can use functions to define others:

def threeLines():
nl()
nl()
nl()

• Alternative definition:
This is called a for-loop. A variable, i,
def threeLines(): takes on every value in range(3), which
for i in range(3): we know to be the list [1,2,3].
nl() We don’t actually use the value of i but
we could, inside the for-loop block.

Intro to Robots
For Loop:

• General Format
for <variable> in <sequence>:
do something
do something
...

• For loops are used when you want to do the same thing
over an over again and you know how many times in
advance.

Intro to Robots
Exercise:

• Write a function, using a for loop, that will call newline() n

times, where n is the function parameter.
def newLines(n):
for i in range(n)
nl()

Intro to Robots
Intro to Robots
Exercise:

• Write a function that prints out 9 lines.

def nineLines():
threeLines()
threeLines()
threeLines()

• Now write a function that prints out 27 lines.

def twentySevenLines():
nineLines()
nineLines()
nineLines()

Intro to Robots
Intro to Robots
Name this function:

Intro to Robots
Execution flow: # happy_birthday_2.py
from myro import *

def getName():
#happy_birthday_1.py return ask("Whose birthday is it? ")
from myro import *
def happyBirthday(name):
name = ask("Whose birthday is it? ") print "Happy Birthday to you,"
print "Happy Birthday to you,"
print "Happy Birthday to you," print "Happy Birthday to you,"
print "Happy Birthday to you," print "Happy Birthday dear", name+’,’
print "Happy Birthday to you," print "Happy Birthday to you."
print "Happy Birthday dear", name+’,’
print "Happy Birthday to you." def getAgeOf(name):
return ask("How old are you, "+name)
age = ask("How old are you, "+name)
# same program with function calls
print name, "is", age, "years old." def main():
bd_name = getName()
happyBirthday(bd_name)
NOTE: These programs have the age = getAgeOf(bd_name)
same execution flow but one is easier print name, "is", age, "years old.“
to read than the other.
main()

Intro to Robots
Parameters and Arguments:

• In the previous example name is a parameter and

bd_name is an argument.
• You pass arguments to parameters
parameter, part of definition

def happyBirthday(name):
print "Happy Birthday to you,"
print "Happy Birthday to you,"
print "Happy Birthday to you,"
print "Happy Birthday dear", name+’,’
print "Happy Birthday to you."

...

happyBirthday(bd_name)
argument, part of function call

Intro to Robots
Parameters and Arguments (cont):

• Imagine a bakery that bakes birthday cakes and on the

top of each cake they write
Happy Birthday
To

• How much more useful is such a cake than one that

says
Happy Birthday
To
Hugo

• Parameters are used when we write the function and

arguments are used when we use the function.
• Why? Because we don’t know when we write the
function precisely what arguments it will use when we
use the function.

Intro to Robots
Parameters and Arguments (cont):

• That space on the top of the cake when the name will go
is just like the parameter name in the definition of a
function. It is a place where we can “plug in” an
argument value when we want to use the function.
• For that reason, function parameters are often called
place holders.
• The name of the argument can be anything. You can
write anyone’s name on a blank birthday cake.

Intro to Robots
Exercise:

• Think of other situations where we use “place holders” in

our daily lives.
– Order a Pizza
– Shopping List
– Wedding Vows

Intro to Robots
Parameters:

• A parameter can only be used inside the function

definition where it is mentioned as a parameter.
• If two functions
def x(name):
...

def y(name):
...

x(name) and y(name) have the same parameter this is

just a coincidence.

Intro to Robots
Local Variables:

• Inside a function definition you can use a variable that is

not a parameter. This is called a local variable.
• “Local” because it can only be used inside the function
definition.
def getName():
newName = ask("Whose birthday is it? ")
return newName

• newName can only be used inside getName().

• We say that the definition of getName() is the scope of
newName.

Intro to Robots
Variable Scope

• Variables defined or used for the first time outside any

function have scope from that point in the file until the
end of the file but not inside any function.
• Variables defined or used for the first time inside some
function have scope from that point in the file until the
end of the function definition.
• Variables defined inside the IDLE interface are useable
until you close the IDLE window.
• A variable can be used as long as it is in scope.

Intro to Robots
Using Variables Globally:

• A variable defined outside any function can be referred to

inside a function if it is declared as global inside that
function.

x=1

def a():
global x
y=x+2
return y

print a()

Intro to Robots
Misuse of Variables:

x=1
x=1
local variable, x
def a():
x=4 def a():
return x y=x+2
return y

print a(), x print a()

41 UnboundLocalError

Intro to Robots
Two variables called x:

scope of x is the entire shell

scope of this x is inside the

function called some_function()
and its value is used only if we
call the function

Intro to Robots
The Stack:

error that shows up only when

n is 0

Intro to Robots
Intro to Robots