Course Topics
Python Basics Introduction and Setup Syntax and Indentation Comments and Documentation Running Python Programs Exercise Variables and Data Types Variables and Assignment Numbers (int, float, complex) Strings and Operations Booleans and None Type Conversion Exercise Operators Arithmetic Operators Comparison Operators Logical Operators Assignment Operators Bitwise Operators Exercise Input and Output Getting User Input Formatting Output Print Function Features Exercise Control Flow - Conditionals If Statements If-Else Statements Elif Statements Nested Conditionals Exercise Control Flow - Loops For Loops While Loops Loop Control (break, continue) Nested Loops Exercise Data Structures - Lists Creating and Accessing Lists List Methods and Operations List Slicing List Comprehensions Exercise Data Structures - Tuples Creating and Accessing Tuples Tuple Methods and Operations Tuple Packing and Unpacking Exercise Data Structures - Dictionaries Creating and Accessing Dictionaries Dictionary Methods and Operations Dictionary Comprehensions Exercise Data Structures - Sets Creating and Accessing Sets Set Methods and Operations Set Comprehensions Exercise Functions Defining Functions Function Parameters and Arguments Return Statements Scope and Variables Lambda Functions Exercise String Manipulation String Indexing and Slicing String Methods String Formatting Regular Expressions Basics Exercise File Handling Opening and Closing Files Reading from Files Writing to Files File Modes and Context Managers Exercise Error Handling Understanding Exceptions Try-Except Blocks Finally and Else Clauses Raising Custom Exceptions Exercise Object-Oriented Programming - Classes Introduction to OOP Creating Classes and Objects Instance Variables and Methods Constructor Method Exercise Object-Oriented Programming - Advanced Inheritance Method Overriding Class Variables and Methods Static Methods Exercise Modules and Packages Importing Modules Creating Custom Modules Python Standard Library Installing External Packages Exercise Working with APIs and JSON Making HTTP Requests JSON Data Handling Working with REST APIs Exercise Database Basics Introduction to Databases SQLite with Python CRUD Operations Exercise Final Project Project Planning Building Complete Application Code Organization Testing and Debugging Exercise

Creating Classes and Objects

Introduction

  • Why this topic matters: Understanding classes and objects is essential for structuring complex programs in Python. It allows us to define reusable, modular components that encapsulate related data and behavior.
  • What you'll learn: How to create custom classes, instantiate objects from those classes, and use class methods and attributes.

Core Concepts

A class is a blueprint for creating multiple objects. In Python, we define a class using the class keyword followed by its name. Inside the class, we can define methods (functions associated with the class) and attributes (variables associated with each instance of the class).

class MyClass:
    # Attributes are defined as variables inside the class
    some_attribute = 0

    def __init__(self, attribute_value):
        self.some_attribute = attribute_value

    def my_method(self):
        print("Hello from my method!")

To create an object (instance) of the class, we use the class_name() syntax and assign it to a variable.

my_object = MyClass(42)

You can access attributes using dot notation:

print(my_object.some_attribute)  # Outputs: 42

Practical Examples

Let's create a simple Rectangle class that calculates the area of a rectangle based on its width and height.

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

    def calculate_area(self):
        return self.width * self.height

# Create a new rectangle and calculate its area
rectangle = Rectangle(5, 10)
print(rectangle.calculate_area())  # Outputs: 50

Common Issues and Solutions (CRITICAL SECTION)

NameError

What causes it: Misspelling a class or method name when trying to use it.

# Bad code example that triggers the error
print(MyClas.calculate_area())  # Incorrect class name

Error message:

Traceback (most recent call last):
  File "example.py", line 10, in <module>
    print(MyClas.calculate_area())
NameError: name 'MyClas' is not defined

Solution: Ensure the class and method names are spelled correctly.

Why it happens: Python does not recognize undefined identifiers, causing a NameError.

How to prevent it: Double-check your code for typos in class and method names.

TypeError

What causes it: Attempting to call a method without providing the required object (instance).

# Bad code example that triggers the error
Rectangle.calculate_area()  # Incorrect usage of the method

Error message:

TypeError: calculate_area() missing 1 required positional argument: 'self'

Solution: Always call methods on an instance (object) created from the class.

Why it happens: Python requires the self parameter to access the instance attributes and methods inside a method definition.

How to prevent it: Use the correct syntax: instance_name.method_name().

Best Practices

  • Use meaningful names for classes and methods, following Python's naming conventions (e.g., CapitalizedWords for class names, lowercase_with_underscores for method and attribute names).
  • Document your code using docstrings (triple quotes) to explain the purpose of the class or method.
  • Use inheritance (subclassing) to create specialized versions of existing classes.
  • Use appropriate access levels (public, private, protected) for attributes and methods by naming them accordingly (e.g., self.__private_attribute for private attributes).

Key Takeaways

  • Understand the basic structure of a class in Python, including attributes, methods, and constructors (__init__ method).
  • Know how to create objects (instances) from classes and access their attributes.
  • Learn to define and call class methods for reusable functionality.
  • Be aware of common errors such as NameError and TypeError, and know how to fix them.
  • Follow best practices when designing your own classes, including clear naming conventions, proper documentation, and inheritance.
  • Next steps for learning: Explore more advanced features of Python classes, such as static methods, properties, decorators, and multiple inheritance.
Previous: Introduction to OOP Next: Instance Variables and Methods