Welcome to Chapter 9, where we delve into Object-Oriented Programming (OOP) in Python! 🚀 OOP is a programming paradigm that uses objects and classes, enabling a structured approach to simplify complex program structures. In this chapter, we’ll unravel the concepts of classes, objects, inheritance, and more, while also applying these concepts in a hands-on project: Library Management System.
Imagine you’re constructing a house. Before you start building, you need a blueprint. This blueprint provides all the details about the house: the number of rooms, their sizes, the layout, and so on. Once you have the blueprint, you can construct multiple houses based on that single design.
In the world of Object-Oriented Programming:
This analogy helps us understand that a class provides a structure or a template, and using that class, we can create several objects with similar properties (attributes) and behaviors (methods).
Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects”, which encapsulates data and functions that operate on the data. Python, being a multi-paradigm programming language, provides full-fledged support for OOP, enabling us to define classes, create objects, and work with inheritance and polymorphism.
In this chapter, we’ll explore:
Let’s embark on this journey by understanding the foundational concepts of OOP and gradually build upon them to create a Library Management System in our project section.
Imagine you’re considering different types of vehicles: cars, bicycles, and buses. Each of these vehicle types can be thought of as a class.
For instance:
Car class might have attributes like color, brand, number_of_wheels, and methods like start(), stop(), and park().Bicycle class might have attributes like brand, type (e.g., mountain, road), number_of_wheels, and methods like pedal(), brake(), and change_gear().Now, your friend’s red Toyota Corolla is an object (or instance) of the Car class, and your blue Giant mountain bike is an instance of the Bicycle class.
This exemplifies how classes act as blueprints for creating objects, and objects are specific instances of these classes.
A class can be thought of as a blueprint for creating objects. It defines a datatype by bundling data and methods that work on that data into one single unit. The data items and methods associated with the class are called attributes and methods, respectively.
Consider an example where Car is a class that has attributes like make, model, and year, and methods like start_engine(), and stop_engine().
An object is an instance of a class. When a class is defined, it merely describes what an object will be, but it is not an object itself. To use the functionalities provided by a class, you need to instantiate it.
Using the Car class example, a specific car object would be:
my_car = Car(make="Toyota", model="Corolla", year=2022)
Here’s a basic example of how to define a class and instantiate it:
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def display_info(self):
print(f"{self.year} {self.make} {self.model}")
# Instantiating the class
my_car = Car("Toyota", "Corolla", 2022)
# Accessing method
my_car.display_info()
In this example:
__init__(self, make, model, year): A special method called a constructor that is used to initialize the object. The self parameter refers to the instance of the object itself.display_info(self): A method to display car information.my_car = Car("Toyota", "Corolla", 2022): Instantiates the Car class, creating a new object my_car.my_car.display_info(): Calls the display_info method to print out the car’s information.class Car:
# Class Variable
car_type = "Sedan"
def __init__(self, make, model, year):
# Instance Variables
self.make = make
self.model = model
self.year = year
In the example above, car_type is a class variable, while make, model, and year are instance variables.
In the realm of Object-Oriented Programming, methods and attributes play a crucial role in managing object states and behaviors. Let’s delve deeper into these concepts to understand their significance and implementation in Python classes.
Imagine a university maintaining a database of students.
In this scenario:
Studentfirst_name, last_name, student_id, courses_enrolled, gpaenroll_course(course_name), drop_course(course_name), calculate_gpa()Each student in the university would be an object of the Student class. The methods allow the university to manage each student’s data effectively.
Attributes in classes are variables where data is stored. They represent the state or quality of an object. In Python, you have:
Example:
class Car:
# Class Attribute
wheels = 4
def __init__(self, make, model):
# Instance Attributes
self.make = make
self.model = model
In the Car class above, wheels is a class attribute, while make and model are instance attributes.
Methods are functions defined inside a class and are used to perform operations that sometimes utilize the attributes of the object they are called on. We categorize them as:
Example:
class Car:
# Class Attribute
wheels = 4
def __init__(self, make, model):
# Instance Attributes
self.make = make
self.model = model
# Instance Method
def display_info(self):
return f"{self.make} {self.model}"
# Class Method
@classmethod
def update_wheels(cls, new_value):
cls.wheels = new_value
# Static Method
@staticmethod
def is_motor_vehicle():
return True
In the Car class above, display_info is an instance method, update_wheels is a class method, and is_motor_vehicle is a static method.
Understanding methods and attributes is fundamental to implementing encapsulation and abstraction, which we will explore in the subsequent sections. Try defining your own classes with various methods and attributes and observe their behavior to solidify your understanding!
Consider a base class Animal that has basic methods like eat() and sleep(). Now, we can have subclasses like Bird and Fish. The Bird class might have a specific method like fly() while the Fish class might have a method like swim(). However, both Bird and Fish classes can still use the eat() and sleep() methods from the Animal class. This is inheritance in action.
Inheritance, a core concept of Object-Oriented Programming, allows a class (called a subclass) to utilize methods and attributes from another class (the superclass or base class). It provides a mechanism to promote code reuse and establish a hierarchical relationship between classes.
Let’s consider a general class, Vehicle, which has attributes and methods that are common to all vehicles. Another class, Car, can inherit from Vehicle, thereby gaining access to its methods and attributes while also being able to introduce its own specific methods and attributes.
class BaseClass:
pass
class DerivedClass(BaseClass):
pass
In this syntax, DerivedClass inherits from BaseClass, meaning all the methods and attributes of BaseClass are accessible by DerivedClass.
Polymorphism allows objects of different types to be treated as objects of a common super type. It enables using a single interface to represent different types of objects. More specifically, polymorphism allows a method to do different things based on the object it is acting upon, even though the method name remains the same.
class Vehicle:
def description(self):
print("This is a generic vehicle")
class Car(Vehicle):
def description(self):
print("This is a car")
In the example above, Car is a derived class that inherits from Vehicle and also changes the behavior of the description method.
In the next sections, we will delve deeper into encapsulation and abstraction, which are crucial for managing the data within our classes and for simplifying complex systems by modeling classes in a more user-friendly manner.
Consider a BankAccount class. The balance of a bank account is a private attribute since we don’t want it to be accessed directly and changed without proper checks.
However, we provide public methods like deposit(amount) and withdraw(amount) that have logic to ensure no invalid operations occur (e.g., withdrawing more than the current balance). This ensures that the balance attribute is encapsulated and protected from unwanted changes.
Encapsulation is one of the fundamental concepts in OOP. It refers to the bundling of data (attributes) and the methods (functions) that manipulate the data into a single unit or class. Moreover, it restricts direct access to some of the object’s components and can prevent the accidental modification of data.
In Python, encapsulation is achieved through private and protected access modifiers.
__ before the attribute or method name and cannot be accessed or modified directly. However, they can be accessed through methods within the class._, they can be accessed by subclasses.class Person:
def __init__(self, name, age):
self.name = name # public attribute
self.__age = age # private attribute
def get_age(self): # public method to access private attribute
return self.__age
In the above Person class, name is a public attribute, while __age is private. To access or modify __age, methods like get_age() should be utilized.
Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. In OOP, abstraction allows you to focus on a simplified view of the problem and ignore complex details.
In Python, abstraction can be achieved through abstract classes and methods.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
Here, Shape is an abstract class with an abstract method area(). Any subclass like Circle must provide an implementation for area().
Feel free to create your own classes and experiment with encapsulation and abstraction in Python to get a better understanding of these concepts!
In object-oriented programming (OOP), an interface defines a contract for a subclass and ensures that it implements a specific set of methods. The interface does not contain any logic but declares the methods that must be implemented within any child classes. In Python, interfaces are created using abstract classes and abstract methods.
from abc import ABC, abstractmethod
class Payment(ABC):
@abstractmethod
def make_payment(self, amount):
pass
class CreditCardPayment(Payment):
def make_payment(self, amount):
return f"Paid {amount} using Credit Card."
class MobileWalletPayment(Payment):
def make_payment(self, amount):
return f"Paid {amount} using Mobile Wallet."
In the example above, Payment is an interface that defines a contract make_payment for its subclasses CreditCardPayment and MobileWalletPayment. The @abstractmethod decorator indicates that the method make_payment must be implemented within any child classes derived from the Payment interface. This ensures that all the subclasses follow the same API structure.
Feel free to create your own interfaces and implement them in Python to gain a deeper understanding of this concept!
The SOLID principles are a set of design principles in object-oriented programming that, when combined together, make it more likely that a developer will create a system that is easy to maintain and scale over time. They are:
Feel free to explore and implement the SOLID principles and consider cohesion and coupling while designing your classes and objects in Python!
Consider a scenario where we want to calculate areas of different shapes. Utilizing classes, inheritance, and polymorphism, you can create a simple shape calculator as follows:
class Shape:
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
class Square(Shape):
def __init__(self, side):
self.side = side
def area(self):
return self.side * self.side
shapes = [Circle(5), Square(4)]
for shape in shapes:
print(f"A {shape.__class__.__name__} has an area of: {shape.area()}")
In the above example, Shape acts as a base class, and Circle and Square are subclasses implementing the area method in their own way. The objects Circle(5) and Square(4) are treated polymorphically as they are used through their superclass interface Shape.
Feel free to modify the example, add more shapes, and try to implement the concepts learned in this chapter!
Your challenge, should you decide to undertake it, is to design and implement a Library Management System. This system will serve as a hub for managing books, library patrons, and staff, ensuring smooth operations, easy accessibility, and accurate data management. By incorporating the principles of Object-Oriented Programming, you’ll craft a system that is robust, scalable, and maintainable.
Welcome to the Library Management System!
Options:
1. Check book availability
2. Borrow book
3. Return book
4. Add book
5. Quit
Select an option: 1
Enter the name of the book: 1984
1984 by George Orwell (1949) is available for borrowing.
Would you like to perform another action? (yes/no): no
Thank you for using the Library Management System. Goodbye!
With the guidance provided, you’re all set to start building your Library Management System:
/code/ directory./code/answer/ directory. Remember, there’s no single way to solve a problem in programming. The provided solution is just one perspective.Consistently document your code, ensuring future you or other developers can quickly understand its functionality.
While crafting your user interface, prioritize clarity and user experience.
Always consider the scalability of your system. Can it handle a larger library or more users in the future?
Building a Library Management System is a comprehensive exercise in object-oriented programming, data management, and user experience. By completing this project, you’ll have a robust application that showcases your understanding of these principles. As you continue your journey in Python, reflect on how you can integrate these concepts into other projects. Happy coding!
Here is a quiz to test your understanding of object-oriented programming concepts.
This is an extremely important topic. While you are clear to proceed to the next chapter, it’s important to continue on this topic as well. Here’s some recommendations:
Remember to continually practice and implement the knowledge gained to become proficient in object-oriented programming in Python.
Happy Coding! 🚀