Classes and Objects

User-defined Types

We have used many of Pythons built-in types Now we are going to define a new type. As an example, we will create a type called Point that represents a point in two-dimensional space. In mathematical notation, points are often written in parentheses with a comma separating the coordinates. For example, (0,0) represents the origin, and (x,y) represents the point x units to the right and y units up from the origin. There are several ways we might represent points in Python:

We could store the coordinates separately in two variables, x and y.

We could store the coordinates as elements in a list or tuple. We could create a new type to represent points as objects.

Creating a new type is (a little) more complicated than the other options, but it has advantages that will be apparent soon.
2

Classic Formatting of Strings

You may format a string so that it prints values embedded into the string using "place holders"

Within the string, a place holder starts with the character %

The symbols immediately after the % symbol describe the type of the object whose value is to be substitute for the place holder. Examples:

%s
%d

string
decimal integer

After the closing quote of the string you place a tuple of the values to be substituted preceded by the % symbol. Replacements are done in left-right order.

Example:

>>> first_name = 'George' >>> last_name = 'Orwell' >>> print("%s's last name is %s" %(first_name,last_name) George's last name is Orwell
3

User-defined Types

A user-defined type is also called a class. A class definition looks like this: class Point: """represents a point in 2-D space"""

This header indicates that we are defining a new class named Point. The body as shown is a docstring that explains what the class is for. You can define variables and functions inside a class definition, as we shall see soon.

Defining a class named Point creates a class object.

>>> print(Point) <class '__main__.Point'>

The class object is like a factory for creating objects. To create a Point, you call Point as if it were a function. >>> blank = Point() >>> print(blank) <__main__.Point object at 0xb7e9d3ac>

User-defined Types

The class object is like a factory for creating objects. To create a Point, you call Point as if it were a function.

>>> blank = Point() >>> print(blank) <__main__.Point object at 0xb7e9d3ac>

The return value is a reference to a Point object, which we assign to blank. Creating a new object is called instantiation, and the object is an instance of the class. When you print an instance, Python tells you what class it belongs to and where it is stored in memory The prefix 0x means that the following number is in hexadecimal.

Attributes

You can assign values to an instance using dot notation: >>> blank.x = 3.0 >>> blank.y = 4.0

This syntax is similar to the syntax for selecting a variable from a module, such as math.pi or string.whitespace.
In this case, though, we are creating and assigning values to named elements of an object.

These elements are called attributes.

As a noun, AT-trib-ute is pronounced with emphasis on the first syllable, as opposed to a-TRIBute, which is a verb.

Object Diagrams

The following diagram shows the result of the preceding assignments. A state diagram that shows an object and its attributes is called an object diagram:

The variable blank refers to a Point object, which contains two attributes.

Each attribute refers to a floating-point number.

You can read the value of an attribute using the same syntax: >>> print(blank.y) 4.0 >>> x = blank.x >>> print(x) 3.0
7

Point Class

The expression blank.x means, Go to the object blank refers to and get the value of x. In this case, we assign that value to a variable named x. There is no conflict between the variable x and the attribute x. You can use dot notation as part of any expression. For instance: >>> print('(%s,%s)' %(blank.x,blank.y)) (3.0,4.0) >>> distance = math.sqrt(blank.x**2 + blank.y**2) >>> print(distance) 5.0

Objects as Function Parameters and Arguments

You can pass an instance as an argument in the usual way. For example: def print_point(p): print('(%s,%s)' %(p.x,p.y))

print_point takes a point as an argument and displays it in mathematical notation. To invoke it, you can pass blank as an argument: >>> print_point(blank) (3.0, 4.0)

Inside the function, p is an alias for blank, so if the function modifies p, blank changes.

Exercise OOP1 Write a function called distance that takes two Point objects as arguments and returns the distance between them.

Rectangles

Sometimes it is obvious what the attributes of an object should be. But other times you have to make decisions. For example, imagine you are designing a class to represent rectangles.

What attributes would you use to specify the location and size of a rectangle?
You can ignore angles; to keep things simple, assume that the rectangle is either vertical or horizontal.

There are at least two possibilities:

You could specify one corner of the rectangle (or the center), the width, and the height. You could specify two opposing corners.

At this point it is hard to say whether either is better than the other, so well implement the first one, just as an example.

10

Rectangles

Here is the class definition: class Rectangle(object): """represent a rectangle. attributes: width, height, corner. """ The docstring lists the attributes:

width and height are numbers; corner is a Point object that specifies the lower-left corner.

To represent a rectangle, you have to instantiate a Rectangle object and assign values to the attributes: box = Rectangle() box.width = 100.0 box.height = 200.0 box.corner = Point() box.corner.x = 0.0 box.corner.y = 0.0

11

Rectangles

The expression box.corner.x means

Go to the object box refers to and select the attribute named corner; then go to that object and select the attribute named x.

The figure shows the state of this object:

An object that is an attribute of another object is embedded.

12

Objects as Return Values

Functions can return instances. For example, find_center takes a Rectangle as an argument and returns a Point that contains the coordinates of the center of the Rectangle: def find_center(box): p = Point() p.x = box.corner.x + box.width/2.0 p.y = box.corner.y + box.height/2.0 return p Here is an example that passes box as an argument and assigns the resulting Point to center: >>> center = find_center(box) >>> print_point(center) (50.0, 100.0)

13

Objects are Mutable

You can change the state of an object by making an assignment to one of its attributes. ] For example, to change the size of a rectangle without changing its position, you can modify the values of width and height:

