08 Classes and Object-Oriented Programming (Chapter 8)

The class Book, and two objects built from it

Write the class that the report needed, then build two books and print their slots. The only new lines are the class line, the definition line and the three assignments.

class Book(object):
    """One entry in the library catalogue."""

    def __init__(self, title, pages, price):
        """Assumes title is a str, pages an int, price a float."""
        self.title = title
        self.pages = pages
        self.price = price


b1 = Book('Ada', 312, 180.0)
b2 = Book('Zeno', 98, 75.5)
print(b1.title, b1.pages, b1.price)
print(b2.title, b2.pages, b2.price)
print(type(b1))

Sample Run:

Ada 312 180.0
Zeno 98 75.5
<class '__main__.Book'>

The shortest book and the average price, from a list of objects

This is the hook, answered. The catalogue is one list, each item is one book, and the loop asks each book for the field it needs.

class Book(object):
    """One entry in the library catalogue."""

    def __init__(self, title, pages, price):
        """Assumes title is a str, pages an int, price a float."""
        self.title = title
        self.pages = pages
        self.price = price


catalogue = [Book('Ada', 312, 180.0),
             Book('Zeno', 98, 75.5),
             Book('Milo', 204, 120.0)]

shortest = catalogue[0]
for b in catalogue:
    if b.pages < shortest.pages:
        shortest = b
print('shortest book:', shortest.title, 'with', shortest.pages, 'pages')

total = 0.0
for b in catalogue:
    total = total + b.price
print('average price:', format(total / len(catalogue), '.2f'))

Sample Run:

shortest book: Zeno with 98 pages
average price: 125.17

One method that answers a question and one that changes the book

Two methods on the same class, one from each family. Read the docstrings first: one says returns and the other says lowers the price and returns nothing.

class Book(object):
    """A book that can answer questions about itself."""

    def __init__(self, title, pages, price):
        """Assumes title is a str, pages an int, price a float."""
        self.title = title
        self.pages = pages
        self.price = price

    def reading_days(self, per_day):
        """Assumes per_day is an int > 0.
        Returns the whole days needed at per_day pages a day."""
        return self.pages // per_day + 1

    def discount(self, percent):
        """Assumes percent is a number between 0 and 100.
        Lowers the price of this book and returns nothing."""
        self.price = self.price - self.price * percent / 100


b = Book('Ada', 312, 180.0)
print(b.reading_days(40), 'days at 40 pages a day')
b.discount(25)
print('new price:', format(b.price, '.2f'))

Sample Run:

8 days at 40 pages a day
new price: 135.00

A method that takes another book as its parameter

A specification often says compares this one with another. The second object arrives as an ordinary parameter, by convention named other, and its slots are read with a dot like any other object.

class Book(object):
    """A book that can compare itself with another book."""

    def __init__(self, title, pages):
        """Assumes title is a str and pages an int."""
        self.__title = title
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title

    def get_pages(self):
        """Returns the page count."""
        return self.__pages

    def longer_than(self, other):
        """Assumes other is a Book.
        Returns True when this book has more pages than the other one."""
        return self.__pages > other.__pages

    def pages_between(self, other):
        """Assumes other is a Book.
        Returns the difference in page count, never a negative number."""
        return abs(self.__pages - other.__pages)


first = Book('Ada', 312)
second = Book('Zeno', 98)
print(first.longer_than(second))
print(second.longer_than(first))
print(first.pages_between(second))
print(second.pages_between(first))

Sample Run:

True
False
214
214

The class Book with private data and a set method that refuses

The specification is the one the lab sheets use: all data members private, a get method for each, a set method for the price that only accepts a positive value, and __init__ setting the price through that set method.

class Book(object):
    """A book whose data is reached only through its own methods."""

    def __init__(self, title, pages, price):
        """Assumes title is a str, pages an int, price a float."""
        self.__title = title
        self.__pages = pages
        self.__price = 0.0
        self.set_price(price)

    def get_title(self):
        """Returns the title."""
        return self.__title

    def get_pages(self):
        """Returns the page count."""
        return self.__pages

    def get_price(self):
        """Returns the price."""
        return self.__price

    def set_price(self, price):
        """Assumes price is a number.
        Sets the price only when the value is positive."""
        if price > 0:
            self.__price = price


b = Book('Ada', 312, 180.0)
print(b.get_title(), b.get_price())
b.set_price(-5.0)
print('after a negative set:', b.get_price())
b.set_price(150.0)
print('after a real set:', b.get_price())

