Problem overview
The class Event has a name and a number of free seats. Event(name, seats) creates it, name is a field any code can read, and the seats left are a private field. book(n) books n seats and returns how many are left.
A booking can fail, and then book raises an error and changes nothing:
- When
nis 0 or less, the message is"invalid number". - When
nis more than the seats left, the message is"sold out".
In Python the error is a ValueError. For Event("Concert", 5), booking 2 leaves 3. Booking 4 then fails with sold out, and because that failure changed nothing, booking 3 afterwards takes the last seats and leaves 0.
Approach
The method has three outcomes, so it works best as a short chain of checks followed by the real work. Check for the invalid number first, then for too many seats, and only when both checks pass change the seat count. Raising an error stops the method on the spot, so the line that subtracts the seats is never reached after a failure. That is how "nothing changes" comes for free: the order of the lines does the job.
The order of the two checks matters in one case. If n is 0 and the event has no seats, "0 is more than 0" is false, but "0 or less" is true, so the answer is invalid number. Checking n <= 0 first gives the result the examples show for an event with 0 seats and a booking of 0.
Step by step
- In
__init__, store the name inself.name, a public field. - Store
seatsinself._seats_left. The underscore says only the class's own methods change it. - In
book, write aniffornbeing 0 or less, and raise aValueErrorwith the message"invalid number". - Write a second
iffornbeing more thanself._seats_left, and raise aValueErrorwith the message"sold out". - Now the booking can go ahead: subtract
nfromself._seats_leftand returnself._seats_left.
The solution in Python
class Event:
def __init__(self, name, seats):
self.name = name
self._seats_left = seats
def book(self, n):
if n <= 0:
raise ValueError("invalid number")
if n > self._seats_left:
raise ValueError("sold out")
self._seats_left -= n
return self._seats_left
Details worth knowing
The second if is not an elif, and it doesn't need to be: when the first one raises, the method has already ended. Both styles behave the same here.
The caller catches the error with try and except ValueError as err, and printing err shows the message. An error that nobody catches stops the program.
The seat count is private only by convention. The underscore asks other code to stay out; Python would still let it read event._seats_left.
Using the class
def run(name, seats, bookings):
e = Event(name, seats)
print(e.name)
for n in bookings:
try:
print(f"booked {{n}}, {{e.book(n)}} left")
except ValueError as err:
print("error:", err)
run("Concert", 5, [2, 4, 3])
run("Play", 4, [-1, 4])
run("Match", 0, [0])
Concert
booked 2, 3 left
error: sold out
booked 3, 0 left
Play
error: invalid number
booked 4, 0 left
Match
error: invalid number
Edge cases and common mistakes
- Subtracting before checking. A failed booking would still lower the seat count. Do the checks first.
- Using
<where<=is needed. The check for an invalid number isn <= 0, because 0 seats is never a valid booking. The check for too many seats isn > self._seats_left, because booking exactly the seats left is fine and leaves 0. - Returning instead of raising. Returning a text like
"sold out"mixes errors with seat counts. Raise the error. - Swapping the messages. The two messages are part of the lesson's output, so spell them exactly.
- Booking more than once after a failure. A failed call does not use up the seats, so the next booking sees the same count.
