Think of classes as blueprints for creating objects in code. They outline what kind of information an object should have and what actions it can perform.

In programming, we use classes a lot, especially in something called object-oriented programming (OOP). When we create a class, we’re essentially creating a new type of thing that our program can work with. These things, called “class instances,” follow the rules laid out in the class blueprint. This helps organize our code and makes it easier to manage and understand.

How to Create a Class in Python –

class Home:
  # Class body starts here

Note: The example above would actually be invalid because class definitions cannot be empty. However, the pass statement can be used as a placeholder to avoid errors:

class Home:
  pass

class Home:
  def __init__(self, rooms, stories):
    # Setting instance variables
    self.rooms = rooms
    self.stories = stories

The above code defines a Python class called Home. Classes are like blueprints for creating objects in code.

The Home class has an __init__ method, which is a special method called a constructor. This method is automatically called when a new instance of the Home class is created.

The __init__ method takes three parameters: self, rooms, and stories.

• The self parameter refers to the instance of the class itself and is used to access variables and methods within the class.
• The rooms parameter represents the number of rooms in the home, and stories represents the number of stories (or floors) the home has.

Inside the __init__ method, two instance variables (self.rooms and self.stories) are defined and initialized using the values passed as arguments to the constructor. These instance variables store the number of rooms and stories for each specific instance of the Home class.

What are Class Instances

a class instance in Python is like an example or a copy of a blueprint (class).

Imagine a class as a blueprint for creating objects, like a blueprint for a house. Now, when you want to build an actual house based on that blueprint, you create an instance of that blueprint. This instance is like a real house based on the design in the blueprint.

Similarly, in Python, a class instance is created when you use the blueprint (class) to make a specific object with its own unique characteristics. Each instance (or object) created from the class can have its own set of attributes and methods, just like each house built from the blueprint can have its own unique features.

Objects can be created or instantiated from classes. These objects are known as class instances and are created by setting a variable equal to the class name followed by parentheses ():

my_home = Home()

Here, the instance name is my_home, which derives from the Home class. Calling this line implicitly calls the Home class’s __init__() method.

What is a Class Attribute?

A class attribute in Python is like a shared characteristic among all instances created from a class, similar to a feature common to all houses built from the same blueprint.

For example, if we have a class called “Car” with a class attribute “manufacturer” set to “Toyota”, it means that all cars created from this class will automatically have “Toyota” as their manufacturer.

So, no matter how many cars we create from the “Car” class, they will all be associated with the “Toyota” manufacturer by default. It’s like saying all cars built from this blueprint are made by Toyota, regardless of their individual characteristics like color or model.

Class attributes are variables that are defined outside of all methods and have the same value for every instance of the class. They also can be accessed via the class name rather than the instance name. Setting the variable via the class name will change it for all instances.

class Bird:
  # Class attribute
  is_hungry = True

parakeet = Bird()
parrot = Bird()


print("Birds are hungry!")
print("Feeding birds...")

parakeet.is_hungry = False
parrot.is_hungry = False

print("Birds fed!")

What are Methods in Python ?

In Python, methods are functions defined within a class that can perform actions on objects created from that class. They encapsulate behavior related to those objects and enable interaction with them.

Here’s a simple explanation with an example:

Let’s say we have a class called Dog, which represents dogs. Within this class, we define a method called bark(). This bark() method defines the action of a dog barking. When we create instances of the Dog class (actual dogs), we can then call the bark() method on those instances to make them bark. In this example, bark() is a method of the Dog class. When we call my_dog.bark(), it triggers the bark() method associated with the my_dog instance, causing it to print “Woof! Woof!”.

class Dog:
    def bark(self):
        print("Woof! Woof!")

# Creating an instance of the Dog class
my_dog = Dog()

# Calling the bark() method on the my_dog instance
my_dog.bark()  # Output: Woof! Woof!

class Bird:
  # Class attribute
  is_hungry = True

  def feed_bird(self, food):
    if(self.is_hungry):
      self.is_hungry = False
      print(f"Feeding with {food}. Bird fed!")
    else:
      print("Bird already ate.")

sparrow = Bird()

sparrow.feed_bird('seeds')
sparrow.feed_bird('oats')

1. Class Definition:
   • class Bird:: This line initiates the definition of a class named “Bird”.
2. Class Attribute:
   • is_hungry = True: This is a class attribute, denoted by is_hungry, which is initially set to True.
   • Class attributes are shared among all instances of the class, meaning all objects created from this class will have this attribute initialized to the same value unless specifically changed for individual instances.
3. Method Definition:
   • def feed_bird(self, food):: This line defines a method (a function within a class) named feed_bird.
   • The method takes two parameters: self (which refers to the instance of the class) and food.
4. Method Implementation:
   • Inside the feed_bird method:
     • if(self.is_hungry):: This condition checks if the is_hungry attribute of the bird instance is True.
     • self.is_hungry = False: If the bird is hungry (is_hungry is True), it sets is_hungry to False, indicating that the bird has been fed.
     • print(f"Feeding with {food}. Bird fed!"): It prints a message indicating that the bird is being fed with the specified food.
     • else:: If the bird is not hungry (is_hungry is False), it executes the following block:
       • print("Bird already ate."): It prints a message indicating that the bird has already eaten.
5. Instance Creation:
   • sparrow = Bird(): This line creates an instance of the Bird class named sparrow.
6. Method Invocation:
   • sparrow.feed_bird('seeds'): This line calls the feed_bird method on the sparrow instance, passing 'seeds' as the food argument.
   • sparrow.feed_bird('oats'): Similarly, this line calls the feed_bird method on the sparrow instance, passing 'oats' as the food argument.

In summary, this code defines a Bird class with a class attribute is_hungry, indicating whether the bird is hungry or not. The feed_bird method feeds the bird with food if it’s hungry, updating its is_hungry status accordingly. The code then creates a sparrow instance and feeds it with seeds and oats, demonstrating the usage of class attributes and methods within Python classes.

class instances, attributes, and methods form the fundamental building blocks of object-oriented programming in Python.

Class instances represent individual objects created from a class, each with its own unique set of attributes and behaviors. Attributes are variables associated with a class or its instances, storing data specific to each instance. Methods, on the other hand, are functions defined within a class that enable objects to perform actions or behaviors.

Together, these concepts allow for the creation of modular, reusable code that models real-world entities and their interactions. By encapsulating data and functionality within classes, Python developers can create more organized, maintainable, and scalable codebases.

Understanding class instances, attributes, and methods is essential for mastering object-oriented programming in Python and building robust, flexible software solutions. Whether designing complex systems or simple utilities, leveraging these concepts empowers developers to write cleaner, more efficient code that meets the demands of modern software development.