-ORIENTED

Feature
automatically. It creates a separate set of dice for each of
our players.
The ‘self’ bit also needs explaining. Variables, like
our dice = [] list are normally disposed of when a
function ends (or is returned).
So if we just put dice = [], the list would be created
by __init__(), then immediately vanish.
Python gets around this problem using the keyword
‘self’. You put ‘self’ inside the parentheses of the
__init__():
An object’s functions are called ‘methods’, but they
are created in the same way.
here re ot o dierent type o method nd you
can create whatever you like, but common ones are
called ‘setters’ and ‘getters’.
Our roll method is a ‘setter’. It sets the dice list to
three random numbers.
What do you think a ‘getter’ does? That’s right. It
gets the variables inside the object and returns them.
We have just the one getter:
dene
Then we use self, followed by a dot, to store the
variable in this version of the object.
ede
You then use e in functions when you want to
access or change a variable, by writing self inside the
parentheses of the function. Like this:
dee
The concept can be mind-boggling (it’s passing a
version of itself into itself). So focus on the practical
steps rather than the esoteric theory of how it works:
deedee
enede
etter nd etter eem it odd t firt. ter
all, you could just reach into an object and access
the variables.
Well, you could, at least in Python, but this is
considered a bad thing to do. One of the points of OOP
is that objects contain their variables and keep them
safe from other objects. So you don’t just reach inside
an object and access variables.
Instead, you create methods (functions) that set the
variables and get them. Then you use these methods
to set and get variables.
ow weve reted our definition we n ue it
to create objects.
• Put a special function at the start of a class called
__init__(self).
• Put the variables you want to use inside init.
• Create the variables with e, like ene
or ee or ede = [].
• Place self inside the parentheses of functions that
need to access the variables.
• Use e and the name of the variable inside
the function to use it.
Got that? Don’t worry too much if it seems weird.
That’s the hardest part and it will get easier with practice.
Now we’ve got our dice list sorted, what about the
other functions?
Methods in the madness
Now that our class has a list for the dice, we need
to ro the die. or tht we rete more regur
untion definition.
Create away
You create objects just as you would a variable. You
use the assigns operator (=). We’re going to create two
dice players:
ee
ee
Note that e and e are not called
‘variables’. They are called ‘object instances’.
We access the object instance’s methods using dot
notation. That is where you use the name of the object
instance, followed by a dot, then the name of the
method you want to use.
We created a method, get_dice(), that returns
the dice stored. We would access this method using
dot notation, such as eede.
irt we ue the roll method to get each player
object to roll its dice:
e
e
dee
deenende
nne
edeendndn
The rest of our bunco_oop.py program is really
very similar to bunco_procedural.py. he dierene
is that here we use the ede method in
place of .
72 February 2017
raspberrypi.org/magpi