What is the correct syntax for defining a class called game in Python?

Python is an object-oriented programming language, which means that it provides features that support object-oriented programming ( OOP).

Object-oriented programming has its roots in the 1960s, but it wasn’t until the mid 1980s that it became the main programming paradigm used in the creation of new software. It was developed as a way to handle the rapidly increasing size and complexity of software systems, and to make it easier to modify these large and complex systems over time.

Up to now we have been writing programs using a procedural programming paradigm. In procedural programming the focus is on writing functions or procedures which operate on data. In object-oriented programming the focus is on the creation of objects which contain both data and functionality together.

7.2. User-defined compound types¶

We will now introduce a new Python keyword, class, which in essence defines a new data type. We have been using several of Python’s built-in types throughout this book, we are now ready to create our own user-defined type: the

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Consider the concept of a mathematical point. In two dimensions, a point is two numbers (coordinates) that are treated collectively as a single object. In mathematical notation, points are often written in parentheses with a comma separating the coordinates. For example,

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

A natural way to represent a point in Python is with two numeric values. The question, then, is how to group these two values into a compound object. The quick and dirty solution is to use a list or tuple, and for some applications that might be the best choice.

An alternative is to define a new user-defined compound type, called a class. This approach involves a bit more effort, but it has advantages that will be apparent soon.

A class definition looks like this:

class Point:
    pass

