In [1]:
name = '2016-05-06-classes'
title = 'Python basics: classes'
tags = 'basics, oop'
author = 'Denis Sergeev'
In [2]:
from nb_tools import connect_notebook_to_post
from IPython.core.display import HTML
html = connect_notebook_to_post(name, title, tags, author)
We start with the introduction from Python docs [1]
Compared with other programming languages, Python’s class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.
Python supports object-oriented programming (OOP). The goals of OOP are [2]:
Using Python, you inevitably run into using classes, even if you don't create one yourself. Every object in Python is defined by its class and has class-specific attributes and methods.
For example, let's create a string:
In [3]:
s = 'hello world'
Check its type:
In [4]:
type(s)
Out[4]:
Then, using dir() function, we can print out all the methods of a str object.
In [5]:
print(dir(s))
Note: a convenience to pronounce __add__ is "dunder add", where dunder stands for double underscore
Numpy arrays are a specific class as well, with a bunch of array-specific methods and attributes.
In [6]:
import numpy as np
In [7]:
a = np.zeros((10,10))
In [8]:
print(dir(a))
The simplest way to create a class:
In [9]:
class MyAwesomeClass:
pass
Note: According to PEP8, class names should normally use the CapWords convention.
Now, create a variable using the just created class:
In [10]:
c = MyAwesomeClass()
In [11]:
c
Out[11]:
Let's define a bit more useful, but still a very simple class [3].
In [12]:
class Creature:
def __init__(self, name, the_level):
self.name = name
self.level = the_level
def __repr__(self):
return "Creature: {} of level {}".format(
self.name, self.level
)
In [13]:
tiger = Creature('big evil tiger', 21)
In [14]:
tiger
Out[14]:
Note the difference in the output after we added a custom __repr__ method to our class.
Shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances [1]:
In [15]:
class Dog:
tricks = [] # mistaken use of a class variable
def __init__(self, name):
self.name = name
def add_trick(self, trick):
self.tricks.append(trick)
In [16]:
F = Dog('Fido')
B = Dog('Buddy')
In [17]:
F.add_trick('roll over')
B.add_trick('play dead')
In [18]:
F.tricks
Out[18]:
Correct design of the class should use an instance variable instead:
In [19]:
class Dog:
def __init__(self, name):
self.name = name
self.tricks = [] # creates a new empty list for each dog
def add_trick(self, trick):
self.tricks.append(trick)
In [20]:
F = Dog('Fido')
B = Dog('Buddy')
In [21]:
F.add_trick('roll over')
B.add_trick('play dead')
In [22]:
F.tricks
Out[22]:
In [23]:
B.tricks
Out[23]:
The best way to understand the logic and convenience of OOP is by examining many examples of its use.
In [24]:
class Vec2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vec2D(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vec2D(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return self.x*other.x + self.y*other.y
def __abs__(self):
return math.sqrt(self.x**2 + self.y**2)
def __str__(self):
return 'this is vector components: {0:g} {1:g}'.format(self.x, self.y)
def __ne__(self, other):
return self.x != other.x or self.y != other.y
Let us play with some Vec2D objects:
In [25]:
u = Vec2D(0,1)
v = Vec2D(1,0)
w = Vec2D(1,1)
In [26]:
a = u + v
In [27]:
print(a)
In [28]:
a == w
Out[28]:
In [29]:
a = u * v
In [30]:
print(a)
In [31]:
u == v
Out[31]:
Let's look at another example that can be useful in Atmospheric and Oceanic sciences. This Wind3D instance is pretty simple, having only two specific methods beside the __init__.
In [32]:
class Wind3D(object):
def __init__(self, u, v, w):
"""
Initialize a Wind3D instance
"""
if (u.shape != v.shape) or (u.shape != w.shape):
raise ValueError('u, v and w must be the same shape')
self.u = u.copy()
self.v = v.copy()
self.w = w.copy()
def magnitude(self):
"""
Calculate wind speed (magnitude of wind vector) and store it within the class
"""
self.mag = np.sqrt(self.u**2 + self.v**2 + self.w**2)
def kinetic_energy(self):
"""
Calculate KE and return it
"""
return 0.5*(self.u**2 + self.v**2 + self.w**2)
The bot in action: https://twitter.com/AtmosSciBot
Source code: https://github.com/dennissergeev/atmosscibot
[1] Python documentation: https://docs.python.org/3/tutorial/classes.html
[2] Short example from Scientific Python tutorial: http://www.scipy-lectures.org/intro/language/oop.html
[3] Python Jumpstart Course: https://github.com/mikeckennedy/python-jumpstart-course-demos
[4] H.P. Langtangen (2014) "A Primer on Scientific Programming with Python": http://hplgit.github.io/primer.html/doc/pub/half/book.pdf
In [33]:
HTML(html)
Out[33]: