08 CLASSES AND OBJECT-ORIENTED PROGRAMMING

What is the key to object-oriented programming?

Think about objects as collections of both data and the meth- ods that operate on that data.

8.1 Abstract Data Types and Classes

Why bound a set of objects and the operations on those objects together with an abstract data type?

One can pass an object from one part of a program to another, and in doing so provide access not only to the data attributes of the object but also to operations that make it easy to manipulate that data.

What does a specification of a class’s operations do?

The specifications of those operations define an interface between the abstract data type and the rest of the program. The interface defines the behavior of the operations—what they do, but not how they do it. The interface thus provides an abstraction barrier that isolates the rest of the program from the data structures, algorithms, and code involved in providing a realization of the type abstraction.

What mechanisms are available for accomplishing the goal of managing complexity in a way that facilitates change?

Decomposition creates structure in a program, and abstraction suppresses detail.

Why someone has a great leg up in maintaining a software for years?

The key is to suppress the appropriate details. This is where data abstraction hits the mark.

One can create domain-specific types that provide a convenient abstraction. Ideally, these types capture concepts that will be relevant over the lifetime of a program. If one starts the programming process by devising types that will be relevant months and even decades later, one has a great leg up in maintaining that software.

What are the comments below the docstring of class and function?

In contrast, the comments below the docstring contain information about the implementation. That information is aimed at programmers who might want to modify the implementation or build subclasses of the class, not at programmers who might want to use the abstraction.

What is the code of implementation an “intset”?

class IntSet(object):
    """An intSet is a set of integers"""
    #Information about the implementation (not the abstraction)
    #Value of the set is represented by a list of ints, self.vals.
    #Each int in the set occurs in self.vals exactly once.
    def __init__(self):
        """Create an empty set of integers""" 
        self.vals = []

    def insert(self, e):
        """Assumes e is an integer and inserts e into self"""
        if e not in self.vals:
            self.vals.append(e)

    def member(self, e):
        """Assumes e is an integer
           Returns True if e is in self, and False otherwise"""
        return e in self.vals

    def remove(self, e):
        """Assumes e is an integer and removes e from self
           Raises ValueError if e is not in self"""
        try:
            self.vals.remove(e)
        except:
            raise ValueError(str(e) + ' not found')

    def getMembers(self):
        """Returns a list containing the elements of self.
           Nothing can be assumed about the order of the elements"""
        return self.vals[:]

    def __str__(self):
        """Returns a string representation of self"""
        self.vals.sort()
        result = ''
        for e in self.vals:
            result = result + str(e) + ','
        return '{' + result[:-1] + '}' #-1 omits trailing comma

What is a function inside a class called?

a method that associated with the class

method attributes of the class

What is the relationship of type, class, method and function?

A class should not be confused with instances of that class, just as an object of type list should not be confused with the list type.

s = IntSet() 
s.insert(3) 
print("Whether '3' exists in 's':", s.member(3))
print ("Type of 'IntSet' is " + str(type (IntSet)) + ".\n" + 
       "Type of 'IntSet.insert' is " + str(type (IntSet.insert)) + ".")
print ("Type of 's' is " + str(type (s)) + ".\n" + 
       "Type of 's.insert' is " + str(type(s.insert)) + ".")

What are method attributes and data attributes?

Method attributes are defined in a class definition, for example IntSet.member is an attribute of the class IntSet. When the class is instantiated, e.g., by the statement s = IntSet(), instance attributes, e.g., s.member, are created.

When data attributes are associated with a class we call them class variables. When they are associated with an instance we call them instance variables.

What is representation-independence?

Data abstraction achieves representation-independence. Think of the im- plementation of an abstract type as having several components:

• Implementations of the methods of the type,
• Data structures that together encode values of the type, and
• Conventions¹ about how the implementations of the methods are to use the data structures. A key convention is captured by the representation² invariant³.

What is representation invariant?

The representation invariant defines which values of the data attributes correspond to valid representations of class instances. The representation invariant for IntSet is that vals contains no duplicates. The implementation of __init__ is responsible for establishing the invariant (which holds on the empty list), and the other methods are responsible for maintaining that invariant. That is why insert appends e only if it is not already in self.vals. The implementation of remove exploits the assumption that the representation invariant is satisfied when remove is entered. It calls list.remove only once, since the representation invariant guarantees that there is at most one occurrence of e in self.vals.

