Adding an Instance Method

from dataclasses import dataclass
from operator import methodcaller

@dataclass(slots=True, kw_only=True)
class Car:
    """Class representing car."""

    color: str
    mileage: int

    def __str__(self):
        """Returns string representation of car."""
        return f"The {self.color} car has {self.mileage:,} miles."

    def drive(self, miles: int) -> None:
        self.mileage += miles

blue_car = Car(color="blue", mileage=20_000)
red_car = Car(color="red", mileage=30_000)
white_car = Car(color="white", mileage=0)

cars = [blue_car, red_car, white_car]
get_mileage = methodcaller("drive", 100)
get_more_mileage = methodcaller("drive", 100)

for car in cars:
    get_mileage(car)
    print(car)

print()

for car in cars:
    get_more_mileage(car)
    print(car)

from random import uniform

class Car:

    def __init__(self,
                 make_car: str,
                 model_car: str,
                 year: int,
                 color: str,
                 mileage: float,
                 ) -> None:
        self.make_car = make_car
        self.model_car = model_car
        self.year = year
        self.color = color
        self.mileage = mileage


    def start(self):
        print(f'Starting {self.make_car} {self.model_car}...')

    def stop(self):
        print(f'{self.model_car} stopped...')

    def drive(self, distance: float) -> None:
        if Car.validate_float(distance, True):
            previous_mileage = self.mileage
            self.mileage += distance
            return (
                f'\tCurrent mileage {previous_mileage:,}km.\n'
                f'\tNew mileage {self.mileage:,}km.'
                )
        else:
            raise ValueError('Incorrect mileage has been given!')

    @staticmethod
    def validate_float(value: float, is_positive: bool=False) -> bool:
        '''if used in the Car Class, validate if distance is not <= 0
           for general use, return false if value is not an instance of type(float)'''
        if isinstance(value, float):
            if is_positive:
                return True if value > 0 else False
            else:
                return True
        else:
            return False


    def __str__(self):
        return f'The {self.color} car has {self.mileage:,}km.'


ford = Car('Ford', 'Ranger', 2014, 'blue', 20_000)
citroen = Car('Citroën', 'Vision', 2030, 'red', 30_000,)

car_obj_mapping = {
    'ford': ford,
    'citroen': citroen,
}
entered_car_brands = set()

for i in range(2):

    while True:
        get_car_brand = input('Car brand: ')
        if get_car_brand in entered_car_brands:
            print(f'{get_car_brand} has already been driven!')
            continue
        elif car_obj_mapping.get(get_car_brand, None):
            entered_car_brands.add(get_car_brand)
            car_obj_mapping[get_car_brand].start()
            break
        else:
            print(f'{get_car_brand} not recognized as a car brand!')

    random_distance = round(uniform(1, 500), 2)

    print(f'{ford.drive(random_distance)}')

    car_obj_mapping[get_car_brand].stop()
else:
    print('Test Drive complete!')

# from
print(f'{ford.drive(random_distance)}')

# to
print(f'{car_obj_mapping[get_car_brand].drive(random_distance)}')