Sample Run:

Ada 180.0
after a negative set: 180.0
after a real set: 150.0

What reaching a private attribute from outside actually says

The error message is worth reading once in full, because it is the one this week's lab produces most often, and because the suggestion at the end of it is a hint about the renaming.

class Book(object):
    """A book with one hidden attribute and one door to it."""

    def __init__(self, title, pages):
        """Assumes title is a str and pages an int."""
        self.__title = title
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title


b = Book('Ada', 312)
print(b.get_title())
print(b.__title)

Sample Run:

Ada
Traceback (most recent call last):
  File "outside.py", line 16, in <module>
    print(b.__title)
          ^^^^^^^^^
AttributeError: 'Book' object has no attribute '__title'. Did you mean: 'get_title'?

Raising the shared fine, written the way that works

The same class with one word changed in the method that raises the fine. Compare the output with the counterexample above, where the left hand side was self.

class Book(object):
    """A book whose method writes the shared fine on the class."""

    __fine_per_day = 2.5

    def __init__(self, title):
        """Assumes title is a str."""
        self.__title = title

    def raise_fine(self, amount):
        """Assumes amount is a number. Raises the fine every book shares."""
        Book.__fine_per_day = Book.__fine_per_day + amount

    def fine(self, days_late):
        """Assumes days_late is an int >= 0. Returns the fine owed."""
        return days_late * Book.__fine_per_day


b1 = Book('Ada')
b2 = Book('Zeno')
b1.raise_fine(1.5)
print(b1.fine(2), b2.fine(2))

Sample Run:

8.0 8.0

A list written under the class line is one list for everybody

Two shelves, each given one title, and the two titles end up on both. This is the aliasing problem from the work on lists, arriving through a class.

class Shelf(object):
    """A shelf of titles. The list was created in the wrong place."""

    __titles = []

    def add(self, title):
        """Assumes title is a str. Puts it on this shelf."""
        Shelf.__titles.append(title)

    def get_titles(self):
        """Returns the titles on this shelf."""
        return Shelf.__titles


upstairs = Shelf()
downstairs = Shelf()
upstairs.add('Ada')
downstairs.add('Zeno')
print(upstairs.get_titles())
print(downstairs.get_titles())
print(upstairs.get_titles() is downstairs.get_titles())

Sample Run:

['Ada', 'Zeno']
['Ada', 'Zeno']
True

The repair is one line moved: the list is built in __init__, so each shelf gets its own.

class Shelf(object):
    """A shelf of titles. Each shelf builds its own list."""

    def __init__(self):
        """Starts this shelf with an empty list of its own."""
        self.__titles = []

    def add(self, title):
        """Assumes title is a str. Puts it on this shelf."""
        self.__titles.append(title)

    def get_titles(self):
        """Returns the titles on this shelf."""
        return self.__titles


upstairs = Shelf()
downstairs = Shelf()
upstairs.add('Ada')
downstairs.add('Zeno')
print(upstairs.get_titles())
print(downstairs.get_titles())
print(upstairs.get_titles() is downstairs.get_titles())

Sample Run:

['Ada']
['Zeno']
False

A three line block for one book, and what a list of them looks like

The format is the one the lab sample runs use: a labelled line per field, ending in a newline. Then the same two books printed as a list, which is where the sample runs get their odd looking brackets and commas.

class Book(object):
    """A book that knows how to print itself."""

    def __init__(self, title, author, pages):
        """Assumes title and author are str, pages an int."""
        self.__title = title
        self.__author = author
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title

    def __repr__(self):
        """Returns the three line block the catalogue prints."""
        return ('Title: ' + self.__title + '\n'
                + 'Author: ' + self.__author + '\n'
                + 'Pages: ' + str(self.__pages) + '\n')


b1 = Book('Ada', 'Kara', 312)
b2 = Book('Zeno', 'Acar', 98)
print(b1)
print([b1, b2])

Sample Run:

Title: Ada
Author: Kara
Pages: 312

[Title: Ada
Author: Kara
Pages: 312
, Title: Zeno
Author: Acar
Pages: 98
]

Both forms on one class, and which one each print reaches

The one case where writing both is worth it: a short friendly line for a reader and an exact form for debugging. Four prints, two of which reach the same method.

