Object-oriented programming (OOP) is a programming paradigm that uses objects and classes to structure software programs. Python supports OOP, allowing developers to model real-world entities as classes and objects.
In Python, classes and objects are fundamental building blocks of object-oriented programming (OOP). They allow you to create blueprints for data structures (classes) and instantiate those blueprints to create individual objects.
A class is a blueprint for creating objects. It defines a set of attributes and methods that the created objects will have.
Defining a Class:
class MyClass:
# Class attribute
class_attribute = "I am a class attribute"
# Initializer method (constructor)
def __init__(self, attribute1, attribute2):
self.attribute1 = attribute1 # Instance attribute
self.attribute2 = attribute2 # Instance attribute
# Instance method
def instance_method(self):
return f"attribute1: {self.attribute1}, attribute2: {self.attribute2}"
# Class method
@classmethod
def class_method(cls):
return cls.class_attribute
# Static method
@staticmethod
def static_method():
return "I am a static method"
An object is an instance of a class. It represents a specific example of the class with actual values.
Creating an Object:
# Create an object (instance) of MyClass
my_object = MyClass("value1", "value2")
# Access instance attributes
print(my_object.attribute1) # Output: value1
print(my_object.attribute2) # Output: value2
# Call instance method
print(my_object.instance_method()) # Output: attribute1: value1, attribute2: value2
# Call class method
print(MyClass.class_method()) # Output: I am a class attribute
# Call static method
print(MyClass.static_method()) # Output: I am a static method
3.1 Class Attributes:
Class attributes are shared by all instances of the class. They are defined within the class but outside any methods.
Example:
class Dog:
species = "Canis familiaris" # Class attribute
def __init__(self, name, age):
self.name = name # Instance attribute
self.age = age # Instance attribute
# All Dog objects share the class attribute
dog1 = Dog("Buddy", 9)
dog2 = Dog("Lucy", 3)
print(dog1.species) # Output: Canis familiaris
print(dog2.species) # Output: Canis familiaris
# Changing the class attribute
Dog.species = "Canis lupus"
print(dog1.species) # Output: Canis lupus
print(dog2.species) # Output: Canis lupus
3.2 Instance Attributes:
Instance attributes are unique to each instance. They are defined within the __init__ method or other instance methods using self.
Example:
class Dog:
def __init__(self, name, age):
self.name = name # Instance attribute
self.age = age # Instance attribute
dog1 = Dog("Buddy", 9)
dog2 = Dog("Lucy", 3)
# Each dog object has its own instance attributes
print(dog1.name) # Output: Buddy
print(dog2.name) # Output: Lucy
4.1 Instance Methods:
Instance methods operate on the instance of the class. They can access instance attributes and other instance methods using self.
Example:
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def description(self):
return f"{self.name} is {self.age} years old"
dog1 = Dog("Buddy", 9)
print(dog1.description()) # Output: Buddy is 9 years old
4.2 Class Methods:
Class methods are bound to the class, not the instance. They can access class attributes using cls.
Example:
class Dog:
species = "Canis familiaris"
@classmethod
def get_species(cls):
return cls.species
print(Dog.get_species()) # Output: Canis familiaris
4.3 Static Methods:
Static methods do not operate on an instance or the class. They are defined using the @staticmethod decorator.
Example:
class Dog:
@staticmethod
def bark():
return "Woof!"
print(Dog.bark()) # Output: Woof!