CLASS BASICS

Designing classes in Python involves defining the attributes and methods that represent the behavior and properties of objects within your application. Here are the key steps to designing classes in Python:

1. Identify the Purpose of the Class:

Understand what the class represents and its role within your application. Determine what data it needs to store and what actions it needs to perform.

2. Define Class Attributes:

Define the attributes (data members) that represent the properties of objects belonging to the class. These attributes will store the state of each object.

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

3. Define Class Methods:

Define the methods (functions) that represent the behavior or actions that objects of the class can perform. These methods can manipulate the object's state or perform other tasks.

class 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} engine started.")

    def stop_engine(self):
        print(f"{self.make} {self.model} engine stopped.")

4. Encapsulation:

Encapsulate the class attributes and methods to control access to them. Use access modifiers such as public, protected, and private to define the visibility of attributes and methods.

class Car:
    def __init__(self, make, model, year):
        self._make = make  # Protected attribute
        self._model = model  # Protected attribute
        self._year = year  # Protected attribute

    def start_engine(self):
        print(f"{self._make} {self._model} engine started.")

    def stop_engine(self):
        print(f"{self._make} {self._model} engine stopped.")

5. Inheritance:

Consider using inheritance to create a hierarchy of classes. Subclasses inherit attributes and methods from their parent class and can have their own specialized behavior.

class ElectricCar(Car):
    def __init__(self, make, model, year, battery_capacity):
        super().__init__(make, model, year)
        self.battery_capacity = battery_capacity

    def charge_battery(self):
        print(f"{self._make} {self._model} battery charging.")

6. Polymorphism:

Use polymorphism to allow objects of different classes to be treated interchangeably. Define methods with the same name in different classes to achieve polymorphic behavior.

class GasolineCar(Car):
    def __init__(self, make, model, year, fuel_capacity):
        super().__init__(make, model, year)
        self.fuel_capacity = fuel_capacity

    def refuel(self):
        print(f"{self._make} {self._model} refueled.")

7. Testing:

Test your class by creating instances and calling methods to ensure they behave as expected.

my_car = Car("Toyota", "Camry", 2022)
my_car.start_engine()  # Output: Toyota Camry engine started.

By following these steps, you can design classes in Python that accurately represent the entities and behaviors in your application, promoting code organization, reusability, and maintainability.

Composition and inheritance are two fundamental concepts in object-oriented programming (OOP) for building relationships between classes. Let's explore each concept:

Composition:

Composition involves building complex objects by combining simpler objects as parts. It represents a "has-a" relationship, where one class contains another class as a component.

Example:

Consider a Car class composed of Engine, Wheel, and Battery objects.

class Engine:
    def start(self):
        print("Engine started")

class Wheel:
    def rotate(self):
        print("Wheel rotating")

class Battery:
    def charge(self):
        print("Battery charging")

class Car:
    def __init__(self):
        self.engine = Engine()
        self.wheels = [Wheel() for _ in range(4)]
        self.battery = Battery()

    def start(self):
        self.engine.start()

my_car = Car()
my_car.start()  # Output: Engine started

Composition allows for flexibility and loose coupling between classes. Changes to the composed classes don't directly affect the container class.

Inheritance:

Inheritance involves creating a new class (subclass) based on an existing class (superclass). The subclass inherits attributes and methods from the superclass and can also define its own attributes and methods.

Example:

Consider a superclass Animal and subclasses Dog and Cat.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

my_dog = Dog()
my_cat = Cat()

my_dog.speak()  # Output: Woof!
my_cat.speak()  # Output: Meow!

Inheritance promotes code reuse and allows for specialization of behavior. Subclasses can override methods from the superclass to provide their own implementation.

When to Use Each:

  • Use composition when objects are made up of other objects and have a "has-a" relationship. It's often used when there's no clear hierarchical relationship between classes.
  • Use inheritance when there's a clear hierarchical relationship between classes, and one class represents a more specialized version of another class.

In practice, both composition and inheritance can be used together to build complex systems with clear relationships between objects. However, composition is generally favored over deep inheritance hierarchies to avoid the issues associated with tight coupling and the fragile base class problem.

Objects, also known as instances, are individual entities created from a class. In Python, a class serves as a blueprint for creating objects with predefined attributes and methods. Here's a closer look at objects or instances:

Creating Objects:

You create an object by calling the class name followed by parentheses. This invokes the class's constructor, __init__, to initialize the object.

class MyClass:
    def __init__(self, name):
        self.name = name

# Creating objects
obj1 = MyClass("Alice")
obj2 = MyClass("Bob")

Attributes:

Attributes are variables associated with objects. They represent the state or characteristics of an object. Each object can have its own set of attributes.

# Accessing attributes
print(obj1.name)  # Output: Alice
print(obj2.name)  # Output: Bob

Methods:

Methods are functions defined within a class and associated with objects. They define the behavior or actions that objects can perform.

class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hello, {self.name}!"

# Calling methods
print(obj1.greet())  # Output: Hello, Alice!
print(obj2.greet())  # Output: Hello, Bob!

Multiple Objects:

You can create multiple objects (instances) from the same class, each with its own attributes and methods.

obj1 = MyClass("Alice")
obj2 = MyClass("Bob")

Modifying Attributes:

You can modify the attributes of an object directly.

obj1.name = "Alice Smith"

Deleting Objects:

You can delete an object using the del keyword. This removes the object and frees up memory.

del obj1

Object Identity and Comparison:

Each object has a unique identity (id) in memory. You can compare objects using their identities.

obj1 = MyClass("Alice")
obj2 = MyClass("Alice")
print(obj1 is obj2)  # Output: False (Different objects)

Objects are the fundamental building blocks of object-oriented programming in Python. They allow you to represent real-world entities, encapsulate data, and define behavior within your programs.

Table of Contents