1. What is a Class in Python?In Python, a class is a blueprint or a template for creating objects that have similar characteristics and behaviors. It provides a structure for organizing and grouping data and functions that operate on that data. In this tutorial, we’ll go over the basics of defining and using classes in Python.1.1. Defining a ClassTo define a class in Python, you use the class keyword, followed by the name of the class. Here is a simple example:pythonCopy codeclass Person:
passThis creates a new class called Person that doesn’t do anything. The pass statement is used as a placeholder for future code.2. Class AttributesA class can have attributes that are shared by all instances of the class. To define a class attribute, you simply create a variable inside the class:pythonCopy codeclass Person:
species = ‘human’In this case, species is a class attribute that is shared by all instances of the Person class. You can access this attribute using the class name:pythonCopy codeprint(Person.species) # Output: ‘human’
3. Class MethodsA class can also have methods, which are functions that are associated with the class. These methods can access and modify the class attributes and can be used to perform operations on instances of the class. To define a class method, you use the def keyword inside the class:pythonCopy codeclass Person:
species = ‘human’
def greet(self):
print(‘Hello, I am a’, self.species)In this example, greet() is a class method that takes one parameter (self), which refers to the instance of the class. The method simply prints a greeting that includes the species the attribute of the class.To use the class method, you create an instance of the class and call the method on that instance:pythonCopy codeperson = Person()
person.greet() # Output: ‘Hello, I am a human’4. Instance AttributesIn addition to class attributes, each instance of a class can have its own attributes that are specific to that instance. To define an instance attribute, you create a variable inside the __init__() method of the class:pythonCopy codeclass Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(‘My name is’, self.name, ‘and I am’, self.age, ‘years old.’)In this example, the __init__() the method is used to initialize the name and age attributes of the instance. These attributes are specific to each instance of the Person class. The introduce() the method is used to print out the name and age of the instance.To create an instance of the class, you simply call the class name with any required parameters:pythonCopy codeperson = Person(‘Alice’, 25)
person.introduce() # Output: ‘My name is Alice and I am 25 years old.’5. Private AttributesPrivate attributes are attributes that are intended to be used only within the class. They are prefixed with double underscores __ to make them private. Private attributes can only be accessed within the class using the same name or through instance methods defined within the class. They cannot be accessed directly from outside the class or even from subclasses.Here’s an example class that demonstrates private attributes:pythonCopy codeclass MyClass:
def __init__(self, public_attribute, private_attribute):
self.public_attribute = public_attribute
self.__private_attribute = private_attribute
def get_private_attribute(self):
return self.__private_attribute
def set_private_attribute(self, value):
self.__private_attribute = value
def print_attributes(self):
print(f’Public attribute: {self.public_attribute}’)
print(f’Private attribute: {self.__private_attribute}’)In this example, we define a class MyClass with a public attribute public_attribute and a private attribute __private_attribute. We also define instance methods get_private_attribute() and set_private_attribute() to get and set the value of the private attribute, respectively. The method print_attributes() is defined to print both the public and private attributes.pythonCopy codeobj = MyClass(‘public’, ‘private’)
print(obj.public_attribute) # Output: public
# This will raise an AttributeError because the attribute is private.
print(obj.__private_attribute)
print(obj.get_private_attribute()) # Output: private
obj.set_private_attribute(‘new value’)
print(obj.get_private_attribute()) # Output: new value
obj.print_attributes()
# Output: Public attribute: public
# Private attribute: new valueIn this example, we can access the public attribute public_attribute directly using the instance name. However, we cannot access the private attribute __private_attribute directly from outside the class. We can only access it using the instance methods get_private_attribute() and set_private_attribute(). When we call the print_attributes() method, we can see that both the public and private attributes are printed.Note that although private attributes cannot be accessed directly from outside the class, they can still be accessed using the _ClassName__private_attribute syntax. However, this is considered bad practice and should be avoided.6. Example Class that demonstrates each type of attribute:pythonCopy codeclass MyClass:
class_attribute = ‘class attribute’
def __init__(self, instance_attribute):
self.instance_attribute = instance_attribute
def instance_method(self):
print(‘This is an instance method.’)
@classmethod
def class_method(cls):
print(‘This is a class method.’)
@staticmethod
def static_method():
print(‘This is a static method.’)In this example, we define a class MyClass with a class attribute class_attribute, an instance attribute instance_attribute, an instance method instance_method(), a class method class_method(), and a static method static_method(). Here’s how we can access each of these attributes:pythonCopy codeprint(MyClass.class_attribute) # Output: class attribute
obj = MyClass(‘instance attribute’)
print(obj.instance_attribute) # Output: instance attribute
obj.instance_method() # Output: This is an instance method.
MyClass.class_method() # Output: This is a class method.
MyClass.static_method() # Output: This is a static method.In this example, class_attribute is a class attribute that is shared by all instances of the class. instance_attribute is an instance attribute that is specific to each instance of the class. instance_method() is an instance method that can only be called on instances of the class. class_method() is a class method that can be called on the class itself, and static_method() is a static method that can also be called on the class itself.2. Types of Classes in PythonIn Python, there are several types of classes that you can define, depending on your requirements. Here are the most common types of classes in Python:Simple Class:A simple class is the most basic type of class in Python. It defines attributes and methods, which can be used to represent an object. Here’s an example of a simple class:pythonCopy codeclass Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
print(f'{self.name} barks!’)In this example, we define a Dog class with two attributes, name and breed, and one method, bark(). The __init__() method is used to initialize the name and breed attributes with the values passed as arguments. The bark() method simply prints a message indicating that the dog is barking.Abstract Class:An abstract class is a class that cannot be instantiated directly but can be used as a base class for other classes. It defines abstract methods that must be implemented in any concrete subclass. Here’s an example of an abstract class:pythonCopy codefrom abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
print(‘Woof!’)In this example, we define an abstract class Animal that has one abstract method, make_sound(). The @abstractmethod decorator is used to indicating that this method must be implemented in any concrete subclass. We define a concrete subclass Dog that implements the make_sound() method by printing ‘Woof!’ to the console.Concrete Class:A concrete class is a class that can be instantiated and used directly. It doesn’t have any abstract methods that need to be implemented in any subclass. Here’s an example of a concrete class:pythonCopy codeclass Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def start_engine(self):
print(f'{self.make} {self.model} ({self.year}) engine started!’)In this example, we define a Car class with three attributes, make, model, and year, and one method, start_engine(). The __init__() method is used to initialize the attributes with the values passed as arguments. The start_engine() method simply prints a message indicating that the car’s engine has been started.Inherited Class:An inherited class is a class that inherits attributes and methods from a parent class. It can add new attributes and methods, or override existing ones. Here’s an example of an inherited class:pythonCopy codeclass Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
print(‘Animal makes sound!’)
class Dog(Animal):
def make_sound(self):
print(‘Woof!’)In this example, we define a Animal class with one attribute, name, and one method, make_sound(). We define a Dog class that inherits from Animal and overrides the make_sound() method with its own implementation. When make_sound() is called on an instance of Dog, it prints ‘Woof!’ to the console.Mixin Class:A mixin class is a class that provides specific functionality that can be added to other classes. It doesn’t have its own instance attributes but defines methods that can be used by other classes. Here’s an example of a mixin class:pythonCopy codeclass FlyMixin:
def fly(self):
print(f'{self.__class__.__name__} flies!’)
class Bird(FlyMixin):
def __init__(self, name):
self.name = name
class Plane(FlyMixin):
def __init__(self, model):
self.model = modelIn this example, we define a FlyMixin the class that has one method, fly(), which simply prints a message indicating that the object is flying. We define two classes, Bird and Plane, that inherit from FlyMixin and can use the fly() method. The Bird the class has an additional attribute, name, while the Plane the class has an additional attribute, model.Metaclass:A metaclass is a class that defines the behavior of other classes. It’s used to customize the behavior of class creation and class instances. Here’s an example of a metaclass:pythonCopy codeclass MyMeta(type):
def __new__(cls, name, bases, attrs):
attrs[‘class_name’] = name
return super().__new__(cls, name, bases, attrs)
class MyClass(metaclass=MyMeta):
passIn this example, we define a metaclass MyMeta that has a __new__() method. This method is called when a new class is created, and it adds a new attribute, class_name, to the class. We define a MyClass class that uses MyMeta as its metaclass, which means that MyMeta’s __new__() method is called when MyClass is created. When we create an instance of MyClass, it has a class_name attribute that is set to ‘MyClass’.Singleton Class:A singleton class is a class that allows only one instance to be created. This is useful when you want to ensure that there’s only one instance of a class in your program. Here’s an example of a singleton class:pythonCopy codeclass Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instanceIn this example, we define a Singleton class that has a private class attribute _instance, which is initially set to None. The __new__() method is used to create a new instance of the class if _instance is None, or return the existing instance if it’s not. When we create multiple instances of Singleton, we always get the same instance.Data Class:A data class is a class that is designed primarily to store data. It automatically generates special methods such as __init__(), __repr__(), __eq__(), and __hash__(). Here’s an example of a data class:pythonCopy codefrom dataclasses import dataclass
@dataclass
class Person:
name: str
age: int
email: strIn this example, we define a Person class using the @dataclass decorator. The class has three attributes, name, age, and email, which are automatically initialized by the __init__() method generated by dataclass. The __repr__(), __eq__(), and __hash__() methods are also automatically generated. We can create instances of Person and access its attributes directly, like this:pythonCopy codeperson = Person(‘John’, 30, ‘john@example.com’)
print(person.name) # Output: John
print(person.age) # Output: 30
print(person.email) # Output: john@example.comConclusionIn this tutorial, we’ve covered the basics of defining and using classes in Python. A class is a blueprint or a template for creating objects that have similar characteristics and behaviors. It provides a structure for organizing and grouping data and functions that operate on that data. We’ve looked at defining class attributes, class methods, instance attributes, and how to create instances of a class. With this knowledge, you can start building more complex programs using classes and objects.AuthorVaneesh BehlPassionately writing and working in Tech Space for more than a decade.
