Objects

OOP¶

Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which have their own properties and methods that define their behavior.

Motivation¶

Why OOP? Let’s write the Hello-World program with OOP:

The above code creates a video by simply defining

• a Scene called HelloWorld

• constructed by playing an animation that

• Writes the Text message 'Hello, World!'.

Complicated animations can be created without too many lines of code because

• OOP makes programming expressive by

• encapsulating different variables (called properties) and functions (called methods) by the entities (called objects) they apply to and

• abstracting away the internal implementation details.

An object is essentially a closure.

Classes and Objects¶

What is an object?

object is a class/type like int, float, str, and bool.

Recall that a function is also a first-class object, or more precisely, an instance of type object:

Almost everything in Python is an object:

An object can be an instance of more than one type. For instance, True is an instance of bool, int, and object:

As proposed in PEP 285,^[1]

• bool is a subclass of int, and

• int is a base class of bool.

In particular, True and False have the integer values 1 and 0 respectively.^[2]

Attributes¶

To check if an object has a particular attribute:

To list all attributes of an object:

Different objects of a class share the class attributes:

Different objects of the same class can still behave differently because their attribute values can be different.

An attribute can also be a function, which is called a method or member function.

A method of a class can be accessed by its instances:

A subclass also inherits the attributes of its base classes:

For instance, ``boolinherits the methods for arithmetics from the base classint`:

A subclass does not necessarily have the same set of attributes as that defined by its base class. A subclass can inherit attributes from multiple base classes and define its own attributes. Different implementations of the same method are resolved using the method resolution order (mro):

Object Aliasing¶

Now is the time to differentiate values from objects.

When are two objects identical?

The keyword is checks whether two objects are the same object:

Is is the same as ==?

is is slightly faster because:

• is simply checks whether two objects occupy the same memory, but

• == calls the method (__eq__) of the operands to check the equality in value.

To see this, we can use the function id which returns an id number for an object based on its memory location.

As the box-pointer diagram shows:

• x is y because the assignment x = y binds y to the same memory location x points to.
  y is said to be an alias (another name) of x.

• x is not z because they point to objects at different memory locations,
  even though the objects have the same type and value.

Can we use is instead of == to compare integers/strings?

Indeed, we normally get a SyntaxWarning when using is with a literal.

Note that the issue is not specific to literals, as shown below. We cannot rely on SyntaxWarning for using is properly.

Using Methods¶

Like a Swiss army knife, an object is a versatile tool that can perform a variety of tasks. By invoking its methods, you can manipulate the object’s data, perform computations, or interact with other objects.

File Objects¶

How to read a text file?

Consider reading a csv (comma separated value) file:

To read the file by a Python program:

1. open is a function that creates a file object and assigns it to f.

2. Associated with the file object:

   • read returns the entire content of the file as a string.

   • close flushes and closes the file.

Why close a file?

If not, depending on the operating system,

• other programs may not be able to access the file, and

• changes may not be written to the file.

To ensure a file is closed properly, we can use the with statement:

The with statement applies to any context manager that provides the methods

• __enter__ for initialization, and

• __exit__ for finalization.

• f.__enter__ is called after the file object is successfully created and assigned to f, and

• f.__exit__ is called at the end, which closes the file.

• f.closed indicates whether the file is closed.

We can iterate a file object in a for loop,
which implicitly calls the method __iter__ to read a file line by line.

How to write to a text file?

Consider backing up contact.csv to a new file:

The directory has to be created first if it does not exist:

To write to the destination file:

• The argument 'w' for open sets the file object to write mode.

• The method write writes the input strings to the file.

How to delete a file?

Note that the file object does not provide any method to delete the file.
Instead, we should use the function remove of the os module.

String Objects¶

How to search for a substring in a string?

A string object has the method find to search for a substring.
E.g., to find the contact information of Tai Ming:

How to split and join strings?

A string can be split according to a delimiter using the split method.

The list of substrings can be joined back together using the join methods.

Operator Overloading¶

Recall that adding str to int raises a type error. The following code circumvented this by creating a subclass of str that overrides its methods __add__ and __radd__ for addition:

How does the above code re-implements +?

Recall that the addition operation + behaves differently for different types.

• Having an operator perform differently based on its argument types is called operator overloading.

• + is called a generic operator.

Dispatch on type¶

The strategy of checking the type for the appropriate implementation is called dispatching on type.

A naive idea is to put all the different implementations together:

def add_case_by_case(x, y):
    if isinstance(x, int) and isinstance(y, int):
        # integer summation
        ...
    elif isinstance(x, str) and isinstance(y, str):
        # string concatenation...
        ...
    else:
        # Return a TypeError
        ...

One issue is that supporting a new data type would require the addition to be re-implemented.

Another issue is that developers need to fight for a good spot in the conditional statement to implement additions for the new data type.

These issues can be alleviated in some programming languages such as C and Java that support function overloading.

However, Python does not support function overloading by default, and even if it did, it would still be quite tedious to implement additions for all possible types and combinations:

Data-directed programming¶

The solution idea is to treat an implementation as a datum that can be returned by the operand types.

• The first case calls Fraction.__add__, which provides a way to add int to Fraction.

• The second case calls int.__add__, which cannot provide any way of adding Fraction to int. (Why not?)

The OOP techniques involved are formally called:

• Polymorphism: Different types can have different implementations of the same method such as __add__ and __radd__.

• Single dispatch: The implementation such as + operation is chosen based on one single type at a time.