This is looking great and Monty Python thinks so, too.

I showed a demo to the group and

they realized that they forgot to include a requirement.

They forgot that there's a service charge involved with each transaction.

You can't sell tickets without a service charge, right?

Now this works a little differently.

Each purchase, not each ticket, has a service charge of $2.

Every time you demo your software, users will request additional features.

It happens all the time.

This is why it's important to get working software in front of your stakeholders.

This is actually a good chance to take a look at our code and

see if we can't refactor it a bit to make it more easy to read.

Well, there's a term we haven't touched on yet, refactor.

Refactoring is when you take a look at your code and you improve it for

readability or extensibility without changing how the program actually works.

Let's see if we can't refactor that price calculation into a function and

then add this new service charge.

Okay, so I'm gonna go ahead.

And I'm gonna add a new card.

And this one is As an owner, I should receive,

A service charge so that I can pay

others to maintain the software.

I suppose that makes sense, right?

Maintaining software can be super difficult for clients.

Now, if there's an error, they'll need to pay developers somehow.

So, I hope some of that service charge makes its way to fellow developers,

cuz it might not be us that fixes it.

You might pick up an application that's already working and you need to fix it.

So, let's move this into In Progress.

Okay, so, I'm gonna get rid of these comments here, get rid of that one, and

that one, and that one.

Okay, looking good, all right.

So let's first refactor our calculation into a function, right?

Cuz currently, we are calculating.

Where are we doing that calculation?

Right here, num_tickets equals times TICKET_PRICE.

So let's go ahead, I'm gonna cut this out.

This is Cmd+X, or Ctrl+X.

So now it's in my clipboard, it's gone.

And I'm gonna add a function that we'll create here in a bit.

And it should calculate the price of how many tickets there are.

So sounds like a good name, calculate_price.

And we're gonna pass in the number of tickets,

which we know is a valid number at this point.

Go ahead and save that.

And I'm gonna up here to the top, and here we go, let's do this.

Create the calculate price function.

Let's use the proper name there, calculate_price function.

It takes Number of tickets and

returns, what do we have here?

num_tickets + TICKET_PRICE, let's make a new.

Cool, so create that function, and return that value.

All right, you got this.

Pause me and create that function.

Remember, it needs to take the number of tickets.

All right, so here's what I did.

So I defined calculate_price.

And I required a parameter of number of tickets.

I need a colon, open that body up, and there is no need to create a new variable.

We can actually just return the result, right?

So we're gonna return and let's get lazy.

This, paste this here, but note that this is number of tickets.

So I'm gonna say number_of_tickets.

Now, note how this refactoring puts this calculating price into a separate area

than where this loop is at there.

So this loop will never really need to change.

We can figure out what this calculation of the price is.

And other people could use it too, should they need to.

We didn't need to do this but we refactored and

things should still work exactly the same.

Let's go ahead and let's run it and make sure.

Hey, Bob, let's get 2 tickets.

We got 20.

Yes, I wanna proceed.

98 tickets left, awesome, perfect.

So now that we have it refactored,

what we should do is we need to add this service charge, right?

So I'm just gonna go ahead, I'll put it in here.

And we need to create a new constant for

the $2 service charge.

Remember, that's once per transaction.

And then we want to add the service charge to what's due.

Okay, you got this.

Pause me and give those a go.

You ready?

Okay, so here's how I did it.

So this service charge, I'm gonna go ahead, I'm gonna come up here.

I'm gonna make a new constant.

And I'm gonna put it at the top of the file.

If you ever look in here, the service charge, if we start charging too much for

our developers, we need to bump this price up.

We just bump it one place here.

And then, I used it in the calculate_price function.

So I'm gonna get rid of this comment here, bring this back up.

We can just say + SERVICE_CHARGE.

You know what, I'm gonna think about my dear Aunt Sally.

And I'm gonna use some parenthesis even though I don't need to.

Because I know that multiplication will happen first and not the addition.

But I'm gonna do that cuz I think that that makes things more clear.

Let's go ahead and see how we did.

I would like to have 2 tickets.

$22, because of that service charge.

And there we go, great job.

Now I do like how if they change the way that this works,

we know where to change things.

It's right up here at the calculate_price.

And when you look at it used in this loop here, it's pretty clean, right?

It's really clear that the price calculation is happening elsewhere, and

we don't need to worry about it here.

If you wanted to calculate this on a different page,

on like a shopping cart page, you could use that same function.

It's reusable, we change it in one place.

And you know what?

I think we're done.

Awesome job.

I want you to take a minute and breathe in this program.

Look at all the tools that you stitched together.

You really have learned a ton and you were able to build an entire application.

You did an excellent job at immersing yourself in the Python

programming language.

Excellent work.