An Introduction to Object-Oriented Concepts in Python, Part 1
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
In this article, I'll show you how to use Python from an object-oriented (OO) point of view. If you're unfamiliar with object-oriented concepts such as inheritance, encapsulation, and polymorphism, read my article "A Primer on Object-Oriented Concepts" before continuing with this article.
This article builds on my earlier Python programming series "An Introduction to Python for the Experienced Programmer," Part 1, Part 2, and Part 3. If you're unfamiliar with Python, I recommend reading that series before continuing with this article.
Python is often viewed mainly as a scripting language, but it can also implement object-oriented concepts by using classes. This design is important for building web-based applications that implement the Model View Controller (MVC) application architectural design pattern. This capability gives Python a decided advantage over other scripting languages such as JavaScript. As with JavaScript, in Python everything is essentially an object, making the language highly flexible and easy to use. However, unlike Python, JavaScript is a prototype language, which means that objects clone other objects to create new object instances. Python can create new object types like C# and Java can, making the language more object-centric and less prototype-centric.
The programming examples in this article use Python 3.3.2.
Python Classes
As in other OO languages, the main type of object in Python is the Class object. In Python, declaring a class is easy:
class PythonClass:
pass
We use the colon to indicate that statements will follow, in an indented sequence. A class name can only be composed of letters, underscores, and numbers. As in Java and .NET, the Python style guide recommends that class names use CamelCase notation, starting with a capital letter.
While this is a very basic definition of a class, we can still use it in Python. The pass keyword tells Python that no further action needs to be taken. It's like an empty set of braces ({}) in other languages. To create an instance of a class, we simply use the class name followed by the parentheses, as with other languages:
myClass = PythonClass()
You may be wondering whether Python classes have constructors. Python doesn't have explicit constructors; however, it has something similar to a constructor: a method called __init__. This method is called immediately after a class is executed. The syntax for using the method is as follows:
class PythonClass:
def __init__(self):
print('hello')
myClass = PythonClass()
If you run this code, you'll see the message 'hello' printed to the screen. The self keyword tells the Python interpreter that this is a newly created class object. The self keyword is used when defining all methods of a class, but when it's not used with the __init__ method, it refers to the instance whose method was called. In this case, the calling instance is the PythonClass. You can think of self as the same thing as this, commonly used with other languages such as Java. Notice that when you call a method, you don't need to pass the self argument, as it's always implicitly defined as a Python method parameter.
Attributes
Attributes are the instance variables of your class. With Python, you can even define the attributes outside the scope of the actual class by using an object instance. For example, the code below assigns two variables to the class:
class PythonClass:
def __init__(self):
pass
myClass = PythonClass()
myClass.x = 10
myClass.y = 11
print(myClass.x)
print(myClass.y)
This is the same thing as defining the attributes within the scope of the class, as it's done in other languages such as Java and .NET:
class PythonClass:
x = 10
y = 10
def __init__(self):
pass
myClass = PythonClass()
print(myClass.x)
print(myClass.y)
What's the advantage of being able to define instance variables outside the scope of the class? I haven't really found one, except that it's a more generic implementation of the class. By not defining the instance variables within the class, we basically can use any variable at any time, given the context in which the variables will be used. This is flexible if you want so-called "open-ended" classes.
As with functions in Python, classes can take any number of arguments. For example, consider the following class declaration:
class PythonClass:
' This is a Python class with two attributes and two methods.'
x = 10
y = 10
def __init__(self):
pass
def method1(self, x,y):
self.x = x
self.y = y
myClass = PythonClass()
myClass.method1(5,4)
print(myClass.x)
print(myClass.y)
In this example, a new method is added, called method1. This method takes two parameters called x and y and assigns the values passed into the method to the attributes of the calling instance, which in this case is the PythonClass instance. If you run the code, you'll get the values 5 and 4. Essentially, we've changed the original value assignments of the attributes initially declared for the class.
Python classes can have what are called docStrings. They're simply strings enclosed in single quotes ('') or double quotes (""). These strings are often just comments for methods in your class, or an overall description of your class.
Conclusion
In this article, you learned how classes work in Python. Examples were given to define classes with multiple methods and arguments.
Classes are essentially the backbone of any OO language. Some key things to know about Python classes: The self keyword references an instance of the calling class.
You can define attributes outside the scope of the class. This differs from other languages such as Java and .NET, where the attributes are always defined within the class itself.
Once you know how to do one Python class, you know how to do them all.
In Part 2 of this series, I'll show you how to subclass Python classes and use them for other OO concepts like inheritance and polymorphism, along with learning more about other object concepts such as modules and packages.