{"id":2682,"date":"2021-10-25T08:27:03","date_gmt":"2021-10-25T08:27:03","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=2682"},"modified":"2025-03-31T07:48:36","modified_gmt":"2025-03-31T07:48:36","slug":"python-object-oriented-programming","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-oop\/python-object-oriented-programming\/","title":{"rendered":"Python Object-oriented Programming"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn object-oriented programming in Python, including essential concepts such as objects, classes, attributes, methods, inheritances, overriding methods, etc.<\/p>\n\n\n\n

Introduction to Python Object-oriented Programming #<\/a><\/h2>\n\n\n\n

Everything in Python is an object. An object has a state and behaviors. To create an object, you define a class first. And then, from the class, you can create one or more objects. The objects are instances of a class.<\/p>\n\n\n\n

Define a class #<\/a><\/h2>\n\n\n\n

To define a class<\/a>, you use the class<\/code> keyword followed by the class name. For example, the following defines a Person<\/code> class:<\/p>\n\n\n

class<\/span> Person<\/span>:<\/span>\n    pass<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To create an object from the Person<\/code> class, you use the class name followed by parentheses ()<\/code>, like calling a function:<\/p>\n\n\n
person = Person()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Define instance attributes #<\/a><\/h2>\n\n\n\n
Python is dynamic. It means that you can add an attribute to an instance of a class dynamically at runtime. <\/p>\n\n\n\n
For example, the following adds the name<\/code> attribute to the person<\/code> object:<\/p>\n\n\n
person.name = 'John'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
However, if you create another Person<\/code> object, the new object won’t have the name<\/code> attribute.<\/p>\n\n\n\n
class<\/span> Person<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, age)<\/span>:<\/span>\n        self.name = name\n        self.age = age<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When you create a Person<\/code> object, Python automatically calls the __init__<\/code> method to initialize the instance attributes. In the __init__<\/code> method, the self<\/code> is the instance of the Person<\/code> class. <\/p>\n\n\n\n
The following creates a Person<\/code> object named person<\/code>:<\/p>\n\n\n
person = Person('John'<\/span>, 25<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The person<\/code> object now has the name<\/code> and age<\/code> attributes. To access an instance attribute, you use the dot notation. For example, the following returns the value of the name attribute of the person<\/code> object:<\/p>\n\n\n
person.name<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Define instance methods #<\/a><\/h2>\n\n\n\n
The following adds an instance method called greet()<\/code> to the Person<\/code> class:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, age)<\/span>:<\/span>\n        self.name = name\n        self.age = age\n\n    def<\/span> greet<\/span>(self)<\/span>:<\/span>\n        return<\/span> f\"Hi, it's {self.name}<\/span>.\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To call an instance method, you also use the dot notation. For example:<\/p>\n\n\n
person = Person('John'<\/span>, 25<\/span>)\nprint(person.greet())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi, it's John<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Define class attributes #<\/a><\/h2>\n\n\n\n
Unlike instance attributes, class attributes are shared by all instances of the class. They are helpful if you want to define class constants or variables that keep track of the number of instances of a class.<\/p>\n\n\n\n
For example, the following defines the counter<\/code> class attribute in the Person<\/code> class:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    counter = 0<\/span>\n\n    def<\/span> __init__<\/span>(self, name, age)<\/span>:<\/span>\n        self.name = name\n        self.age = age\n\n    def<\/span> greet<\/span>(self)<\/span>:<\/span>\n        return<\/span> f\"Hi, it's {self.name}<\/span>.\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
You can access the counter<\/code> attribute from the Person<\/code> class:<\/p>\n\n\n
Person.counter<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Or from any instances of the Person<\/code> class:<\/p>\n\n\n
person = Person('John'<\/span>,25<\/span>)\nperson.counter<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To make the counter<\/code> variable more useful, you can increase its value by one once an object is created. To do it, you increase the counter<\/code> class attribute in the __init__<\/code> method:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    counter = 0<\/span>\n\n    def<\/span> __init__<\/span>(self, name, age)<\/span>:<\/span>\n        self.name = name\n        self.age = age\n        Person.counter += 1<\/span>\n\n    def<\/span> greet<\/span>(self)<\/span>:<\/span>\n        return<\/span> f\"Hi, it's {self.name}<\/span>.\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following creates two instances of the Person<\/code> class and shows the value of the counter<\/code>:<\/p>\n\n\n
p1 = Person('John'<\/span>, 25<\/span>)\np2 = Person('Jane'<\/span>, 22<\/span>)\nprint(Person.counter)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
2<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Define class method #<\/a><\/h2>\n\n\n\n
Like a class attribute, a class method is shared by all instances of the class. The first argument of a class method is the class itself. By convention, its name is cls<\/code>.  Python automatically passes this argument to the class method. Also, you use the @classmethod decorator to decorate a class method.<\/p>\n\n\n\n
The following example defines a class method that returns an anonymous Person<\/code> object:<\/p>\n\n\n
class<\/span> Person<\/span>:<\/span>\n    counter = 0<\/span>\n\n    def<\/span> __init__<\/span>(self, name, age)<\/span>:<\/span>\n        self.name = name\n        self.age = age\n        Person.counter += 1<\/span>\n\n    def<\/span> greet<\/span>(self)<\/span>:<\/span>\n        return<\/span> f\"Hi, it's {self.name}<\/span>.\"<\/span>\n\n    @classmethod<\/span>\n    def<\/span> create_anonymous<\/span>(cls)<\/span>:<\/span>\n        return<\/span> Person('Anonymous'<\/span>, 22<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows how to call the create_anonymous()<\/code> class method:<\/p>\n\n\n
anonymous = Person.create_anonymous()\nprint(anonymous.name)  # Anonymous<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Define static method #<\/a><\/h2>\n\n\n\n
A static method is not bound to a class or any instances of the class. In Python, you use static methods to group logically related functions in a class.  To define a static method, you use the @staticmethod<\/code> decorator. <\/p>\n\n\n\n
For example, the following defines a class TemperatureConverter<\/code> that has two static methods that convert from celsius to Fahrenheit and vice versa:<\/p>\n\n\n
class<\/span> TemperatureConverter<\/span>:<\/span>\n    @staticmethod<\/span>\n    def<\/span> celsius_to_fahrenheit<\/span>(c)<\/span>:<\/span>\n        return<\/span> 9<\/span> * c \/ 5<\/span> + 32<\/span>\n\n    @staticmethod<\/span>\n    def<\/span> fahrenheit_to_celsius<\/span>(f)<\/span>:<\/span>\n        return<\/span> 5<\/span> * (f - 32<\/span>) \/ 9<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To call a static method, you use the ClassName.static_method_name()<\/code> syntax. For example:<\/p>\n\n\n
f = TemperatureConverter.celsius_to_fahrenheit(30<\/span>)\nprint(f)  # 86<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Notice that Python doesn’t implicitly pass an instance (self<\/code>) as well as class (cls<\/code>) as the first argument of a static method.<\/p>\n\n\n\n
Single inheritance #<\/a><\/h2>\n\n\n\n
A class can reuse another class by inheriting it. When a child class inherits from a parent class, the child class can access the attributes and methods of the parent class. <\/p>\n\n\n\n
For example, you can define an Employee<\/code> class that inherits from the Person<\/code> class:<\/p>\n\n\n
class<\/span> Employee<\/span>(Person)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, age, job_title)<\/span>:<\/span>\n        super().__init__(name, age)\n        self.job_title = job_title<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Inside the __init__<\/code> method of the Employee<\/code> class calls the __init__<\/code>method of the Person<\/code> class to initialize the name<\/code> and age<\/code> attributes. The super()<\/code> allows a child class to access a method of the parent class.<\/p>\n\n\n\n
The Employee<\/code> class extends the Person<\/code> class by adding one more attribute called job_title<\/code>.<\/p>\n\n\n\n
The Person<\/code> is the parent class while the Employee<\/code> is a child class. To override the greet()<\/code> method in the Person<\/code> class, you can define the greet()<\/code> method in the Employee<\/code> class as follows:<\/p>\n\n\n
class<\/span> Employee<\/span>(Person)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, age, job_title)<\/span>:<\/span>\n        super().__init__(name, age)\n        self.job_title = job_title\n\n    def<\/span> greet<\/span>(self)<\/span>:<\/span>\n        return<\/span> super().greet() + f\" I'm a {self.job_title}<\/span>.\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The greet()<\/code> method in the Employee<\/code> is also called the greet()<\/code> method of the Person<\/code> class. In other words, it delegates to a method of the parent class.<\/p>\n\n\n\n
The following creates a new instance of the Employee<\/code> class and call the greet()<\/code> method:<\/p>\n\n\n
employee = Employee('John'<\/span>, 25<\/span>, 'Python Developer'<\/span>)\nprint(employee.greet())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi, it's John. I'<\/span>m a Python Developer.<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this tutorial, you have learned a brief overview of object-oriented programming in Python.<\/p>\n\n\n\n
Quiz #<\/a><\/h2>\n\n\n\n
To define and initialize an attribute for all instances of a class, you use the __init__<\/a><\/code> method. The following defines the Person<\/code> class with two instance attributes name<\/code> and age<\/code>:<\/p>\n\n\n
In this example, the person<\/code> is an instance of the Person<\/code> class. Classes are callable<\/a>.<\/p>\n\n\n\n