class Book(object):
    """A book with two printed forms."""

    def __init__(self, title, pages):
        """Assumes title is a str and pages an int."""
        self.__title = title
        self.__pages = pages

    def __str__(self):
        """Returns the form meant for whoever is reading the screen."""
        return self.__title + ' (' + str(self.__pages) + ' pages)'

    def __repr__(self):
        """Returns the form meant for whoever is fixing the program."""
        return 'Book(' + repr(self.__title) + ', ' + repr(self.__pages) + ')'


b = Book('Ada', 312)
print(b)
print(str(b))
print(repr(b))
print([b, b])

Sample Run:

Ada (312 pages)
Ada (312 pages)
Book('Ada', 312)
[Book('Ada', 312), Book('Ada', 312)]

Ordering books by page count, with the title as tie breaker

This is the shape the lab sheets ask for: shorter first, and when two counts are equal the titles decide. Two of the four books have 204 pages on purpose, because that is the pair the second test is for.

class Book(object):
    """A book that compares by page count, then by title."""

    def __init__(self, title, pages):
        """Assumes title is a str and pages an int."""
        self.__title = title
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title

    def get_pages(self):
        """Returns the page count."""
        return self.__pages

    def __lt__(self, other):
        """Assumes other is a Book.
        Returns True when this book is shorter, and when the two counts are
        equal, when this title comes first in alphabetical order."""
        if self.__pages < other.__pages:
            return True
        if self.__pages == other.__pages and self.__title < other.__title:
            return True
        return False

    def __repr__(self):
        """Returns the title and the page count on one line."""
        return self.__title + '/' + str(self.__pages)


shelf = [Book('Milo', 204), Book('Ada', 312), Book('Zeno', 98),
         Book('Bora', 204)]
print(shelf[0] < shelf[1])
shelf.sort()
print(shelf)
print(min(shelf))

Sample Run:

True
[Zeno/98, Bora/204, Milo/204, Ada/312]
Zeno/98

Adding two durations and getting a third

An arithmetic special method should build a new object and leave both of its arguments alone, exactly as adding two numbers does. The carry from minutes into hours is done in __init__, so it happens wherever a duration is built.

class Duration(object):
    """A length of time in whole hours and minutes."""

    def __init__(self, hours, minutes):
        """Assumes hours and minutes are ints >= 0.
        Sixty minutes or more are carried into the hours."""
        self.__hours = hours + minutes // 60
        self.__minutes = minutes % 60

    def get_hours(self):
        """Returns the whole hours."""
        return self.__hours

    def get_minutes(self):
        """Returns the minutes left over."""
        return self.__minutes

    def __add__(self, other):
        """Assumes other is a Duration. Returns a NEW Duration."""
        return Duration(self.__hours + other.__hours,
                        self.__minutes + other.__minutes)

    def __lt__(self, other):
        """Assumes other is a Duration.
        Returns True when this length is the shorter one."""
        return (self.__hours * 60 + self.__minutes
                < other.__hours * 60 + other.__minutes)

    def __repr__(self):
        """Returns hours and minutes, two digits each."""
        return '{0:02d}:{1:02d}'.format(self.__hours, self.__minutes)


lab = Duration(1, 50)
lecture = Duration(2, 25)
print(lab, lecture)
print(lab + lecture)
print(lab < lecture)
week = [Duration(0, 45), Duration(3, 5), Duration(1, 50)]
week.sort()
print(week)

Sample Run:

01:50 02:25
04:15
True
[00:45, 01:50, 03:05]

AudioBook extends Book: two new fields, one overridden answer

The shape the lab sheet asks for. The child calls the parent's __init__, adds its two fields, overrides the method whose answer has to change, and builds its printed form on top of the parent's one.

class Book(object):
    """A catalogue entry with a title, an author and a page count."""

    def __init__(self, title, author, pages):
        """Assumes title and author are str, pages an int."""
        self.__title = title
        self.__author = author
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title

    def get_pages(self):
        """Returns the page count."""
        return self.__pages

    def reading_hours(self):
        """Returns the whole hours needed at 40 pages an hour."""
        return self.__pages // 40

    def __repr__(self):
        """Returns two lines: the title with its author, then the length."""
        return ('Title: ' + self.__title + ' by ' + self.__author + '\n'
                + 'Reading time: ' + str(self.reading_hours()) + ' h\n')


