Python Object-Oriented Programming

In this tutorial, you’ll find out about Object-Oriented Programming (OOP) in Python and its fundamental concept with the help of examples.

Object-Oriented Programming

Python is a multi-worldview programming language. It underpins diverse programming draws near.

One of the popular approaches to solve a programming issue is by making objects. This is known as Object-Oriented Programming (OOP).

An object has two characteristics:

• attributes

• behavior

Let’s take an example:

A parrot is can be an object, as it has the following properties:

• name, age, color as properties

The concept of OOP in Python centers around making reusable code. This idea is otherwise called DRY (Don’t Repeat Yourself).

In Python, the idea of OOP follows some fundamental principles:

Class

A class is a blueprint for the object.

We can think of the class as a sketch of a parrot with labels. It contains all the details about the name, colors, size, etc. Based on these descriptions, we can study about the parrot. Here, a parrot is an object.

The example of a class of parrot can be :

class Parrot:
    pass

Here, we use the class keyword to define an empty class Parrot. From class, we construct instances. An instance is a specific object created from a particular class.

Object

An object (example) is an instantiation of a class. At the point when class is characterized, just the depiction of the item is characterized. In this manner, no memory or capacity is designated.

The example for the object of parrot class can be:

obj = Parrot()

Here, obj is an object of class Parrot.

Suppose we have details of parrots. Now, we are going to show how to build the class and objects of parrots.

Example 1: Creating Class and Object in Python

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

Output

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

In the above program, we created a class with the name Parrot. Then, we define attributes. The attributes are a characteristic of an object.

These attributes are defined inside the __init__ method of the class. It is the initializer method that is first run as soon as the object is created.

Then, we create instances of the Parrot class. Here, blu and woo are references (value) to our new objects.

We can access the class attribute using __class__.species. Class attributes are the same for all instances of a class. Similarly, we access the instance attributes using blu.name and blu.age. However, instance attributes are different for every instance of a class.

To learn more about classes and objects, go to Python Classes and Objects

Methods

Methods are functions defined inside the body of a class. They are used to characterize the behaviors of an object.

Example 2: Creating Methods in Python

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def python(self, programming):
        return "{} python {}".format(self.name, programming)

    def online class(self):
        return "{} is now online classes".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.python("'Happy'"))
print(blu.online class())

Blu python 'Happy'
Blu is now online classes

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

Selling Price: 900
Selling Price: 900
Selling Price: 1000

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

Parrot can fly
Penguin can't fly

worldofitech