This week was packed with theory, practice, challenges, and lots of “what’s going wrong”moments. Let me share what I learned, what I built, the challenges I faced, and how I overcame them.

What I Learned

1.Object-Oriented Programming (OOP)

I understood how OOP helps organize code into classes and objects, making programs easier to structure and maintain.

• Classes are like blueprints.

• Objects are instances of those blueprints.

• Attributes and methods define their behavior.

Example:

#define the Car class
class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def display(self):
        print(f"Car brand: {self.brand}, Model: {self.model}")

#instantiate two Car objects
car1 = Car("Toyota", "Corolla")
car2 = Car("Mercedes", "Benz")

#print their details
car1.display()
car2.display()

In this example, we defined a Car class with two attributes: brand and model.

The init method is a constructor that initializes these attributes whenever a new Car object is created.

The display() method is used to print the details of the car in a clean format.

We then created two objects (car1 and car2) with different values and called their display() methods, which printed their respective details.

This demonstrates the basics of object instantiation (creating objects from a class) and method usage in Python OOP.

2.Inheritance

A class can inherit attributes and methods from another class making code reusable and extensible.

Example:

#base class
class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def make_sound(self):
        print(self.sound)

#subclass Dog
class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "Woof!")

    def make_sound(self):
        print("Woof!")

#subclass Cat
class Cat(Animal):
    def __init__(self, name):
        super().__init__(name, "Meow!")

    def make_sound(self):
        print("Meow!")


#create objects
dog1 = Dog("Brave")
cat1 = Cat("Hover")

#Calling method
dog1.make_sound()
cat1.make_sound()

In this example, we start with a base class Animal that has a make_sound() method.

The subclasses Dog and Cat inherit from Animal but override the make_sound() method to provide their own unique sounds ("Woof!" and "Meow!").

When we create objects (dog1 and cat1) and call their make_sound() methods, Python executes the version defined in the subclass instead of the base class.

This is a demonstration of inheritance (classes reusing functionality from a parent class).

3.Iterators

Iterators let us loop through custom objects using iter() and next().

Example:

class CountDown:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.n > 0:
            current = self.n
            self.n -= 1
            return current
        else:
            raise StopIteration

# Demonstration
num = CountDown(10)

for number in num:
    print(number)

In this example, we define a custom iterator class CountDown.

• The iter() method returns the iterator object itself (required for iteration).

• The next() method defines how the iteration progresses. It decreases the number n by 1 each time and returns the current value. Once n reaches 0, it raises a StopIteration exception to end the loop.

When we use a for loop on the CountDown(10) object, Python internally keeps calling next() until there are no more values to return.

This is a demonstration of how the iterator protocol works in Python making objects iterable just like lists, strings, or tuples.

4.Polymorphism

Different classes can have methods with the same name, but behave differently.

# base class
class Bird:
    def speak(self):
        print("Chirp")

# subclass Parrot
class Parrot(Bird):
    def speak(self):
        print("Squawk")

# subclass Crow
class Crow(Bird):
    def speak(self):
        print("Caw")

# function to make bird speak
def make_bird_speak(bird):
    bird.speak()

# create objects
parrot = Parrot()
crow = Crow()

# function calls
make_bird_speak(parrot)   # Squawk
make_bird_speak(crow)     # Caw

In this example, we start with a base class Bird that has a method speak().

• The subclasses Parrot and Crow override the speak() method to give their own unique sounds: "Squawk" for the parrot and "Caw" for the crow.

• The function make_bird_speak() accepts any Bird object and calls its speak() method, without needing to know whether it’s a parrot, crow, or any other bird.

This demonstrates polymorphism in Python the same method name (speak) behaves differently depending on the object that calls it.

5.Scope (Global, Local, Nonlocal, Built-in)

Variable visibility depends on where it is defined.

• Local> inside a function.

•Global > defined outside all functions.

•Nonlocal >used inside nested functions.

•Built-in >Python reserved names (like len, print).

count = 10  # global

def increment():
    count = 5  # local
    print("Inside function:", count)

increment()
print("Outside function:", count)

In this example, we defined a global variable count = 10. Inside the function increment(), we created another variable named count = 5.

• When we print count inside the function, Python uses the local variable (value 5).

• When we print count outside the function, Python uses the global variable (value 10).

This shows the difference between local scope (variables defined inside a function) and global scope (variables defined outside all functions).

What I Built / Coded

• A library system with Books and Members (using inheritance and encapsulation).

• A Fibonacci iterator to generate numbers up to n.

• Custom iterators for even numbers and file reading.

• OOP examples showing polymorphism (Car vs Bicycle, Cat vs Dog).

Challenges I Faced

1. Indentation Errors – I often misplaced indentation inside classes and methods, which caused frustrating errors.
   Solution: I practiced writing cleaner code consistently and relied on my IDE to quickly spot and correct indentation issues.

2. Confusion with Scope – At some point, I accidentally overwrote built-in names (like len), which led to unexpected errors and confusion.
   Solution: I learned to avoid shadowing built-in functions and studied Python’s LEGB rule (Local → Enclosed → Global → Built-in) to understand how variable resolution works.

3. Iterator Logic – My first iterator didn’t behave as expected because it returned object references instead of actual values.
   Solution: I debugged step by step and realized I needed to properly return values inside the next() method instead of printing the object itself.

Although it wasn’t easy and I had sleepless nights trying to finish my tasks, these challenges made me stronger. YouTube tutorials also helped me a great deal whenever I was stuck, and overcoming these difficulties gave me more confidence in OOP, inheritance, polymorphism, iterators, and Python as a whole.

My Perspective

This week really showed me why OOP matters in programming. Being able to write code that’s structured and reusable feels so much better than just piecing scripts together. Working with iterators and polymorphism stretched how I think about problems, and learning more about scope gave me more confidence whenever I ran into errors.

I’ve come to see that programming isn’t only about writing code it’s about solving problems, thinking in systems, and building something you can reuse and improve on.

I’m looking forward to the next few weeks, but this week gave me a solid foundation and made me feel like I’m starting to think like a real developer.

That’s my Week 2 recap. If you’ve learned OOP, Iterators, Polymorphism, or struggled with scope, I’d love to hear your experience too.