🐍Intro to Python Programming Unit 11 – Classes

What Are Classes?

• Classes provide a way to organize and structure code in object-oriented programming (OOP)
• Define a blueprint or template for creating objects (instances) with specific attributes and behaviors
• Encapsulate related data and functions into a single unit
• Enable the creation of multiple instances of a class, each with its own unique state
• Promote code reusability, modularity, and maintainability by separating concerns and responsibilities
  • Allows for the development of more complex systems by breaking them down into smaller, manageable parts
• Facilitate inheritance, allowing classes to inherit attributes and methods from other classes
• Used to model real-world entities or abstract concepts in a program (Person, Vehicle, BankAccount)

Object-Oriented Programming Basics

• OOP is a programming paradigm that organizes code around objects, which are instances of classes
• Focuses on the concept of objects that have attributes (data) and methods (functions) associated with them
• Emphasizes the interaction and collaboration between objects to achieve desired functionality
• Four main principles of OOP:
  • Encapsulation: Bundling data and methods together within a class, hiding internal details
  • Inheritance: Creating new classes based on existing classes, inheriting attributes and methods
  • Polymorphism: Objects of different classes can be treated as objects of a common base class
  • Abstraction: Simplifying complex systems by breaking them down into smaller, more manageable parts
• Promotes code modularity, reusability, and maintainability by organizing code into logical units (classes)
• Allows for the creation of hierarchical relationships between classes through inheritance

Creating a Class in Python

• Classes are defined using the

  class

  keyword followed by the class name and a colon
• Class names typically follow the PascalCase naming convention
• Attributes and methods are defined within the class block, indented properly
• Example class definition:

  class Person:
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def introduce(self):
          print(f"Hi, my name is {self.name} and I'm {self.age} years old.")
  

• The

  __init__

  method is a special method called the constructor, used to initialize the object's attributes
• Methods are defined as functions within the class and typically take

  self

  as the first parameter
• Instances of a class are created by calling the class name followed by parentheses (Person("Alice", 25))

Class Attributes and Methods

• Attributes are variables that hold data associated with a class or its instances
• Instance attributes are specific to each instance of a class and are defined within the

  __init__

  method
  • Accessed using the

    self

    keyword within the class (self.name, self.age)
• Class attributes are shared among all instances of a class and are defined outside of any methods
  • Accessed using the class name or the

    self

    keyword (Person.class_attribute)
• Methods are functions defined within a class that perform actions or operations on the class or its instances
• Instance methods are the most common type of methods and operate on individual instances of a class
  • Take

    self

    as the first parameter, allowing access to instance attributes
• Class methods are methods that are bound to the class itself rather than instances
  • Defined using the

    @classmethod

    decorator and take

    cls

    as the first parameter
• Static methods are methods that don't depend on the class or its instances
  • Defined using the

    @staticmethod

    decorator and don't take

    self

    or

    cls

    as parameters

Constructors and Self

• The

  __init__

  method is a special method called the constructor, used to initialize an object's attributes when it is created
• Constructors are automatically called when a new instance of a class is created
• The

  self

  parameter is a reference to the instance being created or accessed
  • Used to access and modify instance attributes and call instance methods within the class
• Example constructor:

  class Rectangle:
      def __init__(self, width, height):
          self.width = width
          self.height = height
  

• When creating an instance of a class, the

  self

  parameter is automatically passed by Python (Rectangle(5, 3))
• The

  self

  keyword is used to differentiate between instance attributes and local variables within methods

Inheritance and Polymorphism

• Inheritance is a mechanism that allows a class to inherit attributes and methods from another class
• The class that is being inherited from is called the base class or superclass
• The class that inherits from the base class is called the derived class or subclass
• Inheritance promotes code reuse and allows for the creation of specialized classes based on more general ones
• Example inheritance:

  class Animal:
      def __init__(self, name):
          self.name = name
  
      def speak(self):
          pass
  
  class Dog(Animal):
      def speak(self):
          return "Woof!"
  
  class Cat(Animal):
      def speak(self):
          return "Meow!"
  

• Polymorphism allows objects of different classes to be treated as objects of a common base class
  • Enables the use of a single interface to represent different types of objects
• Polymorphism is achieved through method overriding and method overloading
  • Method overriding: Redefining a method in a derived class that is already defined in the base class
  • Method overloading: Defining multiple methods with the same name but different parameters (not directly supported in Python)

Encapsulation and Data Hiding

• Encapsulation is the bundling of data and methods together within a class, hiding the internal details from outside the class
• Encapsulation provides data protection and prevents unauthorized access or modification of an object's internal state
• In Python, encapsulation is achieved through naming conventions and access modifiers
• Access modifiers:
  • Public: Attributes and methods are accessible from anywhere (default)
  • Protected: Attributes and methods are accessible within the class and its subclasses (prefixed with a single underscore

    _

    )
  • Private: Attributes and methods are accessible only within the class (prefixed with double underscores

    __

    )
• Example encapsulation:

  class BankAccount:
      def __init__(self, account_number, balance):
          self._account_number = account_number
          self.__balance = balance
  
      def deposit(self, amount):
          self.__balance += amount
  
      def withdraw(self, amount):
          if amount <= self.__balance:
              self.__balance -= amount
          else:
              print("Insufficient funds")
  

• Encapsulation helps maintain the integrity of an object's state and provides a clear interface for interacting with the object

Practical Applications of Classes

• Classes are widely used in various domains to model real-world entities, abstract concepts, and solve complex problems
• Examples of practical applications:
  • GUI development: Classes are used to represent graphical user interface elements (buttons, windows, menus)
  • Game development: Classes are used to represent game objects, characters, and game logic
  • Database management: Classes are used to represent database tables, records, and queries
  • Web development: Classes are used to represent web pages, user sessions, and server-side components
  • Scientific computing: Classes are used to represent mathematical objects, algorithms, and simulations
• Classes provide a structured and modular approach to software development
  • Facilitate code organization, reusability, and maintainability
  • Enable the creation of libraries and frameworks that can be used across multiple projects
• Classes allow for the separation of concerns and the encapsulation of related functionality
  • Promote a cleaner and more maintainable codebase
  • Facilitate collaboration and teamwork by providing well-defined interfaces and responsibilities
• Classes enable the development of scalable and extensible software systems
  • Allow for the addition of new features and functionality without modifying existing code
  • Support the creation of specialized classes through inheritance and polymorphism