Why "True if BOOL_EXPR else False"?

[ilyash-b]

Example: return True if (spot.size == LARGE or spot.size == COMPACT) else False

Location: https://github.com/donnemartin/system-design-primer/blob/master/solutions/object_oriented_design/parking_lot/parking_lot.ipynb

It would definitely be negative points if I was interviewing and instead of BOOL_EXPR there was True if BOOL_EXPR else False all over. Why is it there?

[Dhru1001]

Updated Code : from enum import Enum, auto from abc import ABC, abstractmethod

class VehicleSize(Enum): MOTORCYCLE = auto() COMPACT = auto() LARGE = auto()

class Vehicle(ABC): def init(self, vehicle_size, license_plate): self.vehicle_size = vehicle_size self.license_plate = license_plate self.spots_taken = []

def clear_spots(self):
    for spot in self.spots_taken:
        spot.remove_vehicle(self)
    self.spots_taken = []

def take_spot(self, spot):
    self.spots_taken.append(spot)

@abstractmethod
def can_fit_in_spot(self, spot):
    pass

class Motorcycle(Vehicle): def init(self, license_plate): super().init(VehicleSize.MOTORCYCLE, license_plate) self.spot_size = 1

def can_fit_in_spot(self, spot):
    return True

class Car(Vehicle): def init(self, license_plate): super().init(VehicleSize.COMPACT, license_plate) self.spot_size = 1

def can_fit_in_spot(self, spot):
    return spot.size == VehicleSize.LARGE or spot.size == VehicleSize.COMPACT

class Bus(Vehicle): def init(self, license_plate): super().init(VehicleSize.LARGE, license_plate) self.spot_size = 5

def can_fit_in_spot(self, spot):
    return spot.size == VehicleSize.LARGE 

class ParkingLot: def init(self, num_levels): self.num_levels = num_levels self.levels = [Level(i) for i in range(num_levels)]

def park_vehicle(self, vehicle):
    for level in self.levels:
        if level.park_vehicle(vehicle):
            return True
    return False

class Level: SPOTS_PER_ROW = 10

def __init__(self, floor):
    self.floor = floor
    self.num_spots = 0
    self.available_spots = 0
    self.parking_spots = []
    for i in range(Level.SPOTS_PER_ROW // 2):
        self.parking_spots.append(ParkingSpot(self, 0, i, VehicleSize.MOTORCYCLE, VehicleSize.MOTORCYCLE))
    self.num_spots += Level.SPOTS_PER_ROW // 2
    for i in range(Level.SPOTS_PER_ROW // 2, Level.SPOTS_PER_ROW):
        self.parking_spots.append(ParkingSpot(self, 0, i, VehicleSize.COMPACT, VehicleSize.COMPACT))
    self.num_spots += Level.SPOTS_PER_ROW // 2

def spot_freed(self):
    self.available_spots += 1

def park_vehicle(self, vehicle):
    if self.available_spots < vehicle.spot_size:
        return False
    spot = self._find_available_spot(vehicle)
    if spot is None:
        return False
    return spot.park_vehicle(vehicle)

def _find_available_spot(self, vehicle):
    for spot in self.parking_spots:
        if spot.can_fit_vehicle(vehicle):
            return spot
    return None

class ParkingSpot: def init(self, level, row, spot_number, spot_size, vehicle_size): self.level = level self.row = row self.spot_number = spot_number self.spot_size = spot_size self.vehicle_size = vehicle_size self.vehicle = None

def is_available(self):
    return self.vehicle is None

def can_fit_vehicle(self, vehicle):
    if not self.is_available():
        return False

    if self.spot_size == VehicleSize.MOTORCYCLE:
        return True

    if self.spot_size == VehicleSize.COMPACT:
        return vehicle.vehicle_size != VehicleSize.LARGE

    if self.spot_size == VehicleSize.LARGE:
        return vehicle.vehicle_size == VehicleSize.LARGE

    return False