Python objects and classes

An object is a collection of data(attributes) and  behaviors(methods). A class, on the other hand, is a blueprint  that defines the attributes and methods that objects built from the class will possess.

You have already encountered and used objects and classes whether knowingly or unknowingly. The most obvious example of objects in python are the builtin data types.  For example, the builtin int class is used to represent integers, this means that any integer such as 1, 2, 3, -10, etc, is an instance/object of the int class.

print(type(9))
print(type(-100))
 Visualize 

<class 'int'><class 'int'>[Finished in 0.011555564822629094s]

The builtin type  function returns the class that the input object is an instance of.

Similarly, all the other data types  have their own associated classes  that define how they  can be used and manipulated. 

print(type('Python'))
print(type([1, 2, 3, 4]))
print(type({1: 'one', 2: 'two'}))
print(type({1, 2, 3}))
 Visualize 

<class 'str'><class 'list'><class 'dict'><class 'set'>[Finished in 0.010581996059045196s]

We now know  that a class is a blueprint or template for creating objects while objects are individual instantiations of the class that contain all the properties and behaviors defined in the class.  In the next part we will learn how classes are defined as well as how objects are created from the classes. 

Defining classes

In Python, classes are constructed using the class keyword.  The following example demonstrates the simplest class.

#This is a class
class MyClass:
   pass

 Visualize 

The class definition starts with the class keyword followed by a name (of our choice) identifying the class, and is terminated with a colon. 

class ClassName:
   #class body goes here

Creating objects from classes

We now have the simplest class we can have in Python, and as we said classes are simply blueprints. So how can we create objects from the blueprint?

To create objects from a class, we simply type the class name followed by a pair of parentheses. Just like how we call functions.

#define the class
class MyClass:
   pass

#create an object from the class
myclass_object = MyClass()
print(myclass_object)

#create another object
another_object = MyClass()
print(another_object)
 Visualize 

<__main__.MyClass object at 0x7f520565a4d0><__main__.MyClass object at 0x7f520565a510>[Finished in 0.01013154094107449s]

Adding attributes

Objects are just entities made of attributes and methods.  Our previous example class is fairy useless in that it doesn't have any properties or methods defined for its objects.

In this part we will learn how we create objects that have data associated with them. Let us consider a class named, Point as in a point in a Cartesian plane . For a point to be valid  It must have two properties : x- coordinate and  y - coordinate.

#Define the class
class Point:
    x = 0
    y = 0

#Create objects of the class 
p1 = Point()
p2 = Point()
p3 = Point()

#Override the value of attributes through assignment
p2.x = 1
p2.y = 3

p3.x = 4
p3.y = 6

print(p1.x, p1.y, sep = ' ')
print(p2.x, p2.y, sep = ' ')
print(p3.x, p3.y, sep = ' ')
 Visualize 

0 01 34 6[Finished in 0.009982430841773748s]

The above class, Point, defines the attributes x and y . Each object that is created from this class automatically inherits those two attributes. The objects can then override those points with unique values through assignment as in the case of p2 and p3. 

Add Methods

Methods  are behavior associated with a class and its objects. The syntax of a method is just similar to that of a function.  I know you are already familiar with function definition and usage.

let us define a method for the Point class called reset() that resets the point of a Point object back to (0, 0).

#define the class
class Point:
   x = 0
   y = 0

   #define the reset method
   def reset(self):
       self.x = 0.0
       self. y = 0.0

#create an object
p = Point()

#assign new values to the x and y attributes
p.x = 10
p.y = 15

print(p.x, p.y, sep = ' ')

#reset the values
p.reset()

print(p.x, p.y, sep = ' ')
 Visualize 

10 150.0 0.0[Finished in 0.010780930984765291s]

Let us define one more method called get_values  that returns the value of x and y from the Point object as a tuple i.e (x, y)

#define the class
class Point:
   x = 0
   y = 0

   #define the reset method
   def reset(self):
       self.x = 0.0
       self. y = 0.0
   def get_values(self):
       return (self.x, self.y)

#create an object
p = Point()

#assign new values to the x and y attributes
p.x = 10
p.y = 15

print(p.get_values())

#reset the values
p.reset()

print(p.get_values())
 Visualize 

(10, 15)(0.0, 0.0)[Finished in 0.012386834947392344s]

Objects referencing themselves

The self argument that you've just seen above is  a special one in that it refers to the current instance of the class.

When we  are assigning values outside a class,  we use normal assignment.

#define a class 
class Point():
    x = 0
    y = 0

p = Point()
p. x = 10
p.y = 7

print(p.x, p.y, sep = ' ')
 Visualize 

10 7[Finished in 0.009979995898902416s]

The self argument helps us achieve similar functionality when defining the class. 

class Point:
   def some_method(self):
        self.x = 10
        self.y = 7

p = Point()
p.some_method()

print(p.x, p.y, sep = ' ')
 Visualize 

10 7[Finished in 0.010067170020192862s]

Normally, the first argument of any function defined inside a class will reference the current instance of the class(unless we explicitly override this behavior using some special decorators).

"self" is the most conventionally used name for the first argument of instance methods . It is similar to "this" in other languages such as c++.

Consider the following example.

class Point:
    x = 0
    y = 0
    def reset():
       x = 0
       y = 0

p = Point()
p.reset()
 Visualize 

Traceback (most recent call last):  File "<string>", line 9, in <module>TypeError: Point.reset() takes 0 positional arguments but 1 was given[Finished in 0.010004796087741852s]

An error is raised indicating that an argument was passed to the some_method function. This is because, in the background, Python tried to pass instance p to the some_method function and the function does not take any arguments. 

Methods can take other arguments alongside 'self'

Like normal function, methods can specify the arguments that should be passed to it when being called . But we now know that the first parameter of any method should be self.

Consider our example of the class Point, we can define a method called update which will take two arguments, x and y  and then update the existing points with the given values.

#define the class
class Point:
   x = 0
   y = 0
   #define the update method
   def update(self, x, y):
       self.x = x
       self.y = y

p = Point()
print(p.x, p.y, sep = ' ')

#Update the value of x and y for object p
p.update(7, 12)
print(p.x, p.y)
 Visualize 

0 07 12[Finished in 0.012627716874703765s]

In the next part we will look at class constructors.

Summary