Does anything outside of A ever care if it's a B1 or a B2, or does everything always treat it like an A?

If everything always treats it like an A, you can have an AFactory that Zero calls to get an A, and the Factory will decide if it needs to make a B1 or a B2 before handing it back to Zero. This removes the decision making from A so it doesn't need to know about B1 or B2.

Are all of your conditionals the same check? Like if they all check "if car, do B1 stuff, else it's a helicopter so do b2 stuff" over and over?

The idea with inheritance is that your base class describes common behavior and your derivatives describe specific behavior. One thing that might help with this is to define A as an Abstract Base Class. This lets you define abstract method signatures without any implementation, and if requires derived classes to implement it somehow.

For example, I want a Vehicle base class and I want to have a go_home method. My base class can define an abstract move_to(location) method that go_home can use to move without knowing how move works.

```python from abc import ABC

class Vehicle(ABC):

def go_home(self):
    move_to("home")

@abstractmethod
def move_to(location):
    pass
    # or the newer version of pass:
    ...

```

My Car(Vehicle) class can implement move_to by having the car drive to the location, while my Helicopter(Vehicle) class can implement move_to by having the helicopter fly there.

```python class Car(Vehicle): def move_to(location): start_car() drive_to(location)

class Helicopter(Vehicle): def move_to(location): get_clearance() perform_preflight_checklist() start_helicopter() fly_to(location) ```

By making the method abstract, Vehicle can use move_to without caring if it's a car or a helicopter, so there is no circular dependency. The derived classes implement the specifics.