box.width = box.width + 50 box.height = box.width + 100

You can also write functions that modify objects. For example, grow_rectangle takes a Rectangle object and two numbers, dwidth and dheight, and adds the numbers to the width and height of the rectangle: def grow_rectangle(rect, dwidth, dheight) : rect.width += dwidth rect.height += dheight

14

Objects are Mutable

def grow_rectangle(rect, dwidth, dheight) : rect.width += dwidth rect.height += dheight

Here is an example that demonstrates the effect of the grow_rectangle function: >>> print(box.width) 100.0 >>> print(box.height) 200.0 >>> grow_rectangle(box, 50, 100) >>> print(box.width) 150.0 >>> print(box.height) 300.0 Inside the function, rect is an alias for box, so if the function modifies rect, box changes.
15

Objects are Mutable

Exercise OOP2 Write a function named move_rectangle that takes a Rectangle and two numbers named dx and dy. It should change the location of the rectangle by adding dx to the x coordinate of corner and adding dy to the y coordinate of corner.

16

Copying Objects
Aliasing can make a program difficult to read because changes in one place might have unexpected effects in another place. It is hard to keep track of all the variables that might refer to a given object. Copying an object is often an alternative to aliasing. The copy module contains a function called copy that can duplicate any object: p1 and p2 contain the same data, but they are not the same Point. >>> p1 = Point() >>> print_point(p1) >>> p1.x = 3.0 (3.0, 4.0) >>> p1.y = 4.0 >>> print_point(p2) >>> import copy (3.0, 4.0) >>> p2 = copy.copy(p1) >>> p1 is p2 False >>> p1 == p2 False

17

Copying Objects

Exercise OOP3 Write a function named move_rectangle that takes a Rectangle and two numbers named dx and dy. It should change the location of the rectangle by adding dx to the x coordinate of corner and adding dy to the y coordinate of corner.

18

Deepcopy

The is operator indicates that p1 and p2 are not the same object, which is what we expected. But you might have expected == to yield True because these points contain the same data.

In that case, you will be disappointed to learn that for instances, the default behavior of the == operator is the same as the is operator.
It checks object identity, not object equivalence. This behavior can be changedwell see how later. If you use copy.copy to duplicate a Rectangle, you will find that it copies the Rectangle object but not the embedded Point.

19

Deepcopy
>>> box2 = copy.copy(box) >>> box2 is box False >>> box2.corner is box.corner True

Here is what the object diagram looks like:

This operation is called a shallow copy because it copies the object and any references it contains, but not the embedded objects.

20

Deepcopy

For most applications, shallow copy is not what you want. In this example, invoking grow_rectangle on one Rectangle would not affect the other. But invoking move_rectangle on either would affect both!

This behavior is confusing and error-prone. Fortunately, the copy module contains a method named deepcopy that copies not only the object but also the objects it refers to, and the objects they refer to, and so on.

You will not be surprised to learn that this operation is called a deep copy. >>> box3 = copy.deepcopy(box)

>>> box3 is box False

>>> box3.corner is box.corner

False

box3 and box are completely separate objects.

21

Deepcopy

