Core Python Programming (2nd Edition)

chapter, these attributes really are dynamic in nature: you do not need to pre-declare or pre-assign
them in the constructor or anywhere else.
Methods
One way we can improve our use of classes is to add functions to them. These class functions are known
by their more common name, methods. In Python, methods are defined as part of the class definition,
but can be invoked only on an instance. In other words, the path one must take to finally be able to call
a method goes like this: (1) define the class (and the methods), (2) create an instance, and finally, (3)
invoke the method on that instance. Here is an example class with a method:
class MyDataWithMethod(object): # define the class
def printFoo(self): # define the method
print 'You invoked printFoo()!'
You will notice the self argument, which must be present in all method declarations. That argument,
representing the instance object, is passed to the method implicitly by the interpreter when you invoke
a method on an instance, so you, yourself, do not have to worry about passing anything in (specifically
self, which is automatically passed in for you).
For example, if you have a method that takes two arguments, all of your calls should only pass in the
second argument. Python passes in self for you as the first. If you make a mistake, do not worry about
it. When an error occurs, Python will tell you that you have passed in the wrong number of arguments.
You may make this mistake only once anyway... you'll certainly remember each time after that!
The requirement of the instance (self) in each method's signature will be something new to those of
you coming from C++ or Java, so be aware of that. It is all part of Python's philosophy of being
explicitly clear. In those other languages, self is called "this." You can find out more about self in the
Core Note in Section 13.7 on page 540. Requiring the instance only applies to regular methods and not
static or class methods, although the latter requires the class rather than the instance. You can find out
more about static and class methods in Section 13.8 on page 542.
Now we will instantiate the class and invoke the method once we have an instance:
>>> myObj = MyDataWithMethod() # create the instance
>>> myObj.printFoo() # now invoke the method
You invoked printFoo()!
We conclude this introductory section by giving you a slightly more complex example of what you can do
with classes (and instances) and also introducing you to the special method __init__() as well as
subclassing and inheritance.
For those of you who are already familiar with object-oriented programming, __init__() is similar to the
class constructor. If you are new to the world of OOP, a constructor is simply a special method that is
typically called to create a new object. In Python, __init__() is not really the constructor. You do not
call "new" to create a new object. (Python does not even have a keyword called "new" anyway.) Instead,
Python creates the instance for you and then calls __init__() during instantiation to define additional
behavior that should occur when a class is instantiated, i.e., setting up initial values or running some
preliminary diagnostic codebasically performing any special tasks or setup after the instance is created
but before the new instance is returned from the instantiation call.