Python OOP - Create a Class or Build in main.py (Udemy 100 Days of Python)?

Question

The messaging in this course seems to be that OOP revolves around organization of code vs creating classes for the purpose of repeatable variance.

For example: Day 23 is a frogger game. The instructor creates a 'CarManager' class that generates the same car over and over. There doesn't seem to be any reason, other than organization of code, why the CarManager functions couldn't have been placed in the main.py file.

Question:

I'm trying to distinguish and understand why a class would be created when the attributes and functions could very well be placed in the main.py with no difference in the amount of code written. Should a class be created simply for organizing and de-cluttering your main.py?

In the frogger game example, I took a different approach to what the instructor did (code below). I created a Car class with inputs for size and speed. Then in my main.py code, I generated 4 different vehicles using Car class (motorcycle, car, truck, semi) with varying size and speed. Is this not a more appropriate use of OOP within Python?

Car class:

from turtle import Turtle
import random

CAR_COLORS = ["blue", "red", "black", "green", "pink", "orange"]

class Car:
    def __init__(self, size1, speed1):
        self.car_pieces = []
        self.car_list = []
        self.create_car(size1)
        self.speed = speed1

    def create_car(self, car_size):
        color2 = random.choice(CAR_COLORS)
        xcor = random.randrange(310, 350, 20)
        ycor = random.randrange(-235, 226, 40)
        for i in range(car_size):
            car_piece = Turtle()
            car_piece.color(color2)
            car_piece.shape("square")
            car_piece.penup()
            car_piece.setposition(xcor, ycor)
            self.car_pieces.append(car_piece)
            xcor += 20

    def car_move(self):
            for i in range(len(self.car_pieces)):
                self.car_pieces[i].backward(self.speed)

main.py

#Car generation
car_list = []
motorcycle_speed = 12
car_speed = 5
truck_speed = 3
semi_speed = 1
def car_generator():
    car_options = ["motorcycle", "car", "truck", "semi"]
    car_choice = random.choice(car_options)
    random_chance = random.randint(1,6)
    if random_chance == 1:
        if car_choice == "motorcycle":
            motorcycle_object = Car(1, motorcycle_speed)
            car_list.append(motorcycle_object)
        elif car_choice == "car":
            car_object = Car(2, car_speed)
            car_list.append(car_object)
        elif car_choice == "truck":
            truck_object = Car(3, truck_speed)
            car_list.append(truck_object)
        elif car_choice == "semi":
            semi_object = Car(4, semi_speed)
            car_list.append(semi_object)
    else:
        pass

Roci49 · Accepted Answer · 2024-12-07 18:52:30Z

There are a lot of possible "right" and "not-right" ways of programming.

As you said, OOP aims to structure your code in order to do not lose your sanity when you will take back your code to code new features. Actually OOP is great for code design, watch about Design patterns and SOLID architecture for example...

BUT this is not the only reason. Let's suppose you wanna implement new functionalities like "police" or "bike" in a future. Actually you obviously can create a class and invoke that class from main.py. But when you implement a lot of these features you actually will have a gargantuan function which calls different classes in different modules and each time you have to modify one of these modules if class is not well written.

The best principle you can follow is Single-responsability (S of SOLID architecture), this means that one function has ONE responsability, so if car_generator is a function that generates car, actually should not generate bikes. In this way, when you will read your code again you know that car_generator doesn't implement bikes.

Now, you could think "Well, I rename car_generator in generator and I fix the problem". Actually you can, but the point is generator must do only one thing. When you add code in generator to check how many vehicles are in game in a specific time, you broke this principle and in 3 months you will forget that you added this functionality in this function.

Re-read your code now and think "do this function actually does only one thing?", if answer is yes, you can go over, but if in a future you program to implement a vehicle counter, you have to manage fact car_generator actually already does one thing, it creates vehicles.

You can extend this fact to modules too. main.py actually is like a wizard . It must invoke other functions and maintain a "logic" in your game. You can obviously instantiate objects in it, but what if one day you will have twenty classes each one creating twenty vehicles?

The problem is that car_generator is more a function which generates car so it should not stay in main.py. In this way, when you think "ok, I have to create a car" you know you have to visit and modify Car.py and not main.py.

Another thing is that actually you are "thinking" in C. That's really cool to start programming, but actually OOP is great cause of inheritance and polimorphism, two principles of OOP. You will understand why you prof. did this when you will meet these two principles.

I REPEAT: Your solution is not actually "clearly wrong" or "clearly good". Depends on what you will implement next. If the course teaches you that, probably it's because the tutor after years of coding found this is the most clear and beautiful way of creating this kind of things. I suggest you to read books and watch online tutorials of clean code and Design patterns to understand what your teacher is "implicitly saying"

Greetings

Collectives™ on Stack Overflow

Python OOP - Create a Class or Build in main.py (Udemy 100 Days of Python)?

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related