class AudioBook(Book):
    """A catalogue entry that is listened to rather than read."""

    def __init__(self, title, author, pages, minutes, reader):
        """Assumes minutes is an int and reader a str.
        The title, author and pages are set by the Book __init__."""
        super().__init__(title, author, pages)
        self.__minutes = minutes
        self.__reader = reader

    def get_reader(self):
        """Returns the name of the person reading it aloud."""
        return self.__reader

    def reading_hours(self):
        """Returns the whole hours of audio, replacing the page estimate."""
        return self.__minutes // 60

    def __repr__(self):
        """Returns the Book lines, then the reader."""
        return super().__repr__() + 'Read by: ' + self.__reader + '\n'


paper = Book('Ada', 'Kara', 312)
audio = AudioBook('Zeno', 'Acar', 98, 205, 'Deniz Ok')
print(paper)
print(audio)
print(audio.get_title(), audio.get_pages(), audio.get_reader())
print(paper.reading_hours(), audio.reading_hours())
print(Book.reading_hours(audio))

Sample Run:

Title: Ada by Kara
Reading time: 7 h

Title: Zeno by Acar
Reading time: 3 h
Read by: Deniz Ok

Zeno 98 Deniz Ok
7 3
2

isinstance, a subclass with pass, and a comparison across two classes

Three classes and six questions. Reserve adds nothing and exists so that a reserve copy can be told from an ordinary one; both subclasses are still Books.

class Book(object):
    """A catalogue entry that compares by title."""

    def __init__(self, title, pages):
        """Assumes title is a str and pages an int."""
        self.__title = title
        self.__pages = pages

    def get_title(self):
        """Returns the title."""
        return self.__title

    def __lt__(self, other):
        """Assumes other is a Book. Compares the titles alphabetically."""
        return self.__title < other.__title


class AudioBook(Book):
    """A catalogue entry that compares by how long the audio runs."""

    def __init__(self, title, pages, minutes):
        """Assumes minutes is an int."""
        super().__init__(title, pages)
        self.__minutes = minutes

    def __lt__(self, other):
        """Assumes other is an AudioBook. Compares the audio lengths."""
        return self.__minutes < other.__minutes


class Reserve(Book):
    """A copy that may not leave the building. Nothing new is added."""
    pass


paper = Book('Milo', 204)
short = AudioBook('Ada', 98, 205)
long_one = AudioBook('Zeno', 312, 640)
desk = Reserve('Bora', 150)

print(isinstance(short, AudioBook), isinstance(short, Book))
print(isinstance(paper, AudioBook))
print(isinstance(desk, Book), isinstance(desk, Reserve))
print(short < long_one)
print(paper < short)
print(desk.get_title())

Sample Run:

True True
False
True True
True
False
Bora

Two dates, a class variable, and a field that starts as None

The lab sheet for this week uses dates, and this is the pattern it asks for: a date arrives as text and is turned into a date object, a second date starts as None until it is set, and the number of days between two dates is (later - earlier).days.

import datetime


class Loan(object):
    """One loan, with the day it went out and the day it came back."""

    __daily_fine = 2.0

    def __init__(self, title, taken):
        """Assumes title is a str and taken a date written as YYYYmmdd."""
        self.__title = title
        self.__taken = datetime.datetime.strptime(taken, '%Y%m%d').date()
        self.__returned = None

    def get_taken(self):
        """Returns the day the book went out."""
        return self.__taken

    def set_returned(self, returned):
        """Assumes returned is a date written as YYYYmmdd."""
        self.__returned = datetime.datetime.strptime(returned,
                                                     '%Y%m%d').date()

    def days_out(self):
        """Returns the days the book was out, and zero while it is still out."""
        if self.__returned is None:
            return 0
        return (self.__returned - self.__taken).days

    def fine(self):
        """Returns the fine owed for each day past the fourteenth."""
        late = self.days_out() - 14
        if late <= 0:
            return 0.0
        return late * Loan.__daily_fine

    def __repr__(self):
        """Returns the four line block the desk prints."""
        return ('Title: ' + self.__title + '\n'
                + 'Taken: ' + str(self.__taken) + '\n'
                + 'Returned: ' + str(self.__returned) + '\n'
                + 'Fine: ' + format(self.fine(), '.2f') + '\n')


one = Loan('Ada', '20241011')
one.set_returned('20241102')
two = Loan('Zeno', '20241017')
print(one)
print(two)
print(one.days_out(), two.days_out())

Sample Run:

Title: Ada
Taken: 2024-10-11
Returned: 2024-11-02
Fine: 16.00

Title: Zeno
Taken: 2024-10-17
Returned: None
Fine: 0.00

22 0