Class definitions can appear anywhere in a program, but they are usually near the beginning (after the

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

This definition creates a new class called

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

By creating the

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

The variable

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

It may be helpful to think of a class as a factory for making objects, so our

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

7.3. Attributes¶

Like real world objects, object instances have both form and function. The form consists of data elements contained within the instance.

We can add new data elements to an instance using dot notation:

>>> p.x = 3
>>> p.y = 4

This syntax is similar to the syntax for selecting a variable from a module, such as

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

The following state diagram shows the result of these assignments:

The variable

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

We can read the value of an attribute using the same syntax:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

The expression

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

You can use dot notation as part of any expression, so the following statements are legal:

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

The first line outputs

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

7.4. The initialization method and class Point: def __init__(self, x, y): self.x = x self.y = y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 0¶

Since our

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

To solve this problem we add an initialization method to our class.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

A method behaves like a function but it is part of an object. Like a data attribute it is accessed using dot notation.

The initialization method is a special method that is invoked automatically when an object is created by calling the class. The name of this method is

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

There is no conflict between the attribute

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Let’s add another method,

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

Let’s create a few point instances, look at their attributes, and call our new method on them:

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

When defining a method, the first parameter refers to the instance being created. It is customary to name this parameter self. In the example session above, the

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

7.5. Instances as parameters¶

You can pass an instance as a parameter to a function in the usual way. For example:

class Point:
    "Point class for storing mathematical points."

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

To convert

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

1. Indent the function definition so that it is inside the class definition.

2. Rename the parameter to

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def distance_from_origin(self):
           return ((self.x ** 2) + (self.y ** 2)) ** 0.5
   

   0.

class Point:
    "Point class for storing mathematical points."

We can now invoke the method using dot notation.

class Point:
    "Point class for storing mathematical points."

The object on which the method is invoked is assigned to the first parameter, so in this case

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

The syntax for a function call,

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

>>> p = Point(3, 4)
>>> p.x
3
>>> p.y
4
>>> p.distance_from_origin()
5.0
>>> q = Point(5, 12)
>>> q.x
5
>>> q.y
12
>>> q.distance_from_origin()
13.0
>>> r = Point(0, 0)
>>> r.x
0
>>> r.y
0
>>> r.distance_from_origin()
0.0

In object-oriented programming, the objects are the active agents. An invocation like

class Point:
    "Point class for storing mathematical points."

>>> p2 = Point()
>>> p2.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'x'
>>>

This change in perspective might be more polite, but it is not obvious that it is useful. In the examples we have seen so far, it may not be. But sometimes shifting responsibility from the functions onto the objects makes it possible to write more versatile functions, and makes it easier to maintain and reuse code.

7.6. Object-oriented features¶

It is not easy to define object-oriented programming, but we have already seen some of its characteristics:

1. Programs are made up of class definitions which contain attributes that can be data (instance variables) or behaviors (methods).

2. Each object definition corresponds to some object or concept in the real world, and the functions that operate on that object correspond to the ways real-world objects interact.

3. Most of the computation is expressed in terms of operations on objects.

For example, the

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

7.7. Time¶

As another example of a user-defined type, we’ll define a class called

class Point:
    "Point class for storing mathematical points."

The class definition looks like this:

class Point:
    "Point class for storing mathematical points."

When we call the

class Point:
    "Point class for storing mathematical points."

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    "Point class for storing mathematical points."

Here is a

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

To save space, we will leave out the initialization method, but you should include it:

class Point:
    "Point class for storing mathematical points."

which we can now invoke on time instances in the usual way:

class Point:
    "Point class for storing mathematical points."

7.8. Optional arguments¶

We have seen built-in functions that take a variable number of arguments. For example,

class Point:
    "Point class for storing mathematical points."

It is possible to write user-defined functions with optional argument lists. For example, we can upgrade our own version of

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

This is the original version:

class Point:
    "Point class for storing mathematical points."

This is the new and improved version:

class Point:
    "Point class for storing mathematical points."

The third parameter,

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

If we provide a third parameter, it overrides the default:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

We can rewrite our initialization method for the

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

When we instantiate a

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Because the parameters are now optional, however, we can omit them:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Or provide only the first parameter:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Or the first two parameters:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Finally, we can provide a subset of the parameters by naming them explicitly:

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

7.9. Another method¶

Let’s add a method

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Now we can invoke

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Again, the object on which the method is invoked gets assigned to the first parameter,

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

7.10. An example with two class Point: "Point class for storing mathematical points." 08s¶

Let’s add a boolen method,

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

We can only convert one of the parameters to

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

We invoke this method on one object and pass the other as an argument:

>>> p.x = 3
>>> p.y = 4

You can almost read the invocation like English: If time1 is after time2, then…

7.10.1. Pure functions and modifiers (again)¶

In the next few sections, we’ll write two versions of a function called

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

The following is a rough version of

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

The function creates a new

class Point:
    "Point class for storing mathematical points."

Here is an example of how to use this function. We’ll create two

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

The output of this program is

class Point:
    "Point class for storing mathematical points."

The problem is that this function does not deal with cases where the number of seconds or minutes adds up to more than sixty. When that happens, we have to carry the extra seconds into the minutes column or the extra minutes into the hours column.

Here’s a second corrected version of the function:

>>> p.x = 3
>>> p.y = 4

Although this function is correct, it is starting to get big. Later we will suggest an alternative approach that yields shorter code.

7.10.2. Modifiers¶

There are times when it is useful for a function to modify one or more of the objects it gets as parameters. Usually, the caller keeps a reference to the objects it passes, so any changes the function makes are visible to the caller. Functions that work this way are called modifiers.

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

The first line performs the basic operation; the remainder deals with the special cases we saw before.

Is this function correct? What happens if the parameter

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

This function is now correct, but it is not the most efficient solution.

7.11. Prototype development versus planning¶

So far in this chapter, we’ve used an approach to program development that we’ll call prototype development. We wrote a rough draft (or prototype) that performed the basic calculation and then tested it on a few cases, correcting flaws as we found them.

Although this approach can be effective, it can lead to code that is unnecessarily complicated – since it deals with many special cases – and unreliable – since it is hard to know if we’ve found all the errors.

An alternative is planned development, in which high-level insight into the problem can make the programming much easier. In this case, the insight is that a

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

When we wrote

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

This observation suggests another approach to the whole problem – we can convert a

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

Now, all we need is a way to convert from an integer to a

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

You might have to think a bit to convince yourself that this technique to convert from one base to another is correct. Assuming you are convinced, you can use these functions to rewrite

class Point:
    "Point class for storing mathematical points."

>>> p.x = 3
>>> p.y = 4

This version is much shorter than the original, and it is much easier to demonstrate that it is correct (assuming, as usual, that the functions it calls are correct).

7.12. Generalization¶

In some ways, converting from base 60 to base 10 and back is harder than just dealing with times. Base conversion is more abstract; our intuition for dealing with times is better.

But if we have the insight to treat times as base 60 numbers and make the investment of writing the conversion functions (

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

It is also easier to add features later. For example, imagine subtracting two

class Point:
    "Point class for storing mathematical points."

Ironically, sometimes making a problem harder (or more general) makes it easier (because there are fewer special cases and fewer opportunities for error).

7.13. Algorithms¶

When you write a general solution for a class of problems, as opposed to a specific solution to a single problem, you have written an algorithm. We mentioned this word before but did not define it carefully. It is not easy to define, so we will try a couple of approaches.

First, consider something that is not an algorithm. When you learned to multiply single-digit numbers, you probably memorized the multiplication table. In effect, you memorized 100 specific solutions. That kind of knowledge is not algorithmic.

But if you were lazy, you probably cheated by learning a few tricks. For example, to find the product of

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

Similarly, the techniques you learned for addition with carrying, subtraction with borrowing, and long division are all algorithms. One of the characteristics of algorithms is that they do not require any intelligence to carry out. They are mechanical processes in which each step follows from the last according to a simple set of rules.

In my opinion, it is embarrassing that humans spend so much time in school learning to execute algorithms that, quite literally, require no intelligence.

On the other hand, the process of designing algorithms is interesting, intellectually challenging, and a central part of what we call programming.

Some of the things that people do naturally, without difficulty or conscious thought, are the hardest to express algorithmically. Understanding natural language is a good example. We all do it, but so far no one has been able to explain how we do it, at least not in the form of an algorithm.

7.14. Points revisited¶

Let’s rewrite the

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> p.x = 3
>>> p.y = 4

The next method,

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Printing a

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

When we write a new class, we almost always start by writing

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

class Point:
    "Point class for storing mathematical points."

7.15. Operator overloading¶

Some languages make it possible to change the definition of the built-in operators when they are applied to user-defined types. This feature is called operator overloading. It is especially useful when defining new mathematical types.

For example, to override the addition operator

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

As usual, the first parameter is the object on which the method is invoked. The second parameter is conveniently named

class Point:
    "Point class for storing mathematical points."

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return ((self.x ** 2) + (self.y ** 2)) ** 0.5

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Now, when we apply the

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

The expression

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

If the left operand of

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

If the left operand of

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

The result is a new

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

class Point:
    "Point class for storing mathematical points."

This example demonstrates both kinds of multiplication:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

What happens if we try to evaluate

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

class Point:
    "Point class for storing mathematical points."

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Unfortunately, the error message is a bit opaque. This example demonstrates some of the difficulties of object-oriented programming. Sometimes it is hard enough just to figure out what code is running.

For a more complete example of operator overloading, see Appendix (reference overloading).

7.16. Polymorphism¶

Most of the methods we have written only work for a specific type. When you create a new object, you write methods that operate on that type.

But there are certain operations that you will want to apply to many types, such as the arithmetic operations in the previous sections. If many types support the same set of operations, you can write functions that work on any of those types.

For example, the

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

This method will work for any values of

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

We can invoke it with numeric values:

>>> print(p.y)
4
>>> x = p.x
>>> print(x)
3

Or with

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

In the first case, the

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

A function like this that can take parameters with different types is called polymorphic.

As another example, consider the method

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Because the

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

Here’s an example that applies

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Of course, we intended to apply this function to lists, so it is not surprising that it works. What would be surprising is if we could apply it to a

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

To determine whether a function can be applied to a new type, we apply the fundamental rule of polymorphism: If all of the operations inside the function can be applied to the type, the function can be applied to the type. The operations in the method include

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    "Point class for storing mathematical points."

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

Then we can pass

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

The best kind of polymorphism is the unintentional kind, where you discover that a function you have already written can be applied to a type for which you never planned.

7.17. Glossary¶

A user-defined compound type. A class can also be thought of as a template for the objects that are instances of it.

To create an instance of a class.

An object that belongs to a class.

A compound data type that is often used to model a thing or concept in the real world.

One of the named data items that makes up an instance.

A function that does not modify any of the objects it receives as parameters. Most pure functions are fruitful.

A function that changes one or more of the objects it receives as parameters. Most modifiers are void.

A style of program design in which the majority of functions are pure.

A way of developing programs starting with a prototype and gradually testing and improving it.

A way of developing programs that involves high-level insight into the problem and more planning than incremental development or prototype development.

A language that provides features, such as user-defined classes and inheritance, that facilitate object-oriented programming.

A style of programming in which data and the operations that manipulate it are organized into classes and methods.

A function that is defined inside a class definition and is invoked on instances of that class. :override:: To replace a default. Examples include replacing a default parameter with a particular argument and replacing a default method by providing a new method with the same name.

A special method that is invoked automatically when a new object is created and that initializes the object’s attributes.

Extending built-in operators (

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

class Point:
    "Point class for storing mathematical points."

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

>>> type(Point)
<class 'type'>
>>> p = Point()
>>> type(p)
<class '__main__.Point'>

An operation defined in linear algebra that multiplies two

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

An operation defined in linear algebra that multiplies each of the coordinates of a

print('({0}, {1})'.format(p.x, p.y))
distance_squared = p.x * p.x + p.y * p.y

A function that can operate on more than one type. If all the operations in a function can be applied to a type, then the function can be applied to a type.

What is the correct syntax for defining a class called game if it inherits from a parent class called LogicGame in Python?

What is the syntax of a Python class?

What is the correct syntax for defining a class?

What is the correct syntax for instantiating a new object of the type game Python?