Is a user-defined class instance hashable?

Any instance of a user-defined class is hashable

All instances of user-defined classes are hashable, and therefore can be used as dictionary keys. If no __hash__ method is provided, the hash value of the object is derived from the function id.

Why abstract data types are a big deal[^a big deal]?

They lead to a different way of thinking about organizing large programs.

Rely on abstraction when trying to understand concepts about the world

When we think about the world, we rely on abstractions. In the world of finance people talk about stocks and bonds. In the world of biology people talk about proteins and residues. When trying to understand concepts such as these, we mentally gather together some of the relevant data and features of these kinds of objects into one intellectual package. For example, we think of bonds as having an interest rate and a maturity date as data attributes. We also think of bonds as having operations such as “set price” and “calculate yield to maturity.” Abstract data types allow us to incorporate this kind of organization into the design of programs.

Focus on the centrality of data object rather than functions when designing programs

Data abstraction encourages program designers to focus on the centrality of data objects rather than functions. Thinking about a program more as a collection of types than as a collection of functions leads to a profoundly different organizing principle. Among other things, it encourages one to think about programming as a process of combining relatively large chunks, since data abstractions typically encompass[^encompass] more functionality than do individual functions. This, in turn, leads us to think of the essence of programming as a process not of writing individual lines of code, but of composing[^compose] abstractions.

Reuse abstractions to reduce development time and to yield more reliable programs

The availability of reusable abstractions not only reduces development time, but also usually leads to more reliable programs, because mature software is usually more reliable than new software. For many years, the only program libraries in common use were statistical or scientific. Today, however, there is a great range of available program libraries (especially for Python), often based on a rich set of data abstractions.

[^a big deal]: a big deal: informal [usually with negative] a thing considered important: they don’t make a big deal out of minor irritations. • an important person: Sam Kinison became a big deal. • (big deal) used to express one’s contempt for something regarded as impressive or important by another person: “I’ll give you an allowance,” he said. “Big deal,” she thought. [^encompass]: encompass: To circumscribe or go round so as to surround closely; to encircle; to inclose; to environ; as, a ring encompasses the finger; an army encompasses a city; a voyage encompassing the world. - Shak. A question may be encompassed with difficulty. - C. J. Smith. [^compose]: compose: To construct by mental labor; to design and execute, or put together, in a manner involving the adaptation of forms of expression to ideas, or to the laws of harmony or proportion; as, to compose a sentence, a sermon, a symphony, or a picture.

What abstraction might be useful, before rushing in to design a bunch of data structures to keep track of all the students and faculty, ?

Is there an abstraction that covers the common attributes of students, professors, and staff? Some would argue that they are all human. The following code contains a class that incorporates some of the common attributes (name and birthday) of humans.

import datetime

class Person(object):
    def __init__(self, name):
        """Create a person"""
        self.name = name
        try:
            lastBlank = name.rindex(' ')
            self.lastName = name[lastBlank+1:]
        except:
            self.lastName = name
        self.birthday = None

    def getName(self):
        """Returns self's full name"""
        return self.name

    def getLastName(self):
        """Returns self's last name"""
        return self.lastName

    def setBirthday(self, birthdate):
        """ Assumes birthdate is of type datetime.date
            Sets self's birthday to birthdate"""
        self.birthday = birthdate

    def getAge(self):
        """Returns self's current age in days"""
        if self.birthday == None:
            raise ValueError
        return (datetime.date.today() - self.birthday).days

    def __lt__(self, other):
        """Returns True if self precedes other in alphabetical
            order, and False otherwise. Comparison is based on last
            names, but if these are the same full names are
            compared."""
        if self.lastName == other.lastName:
            return self.name < other.name
        return self.lastName < other.lastName

    def __str__(self):
        """Returns self's name"""
        return self.name

The following code makes use of Person.

Barack Hussein Obama is 21493 days old

---

1. convention: General agreement or concurrence; arbitrary custom; usage; conventionality.↩

2. representation: That which represents. Specifically: A description or statement; as, the representation of an historian, of a witness, or an advocate.↩

3. invariant: n. (Math.) An invariable quantity; specifically, a function of the coefficients of one or more forms, which remains unaltered, when these undergo suitable linear transformations. - J. J. Sylvester.↩