All language subtitles for 042 [Interactive Coding Exercise] Banker Roulette - Who will pay the bill_.en_US

So the code challenge that you're about to do comes from a really interesting phenomenon that you might find

in London.

I live in London and it's well known as a big financial district.

So when you head over to the city or the financial area in London and you go into a restaurant, you

might see a strange thing happen.

You might see a whole bunch of people in suits who look very much like the financial banker types. At

the time when they actually need to pay the bill

you see everybody pull out their business cards and put them into a bowl.

So what's actually going on here?

A friend of mine told me apparently there's this game that the rich banker types play where it's kind

of like Russian roulette with the bill.

So everybody puts their business card in and the person's card who gets picked out has to pay for everybody's

bill, which is kind of crazy.

But then again, it's finance.

So in today's challenge, this is what we're going to replicate with code. Head over to the course

resources and click on the coding exercise to bring it up.

Now, go ahead and fork your own copy of it so that you can make amendments.

Now, the idea is that once you've completed the challenge, you should be able to type in a whole bunch

of names as an input with a comma and a space separating each name.

And then the code will pick a random name from the one that you've given it and tell you who is going

to buy the meal.

Now, there's two lines of code here that you might not have seen before.

Now this is something called split, and this allows you to split a string into separate components

based on some sort of divider.

So in this case, notice how it says hello, from, AskPython.

Now, if we use the split on this string, then it will divide it up into a list and separate out all

the words that are divided by this split character, which is the comma.

Now, similarly, over here, when we give the input, it's going to be in the format like this; everybody's

names separated by a comma and a space.

So now if we use the split on a comma and a space, then it will take out the comma and the space and

it will put everything else as separate items inside a list.

So what I recommend doing before you get started writing the actual code is to test it out.

So printout what names actually looks like.

So if we go ahead and run this code and then we type a bunch of names separated by a comma.

so Angela, Ben, Jenny and then hit enter,

then we hit the line where it prints names.

Now names, as you'll see, is now a list with all the names I typed in.

And while previously they were separated by a comma and a space, they are now all individual items

in a list.

The idea is that you've got all of these items inside a list,

how can I pick a random one out of it using a random index based on the number of items in the list

which of course can change?

And then how can I get a random name as the output and then print so-and-so is going to buy the meal

today?

So have a think about it,

have a pause and then see if you can complete the challenge.

So now that we've got the list as a starting point stored inside names, how can we go about generating

a random name and picking it out of the list?

Well, we know that we can pick a item from the list by adding a set of square brackets and then a index

number.

So in this case, it should print the first item out of the list which is going to be just the word

Angela. And I can run this to prove this to you.

You can see that names is a list of all the names, Angela, James, Ben. Names at position zero

is Angela, the first item.

Now, how can we get a random number to replace that number zero?

Well, we could use our random generator.

Let's go ahead and import the random module and we can say random.randint and then we can specify

the start and end.

So the start is probably going to be zero because that's where we start counting with our lists.

But what is the end?

Well, the end should be the position of the last item.

But how can we know that position?

What is that X going to be?

Well, what if we got hold of the number of items in the list?

So do remember how previously we learned about the len function?

Well, the len function can be used to get the number of elements in a list or the number of characters

in a string.

And if you take a look at this Stack Overflow question, then you'll see it in action.

All that we have to do to get hold of the number of items inside this names list is to write len

(), and then inside it we put names.

Now we can either store this or print this. Llet's go ahead and first print with the value of this is

going to be. Let's go ahead and comment out this line of code and then run our code, and then give everybody's

names separated by a comma, hit enter.

And you can see that this line of code has printed three.

So the length of my names list is three.

So now that we've gotten hold of that, then we can probably use that number that comes from this len

function inside our random generator, because we know that we can use this to get the total number

of items in list.

So in this case, that would be one, two, three, four, five.

This last item is not at position five, though, right?

It's at position zero,

one, two, three, four.

So we always need one less than the total number of items.

And the range of random numbers we would want is num_items -1.

Now, this line of code will allow us to generate random numbers between zero and the last index, and

I can store that inside a random choice variable and print my random choice.

So if I run the code again

and it prints one this time,

but the next time, it might be zero or two, because those are all the possible choices for a three

item list. Now we can use that number to actually get hold of a particular item in our list of names.

So we can say names[], and then we're going to use the random choice to get hold of

the random item. And then we can go ahead and save this as the person_who_will_pay.

And we can print

person_who_will_pay + "is going to buy the meal today."

So now let's go ahead and run our code again and then give everybody's names separated by a comma, and

then it says James is going to buy the meal today.

And now we know that we've completed the challenge.

Now, you'll notice that in the instructions, I told you that you're not allowed to use the choice

function.

And the reason for this is because if you search AskPython and you search for the random module

and you scroll down, you'll find that you can actually generate random items from a sequence such as

a list by writing random.choice, and it will actually pick an item from that list.

So let me demo what our code would look like instead. Instead of needing all of these lines of code,

all we have to write is random.choice()

and then we put our names list inside. And now it will do exactly the same as before

but with far less code. But this, of course, doesn't test whether if you've understood how indices

work with lists and whether if you're comfortable with the idea that the last index is actually one

less than the total number of items because we start counting from zero. I've made it a little bit

harder than it needed to be just to see how good a grasp you have on lists.

Now, I hope that you managed to complete this challenge.

If not, don't worry.

Go back to it and see if you can replicate the logic that we talked about just now.

And if you really struggle visualizing what these lines of code are doing, then you can always pass it

through Thonny and use the debugger to step through it one step at a time and see what's happening at

each stage.

Now on the next lesson, we're going to see some more advanced parts of lists in action, namely how

to nest lists inside other lists.

So for all of that and more, I'll see you on the next lesson.