How you could use parameters so that the behavior of your functions could be slightly different each time you call them. Parameters are also sometimes called arguments.
Start with this example code that draws three plus signs:
def setup():
size(800,500)
rectMode(CENTER)
def draw():
background(255)
fill(155,155,255, 50)
noStroke()
# middle
rect(400,250,200,50)
rect(400,250,50,200)
# left
rect(100,250,200,50)
rect(100,250,50,200)
# right
rect(700,250,200,50)
rect(700,250,50,200)
Then create a function (a.k.a., a subroutine) to allow you to more easily draw this shape. This is based on the new syntax introduced at the end of last week's class.
def plusSign():
fill(155,155,255,50)
noStroke()
rect(400,250,200,50)
rect(400,250,50,200)
You would then call this function (also known as invoking the function) simply by typing the name followed by parentheses. Putting it altogether, it would look like this:
def setup():
size(800,500)
rectMode(CENTER)
def plusSign():
fill(155,155,255,50)
noStroke()
rect(400,250,200,50)
rect(400,250,50,200)
def draw():
background(255)
plusSign()
plusSign()
plusSign()
But if you run this code, you can see that this no longer draws the plus sign in three different locations. Since the function code does the exact same thing each time you call it, the plus sign is drawn in the same location each time. If you look closely at the transparency, you might be able to tell that the shape is a little darker, indicating that it has been drawn on top of itself three times.
What we need is a way to be able to call the function, but have it do something slightly different each time. We achieve this by adding parameters (a.k.a., arguments) to the function definition, like this:
def plusSign(x,y): fill(155,155,255,50) noStroke() rect(x,y,200,50) rect(x,y,50,200)Note that the two variable names inside the parentheses are just words that I made up. I could have written:
def plusSign(spaghetti, meatballs):
# etc ...
and as long as you don't use any reserved Python or Processing
keywords, you can name your function parameters
anything you like.
What this does is create special local variables within the block that is the function definition. In other words, the scope of these variables is limited to this function block. It is as if these variables are created when the function is executed and destroyed when the function completes, and that process is repeated for each invocation of the function.
So what are the values of these arguments? We don't know yet! We don't know what the values of the arguments will be until we call the function. And you specify the values for these arguments when you call the function like this:
plusSign(400,250)
When your function definition
includes parameters, you must specify
the same number of values in parentheses when
you call the function. And when the code of the
function is executed, the values that you specify when calling
the function are plugged in to your parameters
in the order that they are specified. In other words, in this
case, 400 gets assigned to the
first parameter which is x,
and 250 gets assigned to the
second parameter, which in this case
is y. Parameters are a way to
customize the behavior of your functions, so
that every time you run that group of commands, the behavior can
be slightly different.
Putting that all together would look like this:
def setup():
size(800,500)
rectMode(CENTER)
def plusSign(x,y):
fill(155,155,255,50)
noStroke()
rect(x,y,200,50)
rect(x,y,50,200)
def draw():
background(255)
plusSign(400,250)
plusSign(100,250)
plusSign(700,250)
So now the first function invocation draws the middle plus sign,
the second invocation draws the left one, and the third
invocation draws the right one. You can see this for yourself if
you step through the code and when you jump from the function
invocation to the function definition, plug the numerical values
from the parentheses in to the parameter names in the function
definition.
You can use parameters for anything you can use
variables for: the location or size of shapes,
colors, True/False values, or
other state variables.