When you start working with objects, you are likely to encounter some new exceptions. If you try to access an attribute that doesnt exist, you get an AttributeError:

>>> p = Point() >>> print(p.z) AttributeError: Point instance has no attribute 'z'

If you are not sure what type an object is, you can ask:

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

If you are not sure whether an object has a particular attribute, you can use the built-in function hasattr: The first argument can be any object; the second argument is a string that contains the name of the attribute.
22

>>> hasattr(p, 'x') True >>> hasattr(p, 'z') False

Time

As another example of a user-defined type, well define a class called Time that records the time of day. The class definition looks like this: class Time(object): """represents the time of day. attributes: hour, minute, second""" We can create a new Time object and assign attributes for hours, minutes, and seconds: time = Time() time.hour = 11 time.minute = 59

time.second = 30

The state diagram for the Time object looks like this:
23

Time

Exercise OOP4 Write a function called print_time that takes a Time object and prints it in the form hour:minute:second. Hint: the format sequence '%.2d' prints an integer using at least two digits, including a leading zero if necessary. Exercise OOP5 Write a boolean function called is_after that takes two Time objects, t1 and t2, and returns True if t1 follows t2 chronologically and False otherwise. Challenge: dont use an if statement.

24

Pure Functions

In the next few sections, well write two functions that add time values. They demonstrate two kinds of functions: pure functions and modifiers. They also demonstrate a development plan that could be called prototype and patch

Prototype and patch is a way of tackling a complex problem by starting with a simple prototype and incrementally dealing with the complications.
Here is a simple prototype of add_time: def add_time(t1, t2): sum = Time() sum.hour = t1.hour + t2.hour sum.minute = t1.minute + t2.minute

sum.second = t1.second + t2.second

return sum
25

Pure Functions

The add_time function creates a new Time object, initializes its attributes, and returns a reference to the new object. This is called a pure function because it does not modify any of the objects passed to it as arguments and it has no effect, like displaying a value or getting user input, other than returning a value. To test this function, Ill create two Time objects: start contains the start time of a movie, like

Monty Python and the Holy Grail, and duration contains the run time of
the movie, which is one
hour 35 minutes. add_time figures out when the movie will be done.

26

Pure Functions
>>> start = Time() >>> start.hour = 9 >>> start.minute = 45 >>> start.second = 0 >>> duration = Time() >>> duration.hour = 1 >>> duration.minute = 35 >>> duration.second = 0

>>> done = add_time(start, duration)

>>> print_time(done) 10:80:00

The result, 10:80:00 might not be what you were hoping for.

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 minute column or the extra minutes into the hour column.
27

Improved add_time
def add_time(t1, t2): sum = Time() sum.hour = t1.hour + t2.hour sum.minute = t1.minute + t2.minute sum.second = t1.second + t2.second if sum.second >= 60: sum.second -= 60 sum.minute += 1 if sum.minute >= 60: sum.minute -= 60 sum.hour += 1 return sum

Although this function is correct, it is starting to get big. We will see a shorter alternative later.
28

Modifiers

Sometimes it is useful for a function to modify the objects it gets as parameters. In that case, the changes are visible to the caller. Functions that work this way are called modifiers. The increment function, which adds a given number of seconds to a Time object, can be written naturally as a modifier. Here is a rough draft: def increment(time, seconds):

time.second += seconds
if time.second >= 60: time.second -= 60 time.minute += 1 if time.minute >= 60: time.minute -= 60 time.hour += 1

# basic operation
# previous adjustments

29

Modifiers

Is the previous function correct? What happens if the parameter seconds is much greater than sixty? In that case, it is not enough to carry once

We have to keep doing it until time.second is less than sixty.

One solution is to replace the if statements with while statements. That would make the function correct, but not very efficient. Exercise OOP6 Write a correct version of increment that doesnt contain any loops.

30

Modifiers

Anything that can be done with modifiers can also be done with pure functions. In fact, some programming languages only allow pure functions. There is some evidence that programs that use pure functions are faster to develop and less error-prone than programs that use modifiers. But modifiers are convenient at times, and functional programs tend to be less efficient. In general, you should probably write pure functions whenever it is reasonable and resort to modifiers only if there is a compelling advantage. This approach might be called a functional programming style. Exercise OOP7 Write a pure version of increment that creates and returns a new Time object rather than modifying the parameter.

31