Object Oriented Programming with Python - Full Course for Beginners

Introduction

This tutorial provides a comprehensive overview of Object-Oriented Programming (OOP) using Python. It is designed for beginners to understand key concepts and practical implementations of OOP, which is essential for modern software development. By the end of this guide, you'll be familiar with classes, constructors, methods, inheritance, and more.

Step 1: Getting Started with Classes

• Understanding Classes: Classes are blueprints for creating objects. They encapsulate data for the object and methods to manipulate that data.
• Creating a Simple Class:

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

• Instantiating an Object:

  my_dog = Dog()
  print(my_dog.bark())  # Output: Woof!
  

Step 2: Working with Constructors

• What is a Constructor: The __init__ method initializes an object's attributes when the object is created.
• Defining a Constructor:

  class Dog:
      def __init__(self, name):
          self.name = name
      
      def bark(self):
          return f"{self.name} says Woof!"
  
  my_dog = Dog("Buddy")
  print(my_dog.bark())  # Output: Buddy says Woof!
  

Step 3: Class vs Static Methods

• Class Methods: Use the @classmethod decorator. These methods can modify class state that applies across all instances.
• Static Methods: Use the @staticmethod decorator. These methods don't modify class or instance state.
• Example:

  class Math:
      @classmethod
      def add(cls, a, b):
          return a + b
      
      @staticmethod
      def multiply(a, b):
          return a * b
          
  print(Math.add(2, 3))       # Output: 5
  print(Math.multiply(2, 3))  # Output: 6
  

Step 4: Understanding Inheritance

• What is Inheritance: Inheritance allows a class (child class) to inherit attributes and methods from another class (parent class).
• Creating a Subclass:

  class Animal:
      def speak(self):
          return "Animal speaks"
  
  class Dog(Animal):
      def bark(self):
          return "Woof!"
  
  my_dog = Dog()
  print(my_dog.speak())  # Output: Animal speaks
  print(my_dog.bark())   # Output: Woof!
  

Step 5: Implementing Getters and Setters

• Purpose of Getters and Setters: These methods provide a way to access and modify private attributes.
• Example:

  class Person:
      def __init__(self, name):
          self.__name = name
      
      def get_name(self):
          return self.__name
      
      def set_name(self, name):
          self.__name = name
          
  person = Person("Alice")
  print(person.get_name())  # Output: Alice
  person.set_name("Bob")
  print(person.get_name())  # Output: Bob
  

Step 6: Exploring OOP Principles

• Four Pillars of OOP:
  • Encapsulation: Bundling data and methods that operate on that data.
  • Abstraction: Hiding complex implementation details and exposing only essential features.
  • Inheritance: Reusing code through class hierarchies.
  • Polymorphism: Using a unified interface for different data types.

Conclusion

In this tutorial, you learned the basics of Object-Oriented Programming in Python, including how to create classes, use constructors, and implement inheritance, getters, and setters. These foundational concepts are crucial for building robust software applications. As a next step, explore the provided code repository for practical examples and continue practicing by creating your own classes and structures.