Object-Oriented Programming in Python (OOP): Tutorial

Instantiating objects

To instantiate an object, type the class name, followed by two brackets. You can assign this to a variable to keep track of the object.

ozzy = Dog()

And print it:

print(ozzy)

<__main__.Dog object at 0x111f47278>

Adding attributes to a class

After printing ozzy, it is clear that this object is a dog. But you haven't added any attributes yet. Let's give the Dog class a name and age by rewriting it:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

You can see that the function now takes two arguments after self: name and age. These then get assigned to self.name and self.age respectively. You can now create a new ozzy object with a name and age:

ozzy = Dog("Ozzy", 2)

To access an object's attributes in Python, you can use the dot notation. This is done by typing the name of the object, followed by a dot and the attribute's name

print(ozzy.name)

print(ozzy.age)

Ozzy
2

This can also be combined in a more elaborate sentence:

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")

Ozzy is 2 year(s) old.

The str() function is used here to convert the age attribute, which is an integer, to a string, so you can use it in the print() function.

Define methods in a class

Now that you have a Dog class, it does have a name and age, which you can keep track of, but it doesn't actually do anything. This is where instance methods come in. You can rewrite the class to now include a bark() method. Notice how the def keyword is used again, as well as the self argument.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

The bark method can now be called using the dot notation, after instantiating a new ozzy object. The method should print "bark bark!" to the screen. Notice the parentheses (curly brackets) in .bark(). These are always used when calling a method. They're empty in this case, since the bark() method does not take any arguments.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Recall how you printed ozzy earlier? The code below now implements this functionality in the Dog class, with the doginfo() method. You then instantiate some objects with different properties, and call the method on them.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

As you can see, you can call the doginfo() method on objects with the dot notation. The response now depends on which Dog object you are calling the method on.

Since dogs get older, it would be nice if you could adjust their age accordingly. Ozzy just turned 3, so let's change his age.

ozzy.age = 3

print(ozzy.age)

3

It's as easy as assigning a new value to the attribute. You could also implement this as a birthday() method in the Dog class:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

Now, you don't need to manually change the dog's age. whenever it is its birthday, you can just call the birthday() method. 

Passing arguments to methods

You would like for our dogs to have a buddy. This should be optional since not all dogs are as sociable. Take a look at the setBuddy() method below. It takes self, as per usual, and buddy as arguments. In this case, buddy will be another Dog object. Set the self.buddy attribute to buddy, and the buddy.buddy attribute to self. This means that the relationship is reciprocal; you are your buddy's buddy. In this case, Filou will be Ozzy's buddy, which means that Ozzy automatically becomes Filou's buddy. You could also set these attributes manually instead of defining a method, but that would require more work (writing two lines of code instead of one) every time you want to set a buddy. Notice that in Python, you don't need to specify what type the argument is. If this were Java, it would be required.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

You can now call the method with the dot notation, and pass it another Dog object. In this case, Ozzy's buddy will be Filou:

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)

If you now want to get some information about Ozzy's buddy, you can use the dot notation twice: First, to refer to Ozzy's buddy, and a second time to refer to its attribute.

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

Notice how this can also be done for Filou.

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

The buddy's methods can also be called. The self argument that gets passed to doginfo() is now ozzy.buddy, which is filou.

 ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Python OOP Example

An example of where Object-Oriented programming in Python might come in handy is our Python For Finance: Algorithmic Trading tutorial. In it, we explain how to set up a trading strategy for a stock portfolio. The trading strategy is based on the moving average of a stock price. If signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] is fulfilled, a signal is created. This signal is a prediction for the stock's future price change. In the code below, you'll see that there is first an initialization, followed by the moving average calculation and signal generation. Since this is not object-oriented code, it's just one big chunk that gets executed at once. Notice that we're using aapl in the example, which is Apple's stock ticker. If you wanted to do this for a different stock, you would have to rewrite the code.

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

In an object-oriented approach, you only need to write the initialization and signal generation code once. You can then create a new object for each stock you want to calculate a strategy on, and call the generate_signals() method on it. Notice that the OOP code is very similar to the code above, with the addition of self.

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

You can now simply instantiate an object, with the parameters you want, and generate signals for it.

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

Doing this for another stock becomes very easy. It's just a matter of instantiating a new object with a different stock symbol.

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

Object-Oriented Programming in Python: Wrap-Up

We've covered some of the main OOPs concepts in Python. You now know how to declare classes and methods, instantiate objects, set their attributes and call instance methods. These skills will come in handy during your future career as a data scientist. If you want to expand the key concepts that you need to further work with Python, be sure to check out our Intermediate Python for Data Science course.

With OOP, your code will grow in complexity as your program gets larger. You will have different classes, subclasses, objects, inheritance, instance methods, and more. You'll want to keep your code properly structured and readable. To do so, it is advised to follow design patterns. These are design principles that represent a set of guidelines to avoid bad design. They each represent a specific problem that often reoccurs in Python OOP and describe the solution to that problem, which can then be used repeatedly. These OOP design patterns can be classified into several categories: creational patterns, structural patterns, and behavioral patterns. An example of a creational pattern is the singleton, which should be used when you want to make sure that only one instance of a class can be created. A Python iterator, which is used to loop over all objects in a collection, is an example of a behavioral pattern.