Learn Python – Interactive Course 2016

[00:00] Python, it's one of the world's top [00:02] programming languages. In this course, [00:04] you're going to learn the basics of [00:05] Python from Treasure Por through a bunch [00:09] of interactive lessons and projects. So, [00:12] this is a great beginner's Python [00:15] course. [00:21] Hello and welcome to Learn Python, a [00:24] course about one of the most in- demand [00:26] languages on the planet. Python is [00:28] immensely popular and it's everywhere. [00:31] NASA uses it to analyze data from space [00:34] missions. Open AAI builds its AI systems [00:36] with it. Netflix uses it to decide what [00:39] you're going to binge next. Python is [00:42] powering the ubiquitous apps that you [00:44] use every single day. Apps like [00:47] Instagram, Spotify, Google, and Dropbox. [00:50] If you're looking to get hired as a [00:52] developer, data scientist, AI engineer, [00:55] or really any technical role, knowing [00:57] Python is your superpower. And Python [01:00] isn't just popular because companies [01:02] love it. It's popular because developers [01:05] love it. The syntax is clean and the [01:08] code reads almost like English. It was [01:11] built with elegance and simplicity in [01:13] mind. And so with Python, you get to [01:15] spend less time fighting the language [01:17] and its quirks and more time actually [01:20] building things. It's powerful enough to [01:22] run production systems at scale and [01:24] approachable enough that it's the go-to [01:26] first language for beginners all over [01:29] the world. In this course, you're going [01:30] to learn by doing. You'll build real [01:33] working apps, solve many challenges, and [01:35] write code from the very beginning. [01:38] Everything we'll build will run right [01:40] here in the Scriber editor where Python [01:42] is already set up and ready to go. So, [01:45] are you ready to learn some Python? [01:47] Let's get into it. [01:54] This section is all about learning the [01:56] basic building blocks of a Python [01:58] program. And we're going to do that by [02:00] building a fun and useful app called [02:02] PayU. PayUP is an expense splitter. So, [02:04] think splitting the dinner tab, dividing [02:06] up costs for a group trip, or settling [02:08] up after a night out. Let me show you [02:11] what we're building. The app gives you a [02:13] nice greeting, and then prompts you for [02:15] four things. The occasion, so we'll say [02:18] the occasion is Paul's Pizza. How much [02:20] the expense was, we'll say $345. [02:24] If there was a tip or a service charge [02:26] as a percentage, we'll say 20%. And [02:29] finally, how many people were in your [02:31] group, we'll say eight. Once you've [02:34] entered all the info, the app prints a [02:36] clean breakdown, and that includes a [02:38] summary of the cost. It calculates the [02:41] service charges based on the percentage, [02:43] the group size, the grand total, and [02:46] finally, of course, what each person [02:48] must pay up, what each person owes. [02:51] Along the way, you'll learn about [02:52] writing and running Python programs, [02:55] variables and the print function, [02:57] strings and string formatting, capturing [03:00] and handling user input, data types and [03:02] type conversion, and basic math [03:05] operations, as well as completing a ton [03:07] of practice and coding challenges. So, [03:10] you'll build up to the PayUP app by [03:12] working through smaller challenges that [03:14] introduce each concept. By the time we [03:16] start writing the app, nothing will be [03:18] new. You'll just be putting the pieces [03:20] together. Let's jump into it and get [03:21] ready to start building. [03:30] Before we start building, let's poke [03:31] around in a working Python program and [03:33] get comfortable reading and changing [03:35] code. Here we have a Python file called [03:37] script.py and in it is some code for a [03:40] party invitation generator. It formats [03:43] and prints a personalized invitation [03:45] based on the information that you give [03:47] it. Let's run it. Open the terminal with [03:49] command J. Type Python script.py and hit [03:53] enter. And there's our invitation. [03:55] There's a title. There's the body of the [03:57] invitation, the host, the date, and [04:01] address code. All formatted and printed. [04:04] Now, let's close the terminal for a [04:06] second and look at the code. You can [04:07] close by pressing command J again or [04:10] using this arrow to toggle the terminal [04:13] open and closed. At the top of the code [04:15] file, you've got host, date, dress code, [04:17] and name. These are called variables. [04:20] And a variable is just a label that [04:22] holds on to a piece of information. And [04:24] you can use that label anywhere you want [04:26] in your program. As you can see, each [04:28] variable corresponds to a place in the [04:30] invitation marked with curly brackets. [04:34] So, we have host, host, date, date, [04:37] dress code, dress code, and name. Watch [04:40] what happens when I change a variable at [04:42] the top of the file. We'll change the [04:44] name to Emily. Now, when I rerun and [04:47] rather than typing Python plus the file [04:49] name again, I can just press the up [04:51] arrow to get my last command. When I hit [04:54] enter to rerun, the invitation updates [04:56] automatically because everywhere that we [04:58] use the label name, Python swapped in [05:02] the new information. And this is really [05:04] the core idea of variables. They let you [05:06] separate your data, meaning the [05:08] information that you might want to [05:10] change, from the rest of your code. So [05:12] now it's your turn to try it. Into the [05:14] file, I'm going to copy and paste a [05:17] challenge. One quick thing before we get [05:19] into the challenge. Notice that the [05:21] challenge instructions each start with a [05:24] pound or hash symbol. That tells Python [05:26] to ignore that line when the file runs. [05:29] When something has a hash or pound [05:31] symbol in front of it, it's called a [05:32] code comment. You'll use comments to [05:34] leave notes for yourself, explain what [05:36] something does, or just think out loud [05:38] inside your code. Python will skip right [05:40] over these lines and ignore them [05:42] completely. So now let's read the [05:44] challenge. Step one is to change the [05:46] program's variables so that the [05:48] invitation prints your name and today's [05:50] date. Step two is change the dress code [05:53] to casual. We're staying in to learn [05:55] Python. No need to get dressed up. And [05:58] finally, don't forget to run the Python [06:00] file to check your work. To run a Python [06:02] file, you'll want to come in here to the [06:04] terminal and type Python plus the file [06:06] name and then hit enter. Go ahead and [06:08] give this a try. [06:14] All right. Hopefully that went well. Let [06:15] me show you the solution. First, we're [06:17] going to change the invitation so it [06:20] prints my name and today's date, which [06:22] we'll say is October 31st. Next is to [06:27] change the dress code to casual. And [06:30] finally, I'm going to save. Open up my [06:33] terminal. We'll clear this out so that [06:35] we can see clearly what's going on. And [06:37] if you weren't aware, if you ever need [06:38] to clear out this window, you can just [06:40] type clear and hit enter and everything [06:42] goes away. Now I'll type pythonscript.py [06:46] to run the file and you'll see my name [06:48] has changed, the date has changed, and [06:50] the dress code has changed. Very [06:53] excellent work. Hopefully you've had [06:55] some fun playing around in some Python [06:57] code. Feel free to stay here and keep [06:59] experimenting. When you're ready, meet [07:01] me in the next scrim. [07:08] To build the payup app, we need a way to [07:10] store information in Python. Things like [07:12] the total cost, the number of people [07:14] splitting it, and the tip percentage. [07:16] That's where variables come in. A [07:18] variable stores a value under a name you [07:21] choose so that you can use that value [07:23] later in your program. Here's the [07:25] syntax. We'll say meal total equals 85. [07:29] The name or the variable is on the left [07:32] and the value is on the right and the [07:34] equal sign is what connects them. This [07:36] is called an assignment. You're [07:38] assigning the value of 85 to the name [07:41] meal total. Let me show you what happens [07:43] if I print meal total. Python recalls [07:46] the value and prints it. And if the [07:48] total changes, I only have to update [07:51] that value in one place. So I'll change [07:53] 85 to 120. And then I'll run the program [07:57] again. And as you can see, same name, [07:59] but the value has updated. And that is [08:02] the core idea of a variable. So now I [08:05] have a challenge for you. Your challenge [08:07] is to think of the last time that you [08:09] ate at a restaurant. How many people [08:11] were you with? Save that number to a [08:12] variable called my party. Then you're [08:15] going to print my party and oops, it [08:18] turns out that two more people showed [08:20] up. So update my party and print it [08:22] again. Go ahead and get started. All [08:24] right. Hopefully that went [08:25] fantastically. Let me show you the [08:27] solution. The last time I ate at a [08:29] restaurant, I think I was with three [08:31] people. So, I'll create a variable [08:33] called my party and I'll assign it to [08:35] three. Then I'll go ahead and print my [08:38] party. If we run this, we get the number [08:41] three. I'll go ahead and comment this [08:43] out so that we don't have too much [08:44] clutter in our terminal. Now, two more [08:46] people showed up to the restaurant. So, [08:48] we'll update this to five. And then when [08:51] we run this again, our output is five. [08:54] But let me quickly show you something [08:56] else. You can reassign variable values [08:59] elsewhere in your code. So I could come [09:01] down here and say my party equals 10. [09:04] And I can print my party again. Now when [09:07] we run, we see that at first my party is [09:10] five, but now it's 10. And the thing is [09:12] is that now my party equals 5 is [09:15] completely gone because it's been [09:17] reassigned to the number 10. Much more [09:20] on that later, but just to show you that [09:22] that's something that you can do. You've [09:23] got the basic mechanics of variables [09:25] down. Store a value, recall it, update [09:28] it. Nice work. [09:35] Now that we know how to store values, [09:37] let's do something with them. I'm going [09:39] to create a variable called meal total, [09:42] which I'll assign to the value of 85, [09:45] and also a tip, which I'll assign to the [09:47] value of 15. Now I can add these [09:50] variables directly in a print statement. [09:52] Meal total plus tip or I can save the [09:56] result of meal total plus tip to a new [09:59] variable like grand total and I can [10:02] print that instead. Let's see what we [10:04] got. In both cases, Python has evaluated [10:06] the values stored in the variables and [10:09] printed the results of adding them [10:10] together. This is where variables really [10:13] start to get useful. I'm going to go [10:15] ahead and delete this print statement [10:16] because we only need one. So I can show [10:19] you that if the meal total changes, I [10:21] can update it in one place and [10:23] everything that depends on it will [10:25] update automatically. Now the grand [10:27] total is 115 without me touching [10:30] anything else. In our payup application, [10:32] we'll have a few values that all feed [10:34] into a final calculation. So this is [10:37] exactly how that's going to work. Before [10:39] I give you a challenge, a couple of [10:41] quick notes on variable naming. Python [10:44] variables should be lowercase with words [10:46] separated by underscore. So drink total [10:50] as opposed to what you might see in a [10:53] language like Java drink total or [10:56] something you might see in JavaScript [10:58] which is camelc case drink total. So in [11:00] Python we use snake case which are words [11:03] separated by underscores. The second [11:05] thing is that Python variables should be [11:07] descriptive. If drink total equals 5 [11:10] that tells you something that means [11:12] something. Looking at our above example, [11:15] if I said that x equals 100 and y equals [11:20] 15, that means very little to anybody [11:23] who's reading your code and your future [11:25] self. You might also see in Python [11:28] documentation and in tutorials using the [11:31] variables fu and bar. I would strongly [11:34] encourage you to avoid this as well [11:36] because again, it doesn't really tell [11:38] you what the purpose of this assignment [11:40] is. And lastly, variables can't be a [11:43] word that Python has already claimed. [11:45] These are words like print, if, for, [11:49] assert. These are words that already [11:51] mean something specific in Python and [11:53] therefore can't be used as variable [11:55] names. You'll know that you hit a [11:56] reserved word because Python will throw [11:58] you an error. So now it's time for the [12:00] challenge. Step one, you and your [12:02] friends have just had dinner. Save the [12:04] cost of the food to a variable called [12:06] food total. Step two, save the cost of [12:08] the drinks to a separate variable called [12:10] drinks total. Three, add them together [12:13] and save the result to a variable called [12:15] meal total. Then you're going to print [12:17] meal total and oops, one friend didn't [12:20] drink. Reduce drinks total by whatever [12:22] amount makes sense and print meal total [12:24] again. And then you'll run your program [12:26] and make sure that it updated. Go ahead [12:28] and give this a try. [12:31] So, first I'll create a variable called [12:33] food total. Let's say we had a fancy [12:36] dinner. it cost 150. Then I'll make a [12:38] variable called drinks total which we'll [12:40] set to 50. I'll make a third variable [12:43] called meal total. And we want meal [12:45] total to be the result of food total [12:48] plus drink total. And then we will go [12:51] ahead and print meal total. Before we do [12:55] the last step, let's open up the [12:56] terminal, clear it out, and run this [12:58] program again. And we got 200, which is [13:01] indeed 150 + 50. So now we're going to [13:05] reduce the drink total. Let's reduce it [13:07] to 40. And now we'll run the file again. [13:10] And our grand total is updated to 190. [13:19] To build a bill splitting app, we'll [13:21] need to save different types of data to [13:23] variables. We'll need to save numbers [13:25] like the cost of the bill and how many [13:27] people are splitting it. But we'll also [13:29] need to save text like the names of the [13:32] people who are splitting the bill. the [13:33] name of the restaurant where they ate [13:35] and things like that. The way to save [13:37] text to a variable is by using a string. [13:40] I'm going to create a variable called [13:41] breakfast and assign it the string [13:44] pancakes. A string can contain pretty [13:46] much any character, letters, symbols, [13:48] even emojis or blank spaces as long as [13:51] these characters remember are enclosed [13:53] in quotes. And also remember that you [13:56] can use single or double quotes. But the [13:58] main thing is that you need to stay [13:59] consistent. So I'm going to create a [14:01] variable called lunch. And let's see [14:03] what happens if we don't use quotes [14:05] consistently. I will put salad starting [14:08] with a double quote and ending with a [14:10] single quote. When I run the file, [14:12] you'll see that we get a syntax error. A [14:15] syntax error generally means that [14:17] there's something wrong with the way [14:18] that the Python has been typed. So you [14:20] can see it says got unexpected string at [14:22] line 2. And it's also very helpfully [14:25] pointing out that something is wrong [14:26] here. So I'll change that back to a [14:28] double quote. Run it again. And we [14:30] aren't using any print statements. So, [14:32] the Python isn't returning anything. [14:34] We'll fix that in a second. But first, [14:36] I'm going to create a third variable [14:38] called dinner, which I will assign to [14:40] the string pizza. Let's see what happens [14:42] if I were to assign the value pizza with [14:45] no quotes at all. This time, I get a [14:47] name error. Name pizza is not defined. [14:51] We're getting this error because Python [14:52] thinks that pizza is a variable instead [14:55] of a string because we didn't use [14:57] quotes. So, quotes are how we let Python [14:59] know, hey, this is some text. It's not a [15:02] variable or any other type of data. So, [15:04] let's put quotes around pizza and make [15:07] sure that everything is running as [15:09] expected. All right, we've got no [15:11] errors. So, that's great. I also want to [15:13] show you that you can add strings [15:15] together just like you can add numbers [15:17] together. And this is called [15:18] concatenating strings. So, in a variable [15:21] called meal plan, I'm going to assign [15:24] breakfast plus lunch plus dinner. And [15:27] I'm going to print the meal plan [15:30] variable. I'll clear this out and let's [15:32] see what happens now if we run the file. [15:34] As you can see, Python has done exactly [15:36] what we've asked. It's concatenated all [15:39] the strings together, but it doesn't [15:40] look quite how we would want it to [15:42] because it's not very readable with all [15:44] the words sort of squished together like [15:46] that. So, there are two ways that we can [15:48] fix this. The first is that we could add [15:50] strings to meal plan to create spaces. [15:54] So here I'm actually concatenating a [15:56] space in between breakfast and lunch. [15:59] And I can also do that between lunch and [16:02] dinner. Let's see what this looks like. [16:04] So now this is much more readable. We [16:06] can see that our meal plan is pancake, [16:09] salad, and pizza. This works, but it's a [16:12] little bit long and messy. So the other [16:14] thing that we can do, especially for a [16:16] small program like this, is that we can [16:18] just add the spaces to our strings. So, [16:21] I'm going to add a space after pancakes [16:24] and after salad, but not for pizza [16:26] because that's the end of the line, so [16:28] we don't need it there. Now, let's take [16:29] a look at what this looks like. You can [16:31] see the result is the same. Also, here [16:34] in meal plan, I could add a whole new [16:37] string. So, to the beginning, I'm going [16:39] to add a string that says today I will [16:41] eat colon plus breakfast, lunch, and [16:44] dinner. And as you can see, that's going [16:46] to print it out all as one string. Are [16:48] you ready for a challenge? Here it is. [16:51] Your challenge is to create a daily [16:53] planner. A simple daily planner because [16:56] it's going to print a sentence that [16:57] outlines your plan for today. You're [17:00] going to start by making three [17:01] variables, morning, afternoon, and [17:03] evening. To each variable, I want you to [17:06] add a string containing one activity, [17:09] and that can be anything you want. [17:11] Taking a nap, climbing a mountain, [17:12] skiing, studying Python, whatever you [17:15] want to do for today. Then I want you to [17:17] add all the variables together and save [17:20] to another variable called plan for [17:22] today. Here's an example of what I want [17:25] your final string to look like. My plan [17:28] for today is number one, first activity, [17:30] number two, second activity, and number [17:33] three, third activity. And here's a [17:35] hint, there's no magic to numbering this [17:38] list. Just go ahead and include the [17:40] numbers in your string. Go ahead and get [17:42] started. [17:47] Hopefully that went really well and your [17:49] day is going to be really exciting or [17:51] relaxing depending on what moves you. [17:53] I'll get started by creating my three [17:55] variables. In the morning I want to [17:58] drink some coffee. I'm going to make [18:00] sure to include a space at the end of my [18:03] string for when I concatenate. And then [18:06] I will create another variable called [18:09] afternoon. And in the afternoon I want [18:11] to study Python followed by a space. And [18:14] in the evening I want to have a dance [18:18] party. And this is the end of the list. [18:21] So I won't add a space. Now it's time to [18:23] put my strings together. And I will [18:25] start by creating a variable called plan [18:27] for today. I'm going to start with a [18:30] string. My plan for today is colon plus [18:34] morning plus afternoon plus evening. Now [18:38] I will print my plan for today to make [18:41] sure everything looks okay. Open up my [18:44] terminal, clear everything out, and run [18:48] my program once again. All right, this [18:50] almost looks good. It looks like I just [18:52] need to make sure I have a space between [18:54] the colon and the one here. So I will go [18:57] ahead and add that. Add a space right [18:59] here. Save. And let's run it again. And [19:02] now it looks good. Great job so far. [19:05] Hopefully, writing Python is starting to [19:07] feel a little more comfortable as you [19:09] get used to the syntax and building up [19:11] that muscle memory. [19:19] Let me introduce you to something that's [19:21] going to make formatting strings a lot [19:23] easier. They're called fstrings, and [19:25] they let you drop variables directly [19:28] into a string as a placeholder. Here's [19:30] what it looks like. I'll create a [19:32] variable called about me and in it I'm [19:34] going to write a string with curly [19:36] brackets where I want Python to insert [19:38] values. So I'll say my name is name in [19:41] curly brackets, my favorite color is [19:44] color and my favorite place to eat is [19:48] restaurant. Now I'll define the [19:50] variables and convention is to put them [19:52] at the top of the file. I'll set name to [19:55] treasure, color to blue, and my favorite [19:58] restaurant is called bow tie. Now, [20:00] here's the important part. In order to [20:02] make this an F string, I'm going to put [20:05] an F in front of the string. And the F, [20:08] by the way, stands for format. Let's [20:10] print about me and see what happens. [20:12] Python found each variable, pulled its [20:14] value, and dropped it into the string [20:16] where the curly brackets were. Without [20:18] the f, Python will print the string [20:20] exactly how it looks here with the curly [20:23] brackets and everything, as long as I [20:26] save the file first. There you go. Let's [20:28] go ahead and put the f back. And here is [20:31] your challenge. For your challenge, [20:33] you're going to create an excuse [20:35] generator. Say a friend invites you out [20:37] and you don't want to go. You're going [20:38] to write a program that generates [20:40] excuses for why you have to stay in. [20:42] Step one is to define these variables. [20:45] First name, event, number, noun, and [20:48] verb. And you can use whatever values [20:49] you want to define these variables as [20:51] long as they match the format. So have [20:53] fun and feel free to be creative with [20:55] this because your next step is to write [20:57] an fstring using your variables that [21:00] generates a one-s sentence excuse. And [21:02] I've included an example of what your [21:05] excuse should look like. This one says, [21:07] "Sorry, Ted, I can't go to the movies. I [21:09] have 345 B's to crochet." And honestly, [21:13] it's taking a little longer than [21:14] expected. The brackets in the sentence [21:16] are where you're going to want to drop [21:17] in your variables. And the idea here is [21:20] to be able to quickly change the [21:21] sentence to create whatever wacky [21:23] excuses you want. So the third step is [21:25] to print it. After you've printed your [21:28] first excuse, I want you to change some [21:30] or all of the values to create a brand [21:32] new excuse. And then go ahead and print [21:35] again. Go ahead and get started. [21:38] Hopefully that went really well and [21:39] you've generated some good excuses. Let [21:42] me show you what I did. I'm going to [21:44] start by creating my sentence, which [21:45] I'll save to a variable called excuse. [21:48] make an F string and then I'll say sorry [21:52] name. I can't go to event. I have number [21:57] noun to verb and honestly it's taking [22:02] longer than expected. Now I'll define my [22:05] variables. I have first name say gym. [22:08] The event I'll say is the concert. Enter [22:12] a big random number. For noun I'll say [22:15] saucepans. And for a verb, I'll say [22:18] scrub. Now I'll print my excuse. Let me [22:21] go ahead and comment out my code at the [22:24] top of the file. And we'll clear this [22:26] and run again. Looks like I have a [22:29] little mistake here. This should be [22:31] first name. Let's try this again. Sorry, [22:34] Jim. I can't go to the concert. I have [22:36] 3,432 [22:38] sauce pans to scrub. And honestly, it's [22:40] taking longer than expected. All right. [22:42] Now, let me try changing some of the [22:44] variables. [22:50] Nice work on this one. Keep going. [22:58] Amazing work so far and a big [23:00] congratulations is in order because [23:02] you've now learned enough Python to [23:04] start building the payup app. And we're [23:07] going to start by building the display, [23:10] also known as what your users will see [23:12] when they're done running the program. [23:14] Before writing any code, let's look at [23:16] the example output, which I've included [23:19] in a file right here. This is what your [23:21] finished output should look like. We [23:23] have a little introduction to the [23:24] program. Then you're going to say, [23:26] here's the breakdown for whatever event [23:28] or occasion they're wanting to split an [23:31] expense for. Then we're going to display [23:32] the cost, the service charges, the group [23:35] size, the grand total, and finally, what [23:38] each person will owe. I also want you to [23:40] notice that for readability, we have [23:42] some empty lines in the display. You may [23:45] remember that we can create space with [23:47] empty print calls and this makes it look [23:49] a lot nicer and as I said, more readable [23:52] for the user, which is very important. [23:54] Now that you know what you're going to [23:55] build, let's jump straight into the [23:57] challenge. Your challenge is to create [23:59] the output display for the payup app. [24:01] And step one is to check out the [24:03] example, which we just did, but be sure [24:05] to reference it as you're building. Step [24:08] two is to define a variable for each [24:10] item. We need a variable for the event [24:12] name, cost, service charge, group size, [24:15] grand total, and total per person. And I [24:18] want you to go ahead and use the madeup [24:20] values in the example output for now. [24:23] We're going to do the math in later [24:24] scripts. Your third step is to build the [24:27] display line by line using print [24:29] statements and franks. And finally, I [24:32] want you to run it and make sure that it [24:34] matches the example. Go ahead and get [24:37] started on the challenge. I know you can [24:39] do it. [24:42] Hopefully that went really smoothly for [24:44] you. Let's get into the solution. I'll [24:46] start by defining my variables. I'll [24:49] make a variable called event. The event [24:51] is dinner at Fantastic Pizza, cost, [24:54] service charge, group size, brand total, [24:59] and total per person. Now that I've [25:01] defined my variables, let's take a look [25:03] at the example and see what I need to [25:05] do. So, I'll start with the first four [25:06] lines. I'll need an introduction, a [25:08] space, the sentence where I'm going to [25:11] drop my event, followed by another [25:13] space, [25:14] add my space, the f string where I'll [25:17] drop my event variable, followed by [25:19] another space. I'm going to pause here [25:21] and run my program just to make sure [25:23] that I haven't made any mistakes so far. [25:26] This looks pretty good so far, but if I [25:28] compare it to my example output, you can [25:31] see that I forgot the colon at the end [25:33] of the line. So, I'll go ahead and add [25:34] that. Okay, let's keep going. Now, I'm [25:38] going to need the next four lines, which [25:40] are all fstrings, where I'll drop my [25:42] next four variables. So, I have cost, [25:45] service charge, group size, and grand [25:47] total. [25:49] Put my service charge here. Then I have [25:53] group size, and grand total. This is a [25:57] really good example of why it's good to [25:59] stop and check your work as you go. [26:01] because I've already noticed that I [26:03] forgot to put the f in front of the [26:05] strings to make them fstrings for every [26:07] single one of these variables. So, let's [26:09] check this and see. And as you can see, [26:12] it's just printing my variables. So, [26:14] I'll go back and turn these all into [26:16] fings. [26:19] Now, let's try this again. So far, this [26:21] is looking like the example. So, that's [26:23] great. Let's look at the final lines. [26:25] The final lines, it looks like, are a [26:27] space and then each person must pay up. [26:29] And this is where we're going to drop [26:31] our total per person variable. So let's [26:33] go ahead and finish up. This line should [26:36] say each person must pay up total per [26:41] person. This should be done for now. [26:43] Let's clear out the terminal and give [26:45] this a final check. All right, this is [26:48] looking good. We've got the display done [26:50] for our payup app. But there's a lot [26:53] more to come. So keep going and [26:55] fantastic work. [27:03] So far, every value in our program has [27:05] been hardcoded, meaning it's fixed in [27:07] the code itself and only changes if you [27:10] go in and manually edit it. But what if [27:12] you want your program to work with [27:14] information you don't have yet? That's [27:16] where the input statement comes in. [27:18] Input takes a string, which is a prompt, [27:21] and waits for the user to type [27:23] something. So, into input, I'll put the [27:25] string, what is your name? Let's run [27:28] this. And you get a prompt, and you can [27:30] type something in. But notice that [27:32] there's no space before the cursor. And [27:34] it doesn't look very good. It looks a [27:36] little bit cramped. So, this is an easy [27:38] fix. We're just going to come up here [27:40] and add a space before the closing [27:42] quote. Now, let's run this again. And [27:44] that looks a little better. But you may [27:46] have noticed that when I enter [27:48] something, it doesn't seem to go [27:50] anywhere. Okay? And that's because we [27:51] haven't done anything with the input [27:53] yet. We need to print it. So I'm going [27:55] to surround the input statement with a [27:58] print statement. And that's going to [27:59] tell Python that we want to print [28:01] whatever the user inputs. So let's clear [28:04] this out and run again. And this time [28:07] I'll put my name treasure. And it prints [28:09] out the name treasure. But this isn't [28:11] super useful on its own. To actually do [28:14] something with the user input, we need [28:16] to save it to a variable. So I'm going [28:18] to remove the print statement from [28:20] around the input and I'm going to save [28:22] the input to a variable called name. And [28:25] then I can print the name and we'll [28:27] still print my name in the terminal. But [28:29] the cool part is that whatever the user [28:31] types is going to get stored in the [28:33] variable name which I can use anywhere [28:36] in my program like in an fstring. So in [28:38] my print statement I can create an [28:41] string that says nice to meet you name. [28:44] And when I run the program, looks like [28:46] we forgot this final quote here. And now [28:49] when I run a program and enter a name, [28:52] it will echo back that name to me as a [28:54] greeting. This has a lot of great uses [28:56] because it can make programs a lot more [28:58] dynamic and fun. And hopefully that's [29:01] what you will discover in your [29:02] challenge. Notice that we have a file [29:05] called excuse generator, which looks a [29:07] lot like the excuse generator from a [29:09] previous scrim. Here's your challenge. [29:11] You're going to update the excuse [29:13] generator to accept user input. Right [29:16] now, all of the variables are hardcoded, [29:19] which means they're never going to [29:20] change unless you type a change [29:22] manually. So, I want you to replace each [29:25] variable's value with an input prompt. [29:28] Then, you're going to print and make [29:30] sure that your output still looks as [29:32] expected. Go ahead and give this a try. [29:38] So for the first input, I could say [29:41] something like what is the name? I could [29:44] say who invited you. There are many [29:48] things I could say here, but what I'm [29:50] going to go with is who is the excuse [29:53] for? And I'm remembering to include a [29:55] space to make it look a little nicer as [29:57] a prompt. For event, I'll simply say [30:00] what's the event for number. Maybe you [30:04] remember doing Mad Libs in school. is [30:06] kind of like that. So, I'm going to [30:07] simply say enter a number. For noun, [30:11] I'll say enter a noun. Or to be a little [30:14] more specific, let's say to enter a [30:16] plural noun. And finally, for a verb, [30:19] I'll say enter a verb. Let's run this [30:22] program and see what it looks like. [30:24] Python excuse generator.py, [30:27] we'll say the excuse is for pair. The [30:29] event is work. Number is 300 unicorns [30:34] and the verb will be brush. Sorry pair, [30:37] I can't go to work. I have 300 unicorns [30:39] to brush and honestly it's taking longer [30:42] than expected. Input statements really [30:45] help your programs become more fun and [30:47] interactive. Awesome work so far. [30:57] Now that you know how to gather user [30:58] input, we can upgrade the payup app. [31:01] Instead of just hard- coding the [31:03] information, we're going to get some of [31:05] it from the user. So, right away, here [31:08] is your challenge. Your challenge, as I [31:10] said, is to gather input from the users. [31:13] We need to get four things from the [31:15] users. The name of the event or [31:17] occasion, the cost, the tip or service [31:19] charge, and how many people are [31:21] splitting the bill. The first step of [31:23] the challenge is to replace the [31:24] hard-coded values for event, cost, [31:28] service charge, and group size. You're [31:31] going to replace those hard-coded values [31:33] with input prompts. You can keep grand [31:36] total and total per person hard-coded [31:38] for now because they won't be entered by [31:40] the user. Then finally, I want you to [31:43] run the program and make sure that your [31:45] prompts are clear and the display looks [31:48] right. Keep in mind that we're not [31:49] having our app calculate anything yet. [31:52] So, the numbers aren't going to be [31:54] correct because these values are going [31:56] to stay hardcoded. It's going to [31:58] continue to say that the grand total is [32:00] 330 and the total per person is 110 no [32:03] matter how these values change up here, [32:05] but we'll fix that later. Now, what do I [32:07] mean by make sure your prompts are [32:09] clear? What I mean is that your prompts [32:11] are instructions for the user. So the [32:14] clearer they are, the more likely you [32:16] are to get back what you need. For [32:18] example, if one of my inputs was service [32:22] charge, this leaves a little bit too [32:25] much room for interpretation. If this [32:27] were the prompt, somebody might think [32:28] that we want them to calculate the [32:30] service charge themselves and then enter [32:32] it in. So, they might enter the dollar [32:34] amount or they could type 20% with a [32:37] percent symbol or 20% or as a response [32:41] to this prompt, you could even just say [32:43] yes, there was a service charge. So, [32:46] here's a prompt that is more specific [32:48] and helpful. [32:50] Was there a tip or a service charge? [32:52] Enter a whole number. Example, 20 for [32:55] 20%. Because what we're looking for here [32:57] is a percentage as a whole number so [33:00] that we can use it to calculate the tip [33:02] or service charge based on the cost of [33:05] the expense that the user wants to [33:07] split. So keep in mind that specificity [33:09] matters to make sure you're getting the [33:11] data you expect from the user. Just [33:13] something to keep in mind. I'm going to [33:16] comment this out so you can still [33:17] reference it. And now go ahead and give [33:20] this challenge a try. [33:25] I'll start by deleting all of my [33:27] hard-coded values. For the event input [33:30] prompt, I'm going to make my prompt, [33:33] "What was the event or occasion?" For [33:36] the cost, I'll put something a little [33:38] more conversational. Let's say, "How [33:40] much was it?" One thing worth flagging [33:42] here is that we do want to be specific [33:46] to an extent, but for the most part at [33:48] this stage, we're going to trust the [33:49] user to enter exactly what we've asked [33:52] for. So here, instead of entering [33:54] something like 300, they could enter 300 [33:58] with a dollar sign or they could even [34:00] type 300 or something like that. And [34:03] this would cause the program to break or [34:05] give you bad output. Later on in the [34:08] course, we're going to talk about error [34:09] handling in input validation and all the [34:12] things that you can do to make sure that [34:14] you're getting the data you expect. But [34:16] for now, we're going to keep it simple, [34:18] be specific where we can, and make the [34:20] assumption that our user is going to [34:22] enter exactly what we ask for, the right [34:25] format, the right data type, nothing [34:27] unexpected. So, let's move on. For [34:29] service charge, I'm going to grab the [34:31] example up here. And finally, for group [34:35] size, my prompt will be how many people [34:38] were in your group. Let's run the [34:41] program and test this out. We'll say the [34:44] event or occasion was dinner at Al's [34:46] Diner. It cost $300. There was a 10% [34:51] service charge. And I see that we're [34:52] missing a parenthesy here. So, we'll [34:54] need to fix that. Four people in our [34:56] group. And the display prints just fine. [34:58] And everything seems in its place. So, [35:01] I'll go ahead and add this parenthesy [35:03] where it's needed. And we'll call that [35:05] good for now. So, we've got the inputs [35:07] working and the app is starting to take [35:09] shape. Amazing work. [35:17] To continue building the payup app, [35:19] we're going to have to learn a little [35:20] bit more math in Python. You've already [35:22] seen some addition. For example, if I [35:25] were to print 20 + 10, that would [35:27] evaluate to 30. The word evaluate in [35:30] Python refers to how Python will compute [35:32] an expression down to a single value. To [35:35] subtract in Python, you can use the [35:37] minus symbol. So, 20 - 10 would evaluate [35:40] to 10. You can divide with a backslash. [35:43] So 20 divided by 10 would evaluate to [35:46] two. You can multiply using the [35:48] asterisk. So 20 * 10 would evaluate to [35:52] 200. Just like with addition, you can [35:54] perform any of these operations on [35:56] variables. For example, let's pretend [35:58] for a second that I have a novelty tie [36:00] collection and the current number of [36:01] ties in my collection is 15. Now let's [36:03] say I went out and bought three more [36:05] ties. If I wanted to keep track of the [36:07] total number of ties in my collection, I [36:10] could create a new variable called total [36:11] ties and set that to the value of [36:14] current ties plus new ties. Let's print [36:17] total ties. Let me quickly comment out [36:19] these earlier print statements so we can [36:21] see a little better what we're doing. [36:22] So, Python finds the value of current [36:24] ties and new ties, adds them together, [36:27] and saves that value to the variable [36:29] total ties. As we can see, total ties is [36:32] 15 + 3, which is 18. Now, say each new [36:35] tie costs $5 and I want to know how much [36:37] I spent. I'll create a new variable [36:39] called total cost and I'll say 5 times [36:42] the number of new ties. If I print the [36:44] value of total cost, it should give me [36:47] 15. And it does. Now, say I realize that [36:50] I have just way too many ties in my tie [36:53] collection and I decide to sell 10 of [36:55] them. Let's make a variable called [36:57] remaining ties and that will be my total [36:59] number of ties minus the 10 that I sold. [37:02] Let's see how many ties we have left. [37:04] Our total number of ties is 18. So, we [37:08] should have eight left. There we go. [37:10] Eight ties left. Finally, I'm done with [37:12] ties. I want to start collecting [37:14] something else. So, I decide to gift [37:16] what's left evenly among my four best [37:18] friends. I could calculate how many ties [37:20] goes to each friend by dividing my [37:23] remaining ties by four. I'll save that [37:25] to a variable called ties per friend. [37:28] And let's print how many ties goes to [37:30] each friend. Looks like I have, let me [37:32] fix this typo. I have eight ties. So, [37:34] two ties go to each friend. Notice that [37:37] division always returns a decimal in [37:39] Python, even when the result, as it is [37:41] here, is a whole number. We'll learn [37:43] more about decimals in Python later, but [37:46] just keep that in mind for now. One more [37:47] thing I want to show you is that you can [37:49] also do math in fstrings. So, instead of [37:52] saving the result to a variable first, [37:53] you can do the calculation right inside [37:55] the curly brackets. So, I could say [37:57] something in an F string like I have [38:00] current ties plus new ties ties in my [38:04] collection. And right in the fstring, [38:06] it's going to find the value of current [38:08] ties and new ties and add them together [38:11] for us and inject them into the [38:13] sentence. And the result is I have 18 [38:15] ties in my collection. This works fine [38:17] for simple math, but it can get hard to [38:19] read. So, in general, it's cleaner to do [38:22] the math ahead of time and then save it [38:24] to a variable. I'm going to go ahead and [38:25] comment out these examples so that I can [38:28] give you your challenge. Your challenge [38:30] is to practice arithmetic operators, [38:32] which is just a fancy way to say [38:34] practicing addition, subtraction, [38:36] multiplication, and division in Python. [38:38] Here, I've given you three word [38:40] problems, and I want you to solve them [38:41] using the following steps. First, save [38:44] each value to a variable. I'm going to [38:46] leave it up to you to decide what to [38:48] name the variables. Next, I want you to [38:50] do the calculation and save to another [38:54] variable. And finally, print the [38:56] results. Go ahead and get started on [38:58] this challenge. [39:06] Okay, let's get started on the first [39:07] problem. You have 200 songs in your [39:09] library. You delete 47. Print how many [39:12] are left? So, I'll save the value 200 to [39:14] a variable called total songs. Then I'll [39:17] make another variable called deleted [39:18] songs and assign that to 47. Then to a [39:22] variable called remaining songs, total [39:25] songs minus deleted songs. Now we can [39:29] print remaining songs and get the number [39:32] of songs we have left. We're left with [39:36] 153 songs. The next one says, "A movie [39:38] ticket cost $12. You're buying for [39:40] yourself and two friends. Print the [39:42] total cost." So we have a movie ticket [39:46] that costs $12. And the number of [39:49] tickets we need is three. So the total [39:52] number of tickets that we need would be [39:55] movie ticket. And maybe a more [39:56] descriptive variable for this would be [39:58] movie ticket cost. Movie ticket cost [40:01] times number of tickets. Now we can [40:05] print total tickets. And we've [40:06] calculated that we need $36 to buy three [40:09] movie tickets. Finally, you have 48 [40:11] stickers to share equally. among six [40:14] friends. Print how many stickers each [40:16] person gets. So we have stickers which [40:19] we'll set equal to 48. The number of [40:22] friends we have is six. And so stickers [40:26] per friend would be stickers divided by [40:29] friends. Now we can print stickers per [40:32] friend. And eight stickers go to each [40:34] friend. [40:42] Let's talk about something that might [40:43] trip us up when we try to do math in the [40:45] payup app. Let's say we have a value [40:48] cost and a value service charge. Notice [40:51] I've made both of these values strings. [40:54] Now I'm going to try to print the sum of [40:56] these values. We would expect to get the [40:58] value 330 because 300 + 30 is 330. But [41:03] instead we get 30,030. [41:06] And that's because Python didn't add the [41:08] numbers. It just stuck them together [41:10] like strings because as I said, they are [41:13] strings. This is important because [41:15] that's always going to be the case with [41:17] user input. Input always returns a [41:21] string no matter what the user types. So [41:24] before we can do any math, we need to [41:25] convert our strings to numbers. Every [41:28] value in Python has a type and we can [41:31] check it using Python's built-in type [41:33] function. So I'm going to print the type [41:36] of cost. The type function tells us that [41:39] the type of cost is a string. To convert [41:42] it to a whole number, we can use a [41:44] built-in Python function called int. [41:47] Let's print the type again. Now the [41:49] value of cost is an integer which is a [41:51] whole number positive or negative. But [41:53] the payup app is going to be working [41:55] with money which means we need decimal [41:58] numbers. In Python, a decimal number is [42:00] called a float or a floating point [42:03] number. We can convert a value to a [42:05] float using the built-in function float. [42:08] Now, it says the type is float. And if [42:10] we print the value, you'll see that it's [42:13] 300 with a decimal. Now, how do we apply [42:16] this to an input? Let's make one really [42:18] quick. I'll make an input called budget. [42:21] And the prompt will be what is your [42:24] budget for the project? Let's print [42:26] budget. And let's also print budgets [42:29] type. So it's prompting me for my [42:31] budget. I will say my budget is 450. And [42:35] it prints my budget and lets me know [42:37] that this is a string. To convert this [42:39] number to the float, I can wrap the [42:42] entire input statement in the float [42:45] function. Now if we run again and I say [42:47] my budget is $450, [42:50] it prints $450.0 [42:53] and the class is now float. This way, if [42:56] we try to add it to something, let's say [42:58] I want to add $100 to my budget, I'm [43:02] able to add this number properly to [43:04] another number because I have converted [43:06] it to the correct type. First, I took [43:09] the string, I made it into a float, and [43:12] I can now add it to another number. By [43:14] wrapping the float around the input, [43:17] that ensures that whatever the user [43:19] types gets converted immediately. Now, [43:22] it's time for a challenge. Your [43:24] challenge is to build a simple paycheck [43:26] calculator. So, we're starting with [43:28] these two hard-coded values. And if we [43:31] wanted to calculate a paycheck based on [43:33] an hourly rate and the hours worked, we [43:36] do something like hourly rate times [43:39] hours worked. But, as you can probably [43:42] guess, this isn't going to work because [43:44] hourly rate and hours worked are [43:46] strings. So, Python doesn't actually [43:48] know what to do when we multiply two [43:50] strings together. So it simply gives us [43:53] an error. String object cannot be [43:55] interpreted as an integer. In other [43:58] words, I don't know what you're trying [43:59] to do here. So what I want you to do is [44:02] instead of these hard-coded values, [44:04] prompt the user for their hourly rate [44:06] and hours worked. Then I want you to [44:08] convert the hourly rate to a float and [44:11] the hours worked to an integer. Type [44:13] check both of the variables and then [44:16] multiply them together and print the [44:18] total pay. Go ahead and give this a try. [44:23] Hopefully that went well for you. Let's [44:25] get into the solution. So, I'm going to [44:27] replace this hard-coded value with an [44:29] input and my prompt will be what is your [44:32] hourly rate. For hours worked, my prompt [44:36] will be how many hours did you work? [44:39] Now, I'll convert the hourly rate to a [44:41] float and the hours worked to an [44:44] integer. Let's go ahead and print the [44:46] types of both. [44:49] I'll say my hourly rate is 25 and I [44:53] worked 88 hours. So now we know that [44:56] hourly rate is a float and hours worked [44:58] is an integer which means I can do the [45:01] next step. I'll create a variable called [45:03] total pay and total pay will be hourly [45:07] rate times hours worked and then we'll [45:11] print total pay. Let's give this a try. [45:14] Again, I'll say my hourly rate is 25 and [45:17] I worked 88 hours. And as you can see, [45:20] we've successfully calculated the [45:22] paycheck. Really amazing work here. [45:24] Let's keep going. [45:31] Here we are back in the payup app where [45:33] I want to take a look at our input [45:35] statements. As we've learned, right now, [45:37] everything is coming in as a string. But [45:40] let's think about what we're going to do [45:41] with each of these values. event is just [45:44] going to be displayed. We don't need to [45:46] do any math with it. So, it's fine if it [45:48] stays a string. But cost, service [45:50] charge, and group size are all going to [45:53] be used in calculations. What we [45:56] ultimately need to do is calculate the [45:58] service charge based on the total cost. [46:00] So, for example, if we get an input [46:02] saying there's a 10% service charge and [46:05] the cost is $100, then we'll want to add [46:07] that 10% to the $100 to get our grand [46:11] total. Once we get our grand total, [46:12] we're going to want to divide it by the [46:14] group size to get the total per person. [46:17] Don't worry about remembering all that [46:19] now because we're going to work through [46:20] it. Right now, what we need to worry [46:22] about is that if we leave them as [46:24] strings, we're going to have problems [46:26] doing math with them. So, the question [46:28] is, what type do we need each one to be? [46:31] What type do we need to convert them to? [46:34] I'm going to leave that up to you to [46:36] figure out. But what I will say is that [46:38] cost needs to be a dollar amount. [46:40] Service charge is a whole number and [46:43] group size will also need to be a whole [46:45] number. So that is going to be your [46:48] challenge. Your challenge is to apply [46:50] type conversion to the payup app. I want [46:53] you to wrap the appropriate input calls [46:56] in a float or an int depending on what [46:59] type we're going to need. Then I want [47:01] you to type check the cost, the service [47:03] charge, and the group size. And then [47:05] finally, run the program to make sure [47:07] everything still works as expected. Go [47:10] ahead and get started on the challenge. [47:15] Cost is going to be a dollar amount, so [47:17] we're going to want to convert that to a [47:20] float. Service charge is a whole number, [47:22] so we'll convert that to an int. And [47:25] finally, group size is also a whole [47:28] number. So we'll convert it to an int. [47:31] Now let's move on to part two. Type [47:33] check cost, service charge, and group [47:35] size. So we can clearly see the types. [47:38] I'm going to comment out all of these [47:39] print statements for now. And we'll [47:41] print the type of cost, the type of [47:44] service charge, and the type of group [47:46] size. Say the event or occasion was [47:48] Sunday brunch. Let's make it really [47:51] expensive just for fun. Say there was a [47:53] 20% tip and there were six people in the [47:56] group. As you can see, we've ended up [47:58] with the cost as a float and the service [48:01] charge and group size as both integers. [48:04] So that's exactly what we want. Let's [48:07] uncomment the rest of our program so [48:09] that we can give it a final check and [48:11] make sure that it's working as we [48:13] expect. So far, our display looks as [48:15] we'd expect. I do want to point out that [48:18] the service charge right now says $20 [48:21] because we're not calculating based on [48:23] the cost yet, but that's totally fine. [48:25] We'll fix that later. But for right now, [48:27] the program is running and we have the [48:29] types we need to successfully do the [48:31] calculations. Great work. [48:39] At this point, you've learned all the [48:40] Python you need to update the payup app. [48:43] So, it does all the work of calculating [48:44] the total cost and splitting it between [48:47] the group. There are three things to [48:48] calculate. The grand total, the total [48:50] per person, and a new variable I'm going [48:53] to add right here called service charge [48:56] total. Here's your challenge. First, [48:58] you're going to calculate the service [49:00] charge total. From your prompt here, the [49:03] user is going to enter a whole number [49:05] percentage. So, you'll need to convert [49:07] that percentage to a decimal and [49:09] multiply it by cost to get the dollar [49:11] amount. And then you're going to save [49:13] the result to service charge total. If [49:15] you're unsure about the math or simply [49:17] not a math person, you can go ahead and [49:19] check out the hints MD file for a [49:21] walkthrough on how to do the [49:22] calculation. For step number two, add [49:24] cost and service charge total to get the [49:27] grand total. And you'll save that to the [49:29] grand total variable. Your third and [49:31] final step is to divide grand total by [49:33] group size to get the total per person. [49:36] To help things be a little clearer, I'll [49:38] move the variables. Step one is [49:40] calculating the service charge total. [49:42] Step two is calculating the grand total. [49:45] And step three is calculating the total [49:47] per person. Go ahead and give this a [49:49] try. [49:51] Service charge is a potentially tricky [49:53] thing here because the user is going to [49:55] enter a whole number percentage. So as [49:58] an input, you might get something like [50:00] 15 for 15%. To get that actual dollar [50:04] amount, you need to convert that [50:06] percentage to a decimal and multiply it [50:08] by the cost. So to convert 15 to a [50:12] decimal, you divide it by 100, which [50:14] would give you 0.15. I would then want [50:17] to multiply the decimal by the cost. So [50:20] let's say that they entered an expense [50:22] of $200. I would do.15 * 200. In other [50:27] words, 15% of 200 is 30. To translate [50:30] this into Python, I would take the cost [50:33] that the user entered and I would [50:35] multiply that by the service charge [50:38] divided by 100. So again, we're dividing [50:40] the percentage whole number by 100. So [50:43] to review quickly, we're converting the [50:45] whole number percentage to a decimal by [50:48] dividing it by 100 and then multiplying [50:50] it by the total cost. And that gives us [50:53] the dollar amount of the service charge [50:56] or tip. Now that we have that, we can [50:58] calculate the grand total, which would [51:00] be the cost plus the service charge [51:03] total. To use an example of real [51:06] numbers, again, if the user inputs a [51:08] cost of $100 and a service charge of [51:11] 10%, 10% of 100 is 10. So, we're adding [51:15] 100 + 10 to get the grand total, $110. [51:20] Now that we have a grand total, we can [51:22] divide that by the group size to get our [51:25] total per person. Now, let's save and [51:27] make sure it works. We'll say we went to [51:29] a karaoke night. It cost $200. There was [51:32] a 15% tip and there were three people in [51:36] the group. Looks like we have a couple [51:38] of adjustments here to make. First, I'm [51:40] going to get rid of our type checking [51:42] here at the bottom of the file so that's [51:44] not cluttering up our terminal. And [51:47] secondly, you'll notice that the math [51:48] here doesn't seem to add up. We have a [51:50] cost of $200. Service charges are 15. [51:54] And yet it says the grand total is $230. [51:58] And that is because here in our display, [52:01] we still have service charge in our [52:04] fing. But we've used service charge to [52:07] calculate a new variable, service charge [52:10] total. So if we change that in the [52:12] display, our math should be correct. [52:14] Let's clear everything out and try it [52:16] again. The event or occasion is karaoke. [52:20] Again, we'll say $200. The 15% service [52:23] charge, there are three people in the [52:25] group. So, now we have a cost of $200 [52:28] with $30 in service charges, which at [52:31] 15% is correct, a group size of three, a [52:35] grand total of $230, which does add up, [52:39] and each person must pay up [52:40] approximately $76. If you're thinking [52:43] that a number followed by many decimal [52:46] points is not an ideal way to display [52:48] money in this app, you're exactly [52:50] correct. So, join me in the next one and [52:52] we'll fix it. [52:59] Depending on the numbers that the user [53:01] plugs into PayUP, you might have seen a [53:04] number that looks something like this. A [53:06] whole number with a long string of [53:08] decimals. Because we're dealing with [53:10] money, we only need to show two decimal [53:13] places. And luckily, we can fix that [53:15] with a small addition to our f strings. [53:18] Let me show you an example. Let's say [53:20] I've made some kind of budget [53:21] calculator, and it says the money I have [53:23] left over from paying my bills is some [53:26] number with many decimal places after [53:28] it. I'll print an F string that says, [53:31] "This month, I have funds remaining [53:34] after I pay all of my bills." Inside the [53:36] curly braces, right after the variable [53:38] name, I'll add colon.2f. [53:42] The f tells Python that we're formatting [53:44] a float. And the 2 tells it to display [53:48] exactly two decimal places. So let's [53:50] take a look. And you'll see that it's [53:52] formatted it to display only the first [53:54] two decimal places. And because the [53:56] third decimal place is an 8, it has [53:59] rounded that up for us. And we've ended [54:01] up with $230.84. [54:04] So that's how you can format a float in [54:07] an F string. Here in the payup app, I [54:09] will give you a challenge. Your [54:11] challenge is to clean up the payoff [54:13] display by adding the float formatting [54:15] to all monetary values in the print [54:18] statements. So go ahead and do that now. [54:22] Okay, let's take a closer look at our [54:24] display and see which numbers could use [54:26] some formatting. Event is a string, so [54:28] we don't need it for that. Cost is a [54:30] monetary value where this formatting [54:32] would be helpful. So I'll add it here. [54:35] We'll also want to add this to the [54:36] service charge total. Group size is a [54:39] whole number. So we don't need it there. [54:41] Definitely need it for the grand total [54:43] as well as for the total per person. All [54:46] right, let's check this out. We'll say [54:48] the amount was 200 with a tip of 15% and [54:51] there were three people in the group. [54:53] Last time we entered these values, we [54:55] got 76 followed by many decimal points. [54:58] And as you can see, that's now nicely [55:00] formatted for us. Let's run this again [55:02] with long decimal numbers for every [55:04] value. The event was karaoke night. [55:06] We'll say it was 200 followed by many [55:09] decimal points. Service charge of 10%. [55:13] And there were five people in the group. [55:15] And as you can see, it's keeping all of [55:17] our monetary values down to two decimal [55:19] points, which looks a lot nicer. Only a [55:21] little bit more left to go now. Let's [55:23] keep at it. [55:33] Before we wrap up, let's add a couple of [55:35] finishing touches to the app. First, [55:37] let's move the line welcome to pay up to [55:40] the top of the file so it's the first [55:42] thing users see when they run the app. [55:44] Instead of having it appear after the [55:46] user inputs everything, a quick greeting [55:48] is going to set the scene and make for a [55:50] better user experience. It's going to [55:52] let people know what app they're using [55:54] before we start asking them a bunch of [55:56] questions. Secondly, if this were a [55:58] production app, meaning an app in the [56:00] wild that's being used by a lot of [56:01] people every day, it would need to [56:03] handle all kinds of unexpected output. [56:06] For example, when answering these [56:08] questions, a user might leave a field [56:10] blank or type the word 20 instead of the [56:12] number 20. Stuff like this is going to [56:14] cause unexpected results or even break [56:17] our app altogether. Handling unexpected [56:19] input is a little bit beyond where we [56:21] are right now, but there's one small [56:23] thing we can do to make our app more [56:24] forgiving. First, let me show you the [56:26] problem that we could run into. If the [56:28] user were to type 20% here instead of [56:31] 20, our program will crash because [56:34] Python can't convert the string 20% to [56:37] an integer. We've asked the user to [56:39] enter a whole number here, but that may [56:41] not stop them from entering 20% and [56:43] breaking the app. We can fix that with [56:45] the string method called strip, which [56:48] removes characters from the edges of a [56:50] string. Let me show you an example. I'm [56:52] going to comment out the app for now and [56:54] make a little room here and I'll make a [56:56] variable called percentage which I'll [56:59] set to the string value of 30%. Then at [57:02] the end of this string I'll use the [57:04] strip method to say I want to strip the [57:07] percent symbol out of this string. Now [57:10] I'll print percentage so you can see the [57:12] percent symbol has been removed or [57:14] stripped out of the string. Let's apply [57:16] the same idea to pay up. What we want to [57:19] do is say that whatever this input ends [57:22] up being, if there's a percentage sign, [57:24] we want to strip it out. So at the end [57:27] of input, I can say strip out the [57:30] percent symbol if there is one. So [57:32] remember that user input always comes in [57:34] as a string. By adding strip to the end, [57:37] we're telling Python to take what the [57:39] user inputs and strip the percent sign [57:41] out of it. And this allows the program [57:43] to continue as normal. So the percent [57:46] sign is stripped away, leaving us with [57:48] 20 as a string, which is then converted [57:50] to an int and saved as the integer 20 to [57:54] service charge. Let's take a final look [57:56] at our finished app with these changes. [57:58] For the service charge, we'll add 30 [58:00] with a percent sign. Say there were six [58:03] people in the group. And there you go. [58:05] Our app no longer crashes if somebody [58:07] mistakenly adds that percent sign. This [58:09] is just a little teaser for all the fun [58:11] things that you can do with string [58:12] methods, which we'll dig into properly [58:15] later on in the course. For now, [58:17] congratulations. You finished your very [58:20] first fully functioning Python app. That [58:23] really is a huge accomplishment. So, I [58:25] hope that you pat yourself on the back [58:27] and feel so so proud. [58:37] A huge congratulation because you have [58:40] just built your first robust Python [58:42] application. The PayUP app takes real [58:45] input, does real math, and displays a [58:47] clean, readable result. And you've [58:50] learned a lot along the way. We've [58:52] covered variables, strings, frings, user [58:54] input, data types, type conversion, [58:57] arithmetic operators, and string [58:59] formatting. These are crucial and [59:01] foundational Python skills. This course [59:03] will be released module by module and [59:06] module 2 is already in the works. So [59:08] hang tight. We have a lot more good [59:10] stuff coming for you in the near future. [59:13] I'm so glad you are here to learn Python [59:15] with me. Happy coding. [59:24] Hello and welcome. I hope you're ready [59:25] to learn more Python. In this section, [59:28] we're going to build a word scramble [59:30] game called Jargon Jumble. Let's take a [59:33] look at the final project. I'm going to [59:34] go ahead and run Python Jargon [59:37] Jumble.py. [59:39] For each round, we're going to show the [59:41] player a scrambled word that they will [59:43] have to unscramble. They'll be able to [59:45] ask for a hint. They'll be able to skip [59:47] the word, and they'll also be able to [59:49] completely quit out of the game. So, [59:51] let's go ahead and ask for a hint. The [59:53] hint is, of course, we'll hit the blank. [59:56] No problem. Well, within a couple of [59:58] days, maybe a week. So, I think that [60:00] this is the word deadline. After I guess [60:04] the word, the game will tell me how I [60:05] did. And I got the word right. So, it [60:07] confirms that and moves me to the second [60:10] round. Let's type a wrong answer and see [60:13] what it does. It tells me that I was [60:15] incorrect, but does give me the correct [60:18] answer. If I type skip, it moves me to [60:21] the next round, but also tells me what [60:23] the correct answer was. And finally, if [60:26] I type quit, the game tells me my final [60:29] score, gives me a bit of commentary, and [60:32] exits the game. Throughout this part of [60:34] the course, we're going to build this [60:36] game from scratch. And I think the [60:38] really fun part about this game is that [60:40] you'll be able to make it completely [60:41] your own by swapping in your own word [60:43] bank and doing your own theming. My word [60:45] bank is themed around tech and coding [60:47] jargon, but you'll be able to use [60:49] whatever hints and words that you want. [60:51] As we build Jargon Jumble, we're going [60:53] to learn about lists. Lists are a Python [60:56] data type used to store and work with [60:58] collections of data. We're also going to [61:00] learn about importing modules, which [61:03] means bringing in pre-written code to [61:04] extend what Python can do. We'll learn [61:07] about ifels blocks to make decisions in [61:09] our code based on conditions. We'll [61:12] learn about while loops to repeat code [61:13] automatically. We'll learn more about [61:16] string methods to transform and clean up [61:18] text. We'll also learn about a Python [61:21] data type called tpples. Tpples pair [61:23] related data so that they don't go out [61:25] of sync. And just like last time, we'll [61:28] build the project in stages with lots of [61:30] opportunities to practice along the way. [61:33] Are you ready? Let's get into it. [61:42] The first thing we'll need for a word [61:44] scramble game is the list of words to [61:46] scramble. So, let's start making a list [61:48] of words. Let's see. I'll make a [61:50] variable called word one. And to it, [61:52] I'll save the value apple. And then I'll [61:54] make a variable called word two. And [61:56] I'll save the value orange. And then [61:58] I'll make a variable word three. And [62:00] I'll save the word banana. This seems [62:02] like it could get a little hard to [62:04] manage. Okay. I did this to show you [62:06] that trying to store a single value in a [62:08] variable often isn't going to cut it. [62:10] Sometimes you need to store many values [62:13] in a single variable. In this case, we [62:15] need a long list of words to scramble. [62:18] So, trying to use a separate variable [62:19] for every word is going to get hard to [62:22] maintain pretty fast. Luckily, Python [62:24] has a data type called list, which lets [62:26] you store multiple values in one place. [62:29] So, I'll make a variable called fruits, [62:30] and I'll set its value to an opening and [62:33] closing bracket. This is an empty list, [62:35] and I can fill it with multiple strings [62:37] separated by commas. So a list is [62:40] comma-epparated items in between an [62:42] opening bracket and a closing bracket. [62:44] Lists can hold any data type. As we've [62:46] seen, they can hold strings, but they [62:48] can also hold numbers. I can make a list [62:50] of floats. And I can even make a list of [62:53] lists. This is a list containing three [62:56] different lists. And just for fun, I [62:57] could even make a list of emojis because [62:59] emojis are just strings. Let's see what [63:01] a list looks like if I print it. Python [63:05] prints it out exactly as it appears in [63:06] the file. We'll learn later how to print [63:09] list items in a nicer looking way, but [63:11] now it's your turn to make some lists. [63:13] Here is your challenge. Your challenge [63:16] is to create some list data to populate [63:18] your personal portfolio site. First, [63:20] create a list called skills with three [63:22] skills you have or three skills you want [63:24] to learn. Second, create a list called [63:26] years with how many years you've spent [63:28] on each skill. Then, create a list [63:30] called about me with at least three [63:32] emojis that say something about your [63:34] personality or hobbies. You can open an [63:36] emoji picker to browse and insert emojis [63:38] using the keyboard shortcuts. So, [63:41] control, command, space on a Mac. And [63:43] for Windows, Windows plus period. [63:45] Finally, go ahead and print all three [63:47] lists. Go ahead and get started on the [63:49] challenge. [63:52] Hopefully, that went well. Let's start [63:54] making some lists. The first is a list [63:56] of three skills. Then the number of [63:58] years. And for the about me, I'll add a [64:02] microphone because I like karaoke, a [64:05] computer because I like programming, and [64:07] a palm tree because I like to travel. [64:09] Now, let's go ahead and print the three [64:11] lists. And everything looks good. Lists [64:14] let you keep a whole collection of [64:16] related values together in a single [64:18] variable instead of having to juggle a [64:20] separate variable for each value. You're [64:22] doing fantastic work. Let's continue to [64:24] learn about how to work with lists. See [64:27] you in the next one. [64:36] We've learned how we can use a list to [64:37] store multiple items in the same [64:39] variable, but we need a way to get an [64:41] item out of the list so that we can do [64:43] something with it. For example, we'll [64:45] need to be able to get a word out of the [64:47] list so we can scramble it and display [64:49] it to whoever is playing our game. Every [64:52] item in a list has a position called [64:54] index. And you can use that index to [64:56] access exactly the item that you want. [64:59] So let's say we wanted to access the [65:00] first item in this playlist. I can do [65:03] that with the variable name plus [65:05] brackets. And inside the brackets, I [65:08] want to include the list position of the [65:10] item that I'm trying to get out of the [65:12] list. In this case, the first item in [65:14] the list is you might expect it to be [65:17] one, but it's actually zero. This is [65:19] basically saying give me the item at [65:21] position zero in the list called [65:23] playlist. Now why is this in the zeroth [65:26] place instead of the first place? Well, [65:28] that's because Python and many other [65:30] programming languages start counting [65:32] from zero. This is called zero indexing [65:36] and it can feel a little weird to get [65:37] used to at first, but after you have [65:40] some exposure to it, I promise it will [65:41] start to feel more natural. So, I'll go [65:43] ahead and print this and you'll see that [65:46] gives me the first item in the list. So [65:48] let's separately print each item in the [65:50] list. And you'll see that gives me every [65:52] item in the list. There's also a [65:55] shortcut for when you want to grab the [65:56] last item in the list. So in a short [65:59] list like this, it's easy to go, I want [66:01] the last item in the list. So this is [66:03] item zero. This is item one. This is [66:05] item two. And then get the item out like [66:08] this. But imagine if you had a list of [66:10] several hundred items or a list whose [66:13] length is constantly changing. then it [66:15] might not be so easy to get the last [66:16] item in the list. So to get the last [66:19] one, you can access it at the index of [66:22] -1. So an index of negative 1 will [66:25] always give you the last item in the [66:27] list. [66:28] -2 will give you the second to last item [66:31] in the list and kind of on and on like [66:33] that. It's basically a way to go through [66:35] a list backwards. So what happens if you [66:37] try to access an index that doesn't [66:39] exist? For example, our list only goes [66:42] up to 012. So, what happens if we were [66:46] to try to access an item at index 10? [66:49] That gives us an index error index out [66:52] of range. This is Python telling you [66:55] that there's nothing at that position. [66:57] This is a pretty common error when [66:58] you're working with lists. So, now you [67:00] know what to look for. You can also save [67:02] index items to a variable and then do [67:05] something with them like use them in an [67:06] F string just like any other value. I'll [67:09] make a variable called top song and to [67:11] it I will save playlist zero. This is [67:13] getting the item at the zero index of [67:16] playlist. So now I can use this variable [67:18] in an fstring. Say something like now [67:21] playing top song. And that'll give me a [67:24] string with a value from the list. And [67:26] note that I could pull this value out of [67:27] the list right in the fsting without [67:29] saving it to a variable first if I [67:31] wanted to. And that yields the same [67:33] result. Now that you've learned a little [67:35] bit more about how to work with lists, [67:37] here is your challenge. Your challenge [67:39] is to build a help desk feature that [67:42] shows who's waiting in line for support. [67:44] I want you to use list indexing to [67:47] create a status display that looks like [67:49] this. It's going to say now helping Ada, [67:51] next in line is Grace, and just added is [67:54] Allen. You're going to build it based [67:56] off of this list. And now helping will [67:59] be the first person in line. Next in [68:00] line is the second person in line. And [68:03] just added is the last person in the [68:06] queue. Go ahead and give this challenge [68:08] a try. [68:12] All right, hopefully that went well. Let [68:14] me show you what I came up with. Going [68:16] to start by creating some variables and [68:18] saving the names I need. So I'll make [68:20] one called now helping. And this should [68:22] be the first person in line. So I need [68:24] the person at the zero index. The list [68:27] is called tickets. So I will say tickets [68:30] at zero index. Now I need the next [68:32] person in line. So I'll make a variable [68:34] called next in line and to that I will [68:37] save the second person in the queue. Now [68:40] I need the last person in the queue who [68:42] is the person who is most recently [68:44] added. So I'll make a variable called [68:46] just added and I'm going to use negative [68:49] indexing to get the last person in the [68:51] queue. Now that I have the people saved, [68:53] I can create my fstrings. So I'll say [68:56] now helping is the now helping variable. [68:59] Next in line is the person saved in the [69:02] next in line variable and just added is [69:05] the person saved in the just added [69:08] variable. Let's run this and make sure [69:10] it works. And that is looking exactly as [69:12] expected. Fantastic work. [69:24] To scramble a word, we're going to need [69:25] to do three things. First, break the [69:27] word into individual letters using the [69:30] list function. Then, we'll need to [69:32] shuffle those letters around. Then, [69:34] finally, join the letters back into a [69:36] string. Just like with list, you can [69:37] access individual letters in a string by [69:40] index. So, let's say I have the string [69:42] listen. I can use an index to access any [69:45] letter in the string. So, let's say I [69:48] want to get the T. That's 0 1 2 3. So, [69:52] index 3 is the T. I'll go ahead and [69:55] print this. and you'll see it gives me [69:57] back the T in listen. While we can [69:59] access individual characters this way, [70:02] unfortunately in Python, there isn't a [70:04] way to rearrange individual letters [70:06] inside of a string. To be able to [70:08] shuffle the letters, we need to convert [70:10] the string to a list. You've already [70:12] learned a few built-in functions in [70:14] Python that convert data from one form [70:17] to another. For example, int changes a [70:19] string into a number and float changes [70:22] numbers into floating decimal points. [70:24] The function list works in a similar [70:26] way. We can pass it a string and it will [70:29] break the string into individual [70:31] characters. To list, I will pass the [70:33] string listen. Then I'll go ahead and [70:36] save this to a variable and then print [70:38] the variable. And that gives me a list [70:40] of all of the individual letters in [70:42] listen. We've converted the string [70:45] listen into a list. So now we can work [70:47] with it just like a list. For example, [70:49] we can use a variety of list functions [70:52] on it. Like for example, the sorted [70:54] function. Sorted rearranges items in a [70:57] list so that they're in alphabetical [70:59] order. So we're converting the word [71:01] listen into a list. We're saving it to [71:04] the variable letters and then we're [71:05] passing this letters list to the sorted [71:08] function. Now I'm going to wrap this in [71:11] a print statement so that we can print [71:12] the result. And as you can see, the [71:14] sorted function has sorted all the [71:17] letters in a list so that they're in [71:18] alphabetical order. This is actually the [71:21] first step in solving a really common [71:23] programming problem, which is figuring [71:25] out if two words are anagrams. When two [71:28] words are anagrams of each other, it [71:29] means that they have the exact same [71:31] letters only rearranged. So, for [71:33] example, the word listen and the word [71:36] silent are anagrams of each other. And [71:39] we can verify that by splitting both [71:41] words into a list and then arranging the [71:43] letters alphabetically. To test this, [71:45] I'm going to change this variable name [71:47] to first word. And then I'll create a [71:49] variable called second word where I will [71:52] convert the word silent to a list. Then [71:55] I will sort first word and print it. And [71:58] I will also print a sorted version of [72:01] second word. Let's run and see the [72:03] result. We can see at a glance that both [72:05] of these lists contain the exact same [72:07] letters. And so we know that they are [72:09] anagrams. A little bit later we'll talk [72:12] about how to randomize the order of the [72:13] letters and stick them back together [72:15] into a string. But first, here is your [72:18] challenge. Your challenge is to write an [72:20] anagram check. So, for each pair below, [72:23] I want you to split both words into [72:25] lists, sort them, and print the results. [72:28] And you'll know that if the two lists [72:30] match, then they're anagrams. And if [72:31] they don't match, they are not anagrams. [72:34] Go ahead and give this a try. [72:38] Let's check for anagrams. I'm going to [72:39] start by converting my words to lists. [72:41] And this time for variable names, I'm [72:44] just going to go with the name of the [72:46] letter we're checking. So the first one [72:48] is earth. And I'm going to convert earth [72:50] to a list. And we're comparing that to [72:52] the word heart. And now I will print a [72:55] sorted version of each. Let's check this [72:58] before we move on. Let me go ahead and [73:01] comment out the example print statements [73:04] so that we can see clearly what we're [73:06] doing. Let's try this again. We have two [73:09] identical lists. So we know that earth [73:10] and heart are anagrams. Now let's do [73:12] below and elbow. [73:15] Again we have two identical lists. So we [73:17] know we have anagrams. And finally let's [73:20] do night and tight. [73:23] This time you should see that we do [73:25] actually have a difference in the two [73:27] lists. We have two letters that don't [73:29] match up. So we know night and tight are [73:31] not anagrams. Excellent work. Let's keep [73:34] going. [73:41] We've seen a few of Python's built-in [73:43] functions that work like shortcuts for [73:45] common tasks that we might otherwise [73:47] need to do ourselves. Functions like [73:49] print, list, or int. These are functions [73:52] that are automatically available, [73:54] meaning they're just sort of always [73:55] there for you to use. But there is also [73:58] a lot of built-in helper code that you [74:00] can import. The helper code that you can [74:02] import are called modules. And a module [74:05] is a file containing Python code that [74:07] you can import and use in your own [74:09] programs. To use a module, you bring in [74:11] the code using the import keyword. By [74:14] convention, it goes at the top of the [74:15] file. That way, all the code you write [74:18] afterwards has access to it. So, I'm [74:20] going to import the random module. Once [74:23] the module is imported, you can reach [74:25] its functions with dot notation. So, [74:28] let's say I can't decide which of these [74:30] lunch spots I want to eat at today. And [74:32] I want Python to choose for me. I'm [74:35] going to use a function called [74:37] random.choice [74:38] to randomly choose a lunch spot out of [74:40] this list for me. So, it's the module [74:43] name, which is random, a dot, and then [74:46] the function that I want to use. And [74:47] that's why it's called dot notation. So, [74:49] what I can do now is pass my list into [74:52] the random.choice function. And if I [74:55] print this, I'll see that it hands me [74:57] back a random spot for lunch. If I run [75:00] it again, I'll likely get a different [75:02] random choice. The random module also [75:04] has a function called random.shuffle, [75:08] and this takes in a list and rearranges [75:10] the items into random order. So, say I [75:13] wanted to show my lunch spots in a [75:15] different order each time. So, this will [75:17] shuffle the list. And when I print it, [75:20] you'll see that it rearranges my lunch [75:22] spots in a different order each time. [75:24] There's something a little bit unique [75:26] about random.shuffle that I want to talk [75:28] about quickly. Notice that I shuffled [75:30] the list and was able to print it [75:32] without saving it to a new variable. [75:35] First, I just called random.shuffle, [75:38] passing lunch spots into it on one line. [75:41] And the list itself, the lunch spot list [75:43] itself changed. And that's because [75:46] shuffle does what's called changing the [75:48] list in place. In other words, it [75:50] changes the original list directly [75:52] rather than handing you back a new copy [75:55] of the list. That makes it different [75:56] from something like the sorted function. [75:59] So I'll pass my list to the sorted [76:01] function and then I'll print it and then [76:03] I'll go ahead and print lunch spots [76:05] again. So the sorted function hands us [76:08] back a sorted copy of the list. So each [76:10] item is in alphabetical order. But if we [76:13] print the lunch spots list again, you [76:15] can see that the original version is [76:17] intact. And this is very different from [76:19] how random shuffle works because random [76:22] shuffle will shuffle the list itself [76:25] rather than making a copy of the list, [76:27] shuffling it, and handing you back that [76:29] copy. Don't sweat the details of this. [76:31] It's kind of an advanced concept for [76:33] now, but it is something to keep in mind [76:35] about random shuffle because it's what [76:37] we're going to use to scramble letters [76:39] for our word scramble. And now I'm going [76:41] to comment out these print statements [76:43] because it's time for a challenge. Your [76:46] challenge is that you're building a [76:47] feature for a board game app that sets [76:50] up each match. At the start of a game, [76:52] you need to put the players in a random [76:54] turn order and also randomly choose one [76:57] player to deal the cards. So step one [77:00] will be to shuffle the players into a [77:02] random turn order and then print the [77:05] players list. The second step is to [77:07] randomly choose one player to be the [77:09] dealer and print the name of who is [77:11] dealing this match. This is an example [77:13] of what your output should look like. Go [77:16] ahead and get started on the challenge. [77:20] Import random is already included at the [77:23] top of the file. Otherwise, that's the [77:24] first thing I would do. Since I already [77:26] have access to the random function, [77:28] first thing I'm going to do is shuffle [77:30] the players list. Then I'll go ahead and [77:33] print the shuffled list. Remember that [77:35] random shuffle shuffles this in place. [77:38] So all I have to do is print the list [77:39] and it should be shuffled. There we go. [77:41] There's our list shuffled in random [77:43] order. Next, I have to randomly choose a [77:46] dealer of the cards. So I'll start by [77:48] creating a variable called card dealer. [77:51] And I'll pick a random choice with [77:53] random choice passing the players list [77:56] to the function. Before I do my fing, [77:59] let me check my work and make sure that [78:00] I get a random player. There we go. I [78:03] get a random player each time. So I'll [78:06] go ahead and make this into an F string. [78:09] So I have card dealer deals first. And [78:13] each time I run the file, I get a random [78:15] card dealer. This is working as [78:17] expected. Excellent work. Let's keep [78:19] going. [78:27] You've learned how to split a word into [78:28] a list of letters and how to shuffle [78:31] those letters into a random order so [78:33] that they're scrambled. The last step is [78:35] reassembling the list of scrambled [78:37] letters back into a word. We can do that [78:40] using the join function. The join [78:42] function transforms a list into a [78:45] string. And it's called join because it [78:47] joins list items with a separator. Let [78:50] me show you what I mean. The syntax is a [78:53] little different than what we've seen [78:54] before because the separator comes [78:56] first. So I'm going to say I want to [78:58] join my list together with a comma. So [79:01] we're first defining a string that we [79:03] want to join our list with. Then we can [79:06] say dot join and then to join will pass [79:09] the list that we want to join. So I'm [79:11] going to go ahead and pass a list [79:13] directly to the join function. Like I [79:15] said, the syntax here feels a little [79:17] wonky, but you can read this as with a [79:20] comma, join this list. I'm going to save [79:23] this to a variable called result, and [79:24] then we'll print result to see what it [79:26] looks like. So now our list is a string [79:28] that says peace, love, happiness. The [79:31] words look a little jammed together [79:33] because there are no spaces. So I'm [79:35] going to add a space after the comma. [79:38] And as you can see, that looks a little [79:40] bit better. Notice that the separator [79:42] here is just a string. So, you can join [79:45] a list with pretty much any string. For [79:48] example, we could use a dash here. We [79:52] could use a word. And just for fun, we [79:55] could even use an emoji. You can even [79:57] join with nothing at all. In other [80:00] words, you can join with a completely [80:02] empty string. And that's just going to [80:05] shove all of the elements in a list [80:07] together. This isn't super for a list of [80:09] words, but let's say that each item in [80:11] our list is the letter of a word. The [80:15] result is that each letter in the list [80:16] is joined to form a single word. So [80:19] that's the last piece. After converting [80:22] a string to a list of letters and [80:24] shuffling them, join is going to put [80:26] them back together into a single word. [80:28] But here is a little bit of practice [80:31] using the join function. Your challenge [80:33] is to join various lists into a single [80:35] string. First, you'll create a URL by [80:38] joining this list with a forward slash. [80:40] Then, you'll join this list with a dash [80:43] to format a date. This list with a space [80:46] to create a cheer. And finally, you'll [80:48] join this list of letters into a single [80:52] string. Go ahead and get started. [80:58] I'll start by creating a variable called [81:00] URL. And then with a forward slash I am [81:03] going to join this list which I'll go [81:06] ahead and copy and paste. Next I've got [81:08] a date which I'm going to join with a [81:11] dash. Thirdly I have a cheer which I [81:14] will join with a blank space. Then [81:16] finally I have a word which I want to [81:19] join with no separator at all. Because [81:21] this list is already saved to a [81:23] variable. I can go ahead and pass in the [81:25] variable. The final step is to print [81:27] each variable. And let's have a look. We [81:30] have a formatted URL, a date, a cheer, [81:33] and a rejoined word. [81:41] Thanks to all of your amazing work so [81:43] far, you've got everything you need to [81:45] build the first part of the Word [81:47] Scrambler game. So, let's jump right [81:49] into it. Here's your challenge. First, [81:51] create a game file called [81:52] jargonjumble.py. [81:54] In this new file, I want you to create a [81:56] list of at least three words and save it [81:59] to a variable called words. Then you'll [82:01] use random.choice to pick a word from [82:04] the list. The fourth step is to use [82:06] list, random shuffle, and join to [82:08] scramble the word. And then finally, I [82:11] want you to print out the scrambled [82:12] word. You've totally got this. Go ahead [82:15] and get started on the challenge. [82:19] Hopefully, that went really well and you [82:21] have a word scrambler. Let's walk [82:23] through the solution. Step one, I am [82:25] going to create a new file called jargon [82:27] jumble. [82:28] Then I'll make a list and save it to a [82:31] variable called words. And I'll add a [82:33] few items to the list. Next, I need to [82:35] use random choice to pick a word from [82:37] the list. So at the top of the file, I'm [82:40] going to import random. And then to a [82:42] variable called word, I'll have it pick [82:45] a random word from the words list. [82:48] Before we continue, let's print word and [82:50] make sure this is working. Okay, run [82:52] this a couple more times and we're [82:54] getting a random item from the list. [82:57] Great. The next step is to scramble the [82:59] word using list, random, shuffle, and [83:02] join. So, first I'll convert the word to [83:04] a list and I'll save it to the variable [83:06] letters. So, to list, I'll pass my [83:08] randomly chosen word. So, now let's take [83:10] a look at letters. And I've split my [83:13] random word into a list. So, now I can [83:15] go ahead and shuffle the list. I'll do [83:17] that by using random.shuffle shuffle and [83:20] passing in my letters list. Now let's [83:23] print letters one more time. Clear this [83:25] out. Run again. And we have all the [83:28] letters in orange shuffled randomly. The [83:30] last step is to join them back together [83:32] into a string. So I'm going to get rid [83:35] of this print statement for now. Then [83:37] we'll create a new variable called [83:40] scrambled word. And then I want to join [83:43] with an empty string my list of letters. [83:46] The very last step, we are going to [83:48] print the scrambled word. And I'm going [83:50] to go ahead and print it in an F string [83:52] just so it's a little bit easier to see. [83:54] I'm going to say scrambled. And we'll [83:56] print the scrambled word. Let's give [83:58] this a final run through. The randomly [84:01] picked word was orange. And here is the [84:04] scrambled version. Let's run and try [84:06] this again with a different word. Looks [84:08] like it's going to keep choosing orange. [84:10] Here we go. Apple scrambled. So that's [84:12] great. This is working perfectly. Really [84:15] excellent work here. We've got the first [84:17] part up and running. Let's keep going. [84:28] We've completed a crucial part of the [84:29] word scramble game, which is, of course, [84:31] to scramble words. Another big component [84:34] is going to be figuring out whether or [84:36] not the player's submitted answer is [84:38] correct. To do that, we'll need to [84:39] compare the player's answer to the [84:41] correct answer and ask Python, are these [84:43] two things the same. And the way we can [84:46] do that is with equality operators. To [84:48] demonstrate equality operators, I'm [84:50] going to use the Python ripple. Ripple [84:52] stands for read eval print loop. This is [84:55] an interactive shell where you can [84:57] execute code one line at a time and see [84:59] the results immediately without having [85:01] to write and save a whole file. It's [85:03] perfect for small and quick testing. So [85:06] to open the rebel, I'm going to open my [85:07] terminal and make it a little bigger. [85:09] Give us some room here. And I'm just [85:12] going to type Python and hit enter. [85:14] You'll see this prompt with a group of [85:16] arrows. And that means that Python is [85:18] ready for our input. In the ripple, I [85:20] can do all sorts of things like I can do [85:22] some basic math. I could save something [85:24] to a variable and have Python call it [85:26] later. In the ripple, I can execute [85:29] pretty much any Python immediately. You [85:31] can exit the ripple with C. I'm going to [85:34] go ahead and clear it out and start the [85:35] ripple again by typing Python. And you [85:38] can also quit out of it by using the [85:39] quit function. Now let's look at [85:41] comparison operators. This is where you [85:43] compare two values using the double [85:45] equals sign. And Python gives us back [85:48] true. Notice that true is not a string. [85:52] This is a new to us Python data type [85:54] called a boolean. And a boolean can only [85:56] have two possible values which is true [85:59] or false. A boolean is always going to [86:02] be capitalized in Python. So true has a [86:04] capital T. And if I were to compare [86:08] apple to orange, that would give me [86:10] false with a capital F. If you're using [86:12] boolean and accidentally use a [86:14] lowercase, Python is going to think that [86:16] you're trying to use a variable name and [86:17] throw an error. So that's definitely [86:19] something to keep in mind. So this is [86:22] basically saying, is the string apple [86:24] equal to the string orange? And it's [86:26] not. So Python returns false. So the [86:29] double equal sign compares two values [86:31] whereas a single equal sign is for [86:33] assigning a value to a variable. It's [86:35] common to mix the two up. So just [86:37] something else to keep in mind. Let's [86:38] see what happens if I compare lowercase [86:41] apple to uppercase apple. This returns [86:44] false because the double equal sign is [86:47] case sensitive. And this is going to [86:48] matter later when we're comparing a [86:50] player's guess with a correct answer. [86:52] Another equality operator is the not [86:55] equal operator. So for example, I could [86:58] ask Python something like this. This is [87:01] the non equal operator, an exclamation [87:03] point followed by an equal sign. And [87:05] this is basically asking is it true that [87:08] cat is not equal to dog and that is [87:11] true. So Python returns true. So it's [87:13] doing the opposite of the double equals. [87:16] It's checking whether or not two values [87:18] don't match. The double equals and not [87:20] equal operators also work with numbers. [87:23] So I could say is 5 equal to 5 true is 5 [87:27] not equal to 5 false is 5 equal to 6 [87:31] false is 5 not equal to 6 and that's [87:35] true. So those are equality operators. [87:38] I'm going to type quit to exit the [87:40] ripple and close the terminal so we can [87:42] see how this might work in a file. Let's [87:44] say I have a password and I want to [87:47] check whether or not a password that a [87:49] user entered matches the password I have [87:51] here. So I'm going to create an input. [87:53] I'm going to call it user password. And [87:56] I'm going to prompt the user to enter [87:59] their password. And I'll print a [88:01] statement comparing whether the password [88:03] I have equals the user password. And [88:06] also just to demonstrate, I'm going to [88:08] print whether or not password does not [88:10] equal the user password. Let's open the [88:13] terminal back up and try this out. When [88:15] I run the file, it will prompt me for a [88:18] password. And I'm going to type in what [88:20] I know is the correct password. So we [88:22] get does password equal the user [88:25] password. And it does. So that returns [88:28] true. But when we check if the password [88:30] does not equal the user password, they [88:33] do in fact match. So Python returns [88:36] false. If I run this again and type a [88:39] password that doesn't match, you'll see [88:41] the results will flip. So now does [88:43] password equal user password? No. So [88:46] that's false. Does password not equal [88:48] user password? That is true. I'll go [88:51] ahead and comment out these print [88:52] statements so I can give you your [88:54] challenge. Your challenge is to build a [88:56] promo code checker for an online shop so [88:59] a shopper can enter a code and find out [89:01] whether or not it unlocks the flash sale [89:03] discount. So, step one, you're going to [89:05] prompt the user to enter a promo code. [89:08] Step two, print whether the user's input [89:10] is equal to the promo code and also [89:13] print whether the user's input is not [89:15] equal to the promo code. For a user [89:18] input, I want you to try both flash 50 [89:20] in all capital letters and flash 50 in [89:23] lowercase as a prompt. Just so you can [89:26] notice that because the double equals is [89:28] case-sensitive, the results are going to [89:31] flip. And this is the promo code that [89:33] you're going to be comparing against. So [89:35] go ahead and give this a try. [89:39] So I'll start by creating a variable [89:41] called user code and I'm going to use an [89:44] input to prompt the user and I'll say [89:48] enter your promo code. Then I will print [89:51] a comparison operator that asks is the [89:55] user code equal to the promo code. And [89:59] I'll also print an equality operator [90:01] that checks is user code not equal to [90:05] the promo code. Let's check this out. [90:09] All right. So first I need to comment [90:11] out this user prompt just so we don't [90:13] get confused. I'm going to control C out [90:16] of this clear and we'll run it again. So [90:18] first I'll enter the promo code 50 in [90:22] all caps. So is the user code equal to [90:25] the promo code? Yes, that's true because [90:27] I entered it exactly as we see the promo [90:30] code. And is user code not equal to [90:33] promo code? They are equal. So that's [90:35] false. Now let's run this again and try [90:38] it with a lowercase code. And you can [90:41] see that the results have flipped [90:43] because the equal operator and the not [90:45] equal operator are case sensitive. [90:48] Ideally in the real world, your user [90:50] would be able to enter either of these [90:52] prompts and they would both work. and [90:55] we're going to address that later as we [90:58] move along with our project. But for [91:00] now, you've done a really great job. [91:03] Let's keep moving right along. [91:11] Double equals and not equals check [91:13] equality between two values. But [91:16] sometimes you need to know which value [91:18] is bigger or whether one value is at [91:20] least as large as another. And this is [91:22] what comparison operators are useful [91:25] for. Let's take a look at them. I am [91:28] going to open up the terminal and start [91:30] running the Python ripple. Comparison [91:32] operators are basically symbols that [91:34] you've probably learned in a math class [91:37] like greater than, less than, greater [91:39] than or equal to, or less than or equal [91:42] to. So we can use them to check for [91:45] example numbers like is 10 greater than [91:49] 5. And Python returns the boolean true [91:52] because 10 is greater than five. What [91:54] about whether or not three is less than [91:56] one? That is false because three is [91:58] bigger than 1. If I were to check if 10 [92:01] is strictly greater than 10, I would get [92:04] false. But if I check if 10 is greater [92:07] than or equal to 10, I would get true [92:11] because 10 is not greater than 10, but [92:13] it is equal to 10. As we can see, a [92:16] comparison operator is always going to [92:18] evaluate to a boolean value of true or [92:21] false. So let's say I was building some [92:23] kind of age checker. My age is 20 and I [92:27] can have a variable called is adult and [92:30] I can drop a comparison result into this [92:32] variable. So I could say age is greater [92:36] than or equal to 18. Age is greater than [92:39] or equal to 18 is going to compare age [92:42] to 18. So is 20 greater than or equal to [92:47] 18? It is greater than. So this whole [92:50] statement will ultimately evaluate to [92:52] true. And you can see that if I were to [92:55] print is adult. Let's go ahead and check [92:58] this out. So you can see that the [93:00] statement with a comparison operator did [93:02] indeed evaluate to true and that is [93:05] what's ultimately saved to the is adult [93:07] variable. You can also drop a comparison [93:10] straight into an fstring. So I could say [93:12] I'm going to print the f string is old [93:15] enough and in my brackets I'm going to [93:18] put a comparison straight in. So Python [93:21] will compare age which is 20. See if [93:24] it's greater than or equal to 18 which [93:26] it is. So this statement will evaluate [93:28] to true which will show up in my fing. [93:31] Let's go ahead and look at this just to [93:33] make sure. And you can see there is old [93:36] enough true. Putting a check inside an [93:38] string like this is handy when you want [93:40] to label a result. The final thing I'd [93:42] like to show you is that these operators [93:44] do actually work on strings. So I'm [93:47] going to print is banana less than [93:51] cherry. And Python is going to compare [93:54] these alphabetically. [93:56] When I run it, you can see that is [93:58] banana less than cherry evaluates to [94:00] true. And that's because Python ends up [94:02] comparing them alphabetically and banana [94:05] comes before cherry in the alphabet. [94:07] This isn't something that you're going [94:09] to use very often, but I wanted to point [94:11] it out. I'll go ahead and comment all of [94:14] this out so I can give you your [94:15] challenge. Your challenge is going to be [94:17] a series of comparison checks. Apps [94:20] often compare numbers to decide what to [94:22] show a user. So using these values [94:25] below, I want you to use comparison [94:27] operators inside fstrings to print a [94:30] labeled result for each check. And this [94:33] is what your output should look like. [94:35] Has read message more than zero should [94:38] equal false. Old enough to rent a car [94:40] where the threshold is 25 or older [94:43] should equal true. Under the $50 free [94:46] shipping minimum should equal true. and [94:48] sold out, which is zero or fewer tickets [94:51] left, should equal false. So, you're [94:54] going to create fstrings and drop some [94:56] comparison operators inside so that this [94:59] ends up being your output. Go ahead and [95:01] get started on this challenge. [95:06] Okay, so here is my solution. I'm going [95:08] to make my fstrings right inside print [95:11] statements. And I'll start with my [95:13] string text has unread messages more [95:16] than zero. So this needs to check [95:19] whether unread messages is greater than [95:22] zero. Anything over zero in this case [95:25] means we have unread messages. But [95:27] because we have zero unread messages, [95:29] this is going to evaluate to false as it [95:32] should. For the second statement, I will [95:34] start my string. And I know this [95:36] comparison operator needs to evaluate [95:38] whether the entered age is 25 or older. [95:42] So the key here is that we want to [95:44] return true if the value is 25 or above [95:48] 25. So I'm going to want to say if age [95:51] is greater than or equal to 25. Let's [95:56] check what we have so far. Looks like we [95:58] have a little typo here. That's why we [96:01] check. So let's clear and try this [96:03] again. So the first statement evaluates [96:05] to false and the second one evaluates to [96:07] true, which is just what we need. The [96:10] third one is checking whether a value is [96:12] under the $50 free shipping minimum. So [96:15] for this one, we need to check if cart [96:17] total is less than 50. If cart total is [96:21] less than 50, no free shipping. The last [96:24] statement needs to check whether some [96:26] tickets are sold out or not. And tickets [96:29] are sold out if there are zero or fewer [96:32] tickets. [96:33] So, we'll say sold out zero or fewer [96:37] tickets left. And we'll want to check if [96:40] the value of tickets left is less than [96:43] or equal to zero. Let's check this out. [96:47] Looks like I have another typo here, but [96:49] luckily Python is very helpful. It says, [96:52] "Did you mean tickets left?" And as you [96:55] can see, I wrote ticket left. So, yes, [96:57] thank you, Python. Let's try this one [96:59] more time. All right, we're looking for [97:01] our statements to evaluate to false, [97:03] true, true, and false, which they do. [97:06] So, we know that we have checked our [97:08] comparisons correctly. Really amazing [97:10] work, and I'll see you in the next one. [97:19] Nearly every Python program is going to [97:21] need to make decisions. For example, in [97:24] the word scramble game, we're going to [97:25] want to run certain code if the player [97:27] guesses the answer correctly and run [97:30] different code if they guess the answer [97:32] incorrectly. To make decisions in a [97:34] Python program, we use if else blocks. [97:37] An if statement is going to check a [97:39] condition. So, let's say we have a noise [97:41] meter app and we want to check whether a [97:43] room is too loud measured in decb. So, [97:46] I'm going to create a decibb variable [97:48] and I'll set it to 90. Now I'll make an [97:51] if else block that checks the value of [97:54] decb and does something depending on its [97:56] value. So for example I can say if decb [98:00] is greater than 89 I'm going to print [98:04] the message warning loud environment. An [98:07] if statement evaluates an expression and [98:10] in this case it's evaluating whether or [98:12] not decb is greater than 89. So this [98:16] statement will ultimately evaluate to [98:19] the boolean true. So it's the same as [98:21] saying if it's true that decibb is [98:24] greater than or equal to 89 print this [98:26] warning. So if we were to run this you [98:30] can see that the warning gets printed [98:31] because the condition that we're [98:33] checking for is whether or not decb is [98:35] greater than 89 and decb is 90. So the [98:39] statement evaluates to true. The [98:41] expression in this if statement could be [98:43] checking any number of things like [98:45] whether a player guessed correctly [98:46] whether a number falls in a certain [98:48] range or whether two strings are equal. [98:51] If this statement were to evaluate to [98:54] false, so let's say that the decibel [98:56] level was 20. We'll run this again and [98:59] you'll see that nothing happens. Nothing [99:01] is printed. Nothing will happen unless I [99:03] include an else block that tells Python [99:05] what to do if the if statement isn't [99:07] true. So under the if block I can say [99:10] else will print a different message. Now [99:13] when we check this out this statement [99:15] has evaluated to false. So it runs the [99:18] code in the else block. Keep in mind [99:20] that the else block is optional and [99:23] sometimes you'll want to do something [99:24] when the condition is true and otherwise [99:27] do nothing at all. I also want to take a [99:29] second here to talk about indentation [99:32] because it's a very important thing in [99:34] Python that we haven't encountered yet. [99:36] Python requires these print statements [99:39] to be indented by four spaces and that's [99:42] how Python knows that this print [99:44] statement is inside of the if block. The [99:47] Scrimpa editor and most text editors [99:49] will do this for you. But this is still [99:52] a really important thing to keep in mind [99:54] because indentation errors are very [99:56] common when you are writing Python. In a [99:58] programming language like JavaScript, [100:01] your if statement might look something [100:03] like this where you would use curly [100:05] brackets to indicate what is inside of [100:08] the if statement. So then here you would [100:11] console.log something. But Python [100:14] depends on that indentation to know what [100:16] code is in the if block and what code is [100:19] in the else block. So again, the Scribba [100:21] editor will mostly do that for you, but [100:24] it's something to be aware of. All that [100:26] being said, now it's your turn. And here [100:29] is your challenge. For this challenge, [100:31] you're going to build a results screen [100:33] for an online course quiz where a [100:36] student needs at least 60 points to [100:38] pass. So, first you'll use an input [100:41] prompt to ask the student for their [100:43] score and make sure to convert it to an [100:45] int. If their score is 60 or higher, [100:48] print a message telling them that they [100:50] passed. Otherwise, print a nice message [100:53] telling them that they haven't passed [100:55] this time. Go ahead and get started on [100:58] the challenge. [101:00] All right, I hope that went really well. [101:02] I am going to get started by making my [101:05] input prompt. And for that, I will just [101:07] say, enter your quiz score. I'm going to [101:10] make sure to convert whatever I get back [101:13] into an integer. And then if the score I [101:16] get back is greater than or equal to 60, [101:20] I'm going to print a message that says, [101:22] "Congratulations, you passed. Nice [101:25] work." Else, I'm going to print, "You [101:28] didn't pass this time. Please try [101:31] again." Let's run this and make sure it [101:33] works. I'm going to enter a quiz score [101:36] of 60. Congratulations, I passed. All [101:39] right, let's try entering a score less [101:41] than 60. We'll say 23. We didn't pass [101:45] this time. Please try again. [101:55] An if else block gives you two paths. If [101:58] a condition is true, run this code. And [102:01] if it's not true, run this other code. [102:03] But often you'll have multiple [102:05] conditions you need to check and run [102:07] code for. So there's another option [102:09] called L if that lets you chain as many [102:12] conditions as you need. If you were to [102:14] write a bunch of if statements, for [102:17] example, let's say that I have a test [102:19] score of 95 and I need to check if the [102:22] test score is greater than or equal to [102:26] 90. And if so, I'll print that the [102:28] student got an A. But I also want to [102:31] check if the test score is greater than [102:35] or equal to 80 because in that case, [102:38] they score a B. The problem with two if [102:41] statements is that both of these lines [102:44] of code are going to run. So both if [102:46] blocks will run because both are true. A [102:50] student can't get both an A grade and a [102:52] B-grade, but we want to be able to check [102:54] their scores to assign a grade of A, B, [102:58] C, D, E, F, or any number of other [103:01] options. So there's an option called L [103:04] if that will stop at the first match. So [103:07] it looks at the score which is 95 which [103:10] is greater than or equal to 90. So it [103:12] prints a and then the code stops. LF [103:15] basically says only check this condition [103:17] if the previous condition wasn't true. [103:20] So let's change this to a score of 89 [103:23] and run it again. Now it's going to look [103:26] at this first condition. Is the test [103:28] score greater than or equal to 90? No. [103:31] So it's going to test is the test score [103:33] greater or equal to 80? Yes. So it [103:36] prints B. Now let me keep chaining down [103:39] through the other grades. If test score [103:41] is greater than or equal to 70, we'll [103:45] print a grade of C. Or if the test score [103:48] is greater than or equal to 60, we'll [103:51] print a D. And then finally, if none of [103:54] those conditions are met, we will print [103:57] an F. So let's say we have a score of [104:00] 85. Python is going to skip the first [104:03] condition. It will then evaluate if 85 [104:07] is greater than or equal to 80, which it [104:09] is. So, it will print B and then stop. [104:12] It won't continue on down the rest of [104:15] the L-s. The else here serves as a catch [104:18] all. So, it's only going to run if none [104:20] of the other conditions are true. So, if [104:23] we have a score of 59, for example, [104:27] that's going to print an F. So, keep in [104:29] mind that order matters here. I'm going [104:32] to change this back to 85. And let's [104:35] switch these two conditions. So I'm [104:37] going to check first if the score is [104:39] greater than or equal to 80. Let's also [104:41] switch around our print statements and [104:44] run this and see what happens. If we [104:46] change the score to something like 95, [104:49] which is an obvious A. Let's run and see [104:51] what happens. You'll see that B actually [104:54] prints because this condition is [104:56] technically being met. 95 is greater [104:59] than or equal to 80. and it assigns B [105:02] because it says yes, this is true and it [105:04] stops there. It never actually makes it [105:06] to this condition. So, just keep in mind [105:09] that the order matters. I'll change this [105:10] back so it's in the right order and [105:12] we'll go ahead and comment this out so [105:14] that you can start your challenge. [105:16] Here's your challenge. You're building a [105:18] feature for a coffee shop that has [105:19] spotty Wi-Fi. The feature should give [105:21] customers a discount based on how many [105:24] signal bars they're getting. And for the [105:26] purposes of the exercise, we're going to [105:27] say the signal is currently two out of [105:29] five bars. So, you're going to write an [105:32] if l if else chain that prints a message [105:35] informing the customer of their [105:37] discount. If there are zero bars, you'll [105:39] print a message giving them 50% off and [105:41] say, "Sorry about the Wi-Fi." For one or [105:43] two bars, 25% off. For three or four [105:46] bars, 10% off. And if there are five [105:49] bars, you'll inform the customer that we [105:52] have full bars today and so there is no [105:54] discount. Go ahead and give this a try. [105:59] I'm going to start off with if the [106:01] signal equals zero. If there are no [106:03] bars, we're going to print 50% off. [106:07] Sorry about the Wi-Fi. Else if the [106:10] signal is less than or equal to two [106:13] bars. So, if there are one or two bars, [106:16] we'll print 25% off. Else if the signal [106:20] is less than or equal to four, we'll [106:24] print 10% off. And finally, if none of [106:27] these conditions are true, that means [106:29] that we have full bars and we can print [106:32] full bars, no discount today. Let's test [106:35] this out. We have a signal of two. So, [106:38] we should get a 25% discount. Let me go [106:42] ahead and save first and we'll try this [106:44] again. Here we go. 25% off. Let's try [106:48] changing the signal to five. Full bars, [106:51] no discount today. Let's change the [106:53] signal to zero. 50% off. And for a final [106:57] check, let's do a signal of three. This [107:00] is less than or equal to four. So, we [107:02] should end up with a 10% discount. And [107:05] there you go. Fantastic work. [107:13] You've already used a couple of string [107:15] methods like strip, which you've used to [107:17] strip a percent sign off a value. And [107:20] then there was also join, which turns a [107:22] list back into a string. So string [107:24] methods are built-in tools that [107:26] transform or work with text. You call [107:29] them with dot notation. So the string [107:32] first, then a dot, then the method name. [107:35] So let's learn about a few more of them, [107:37] including some more ways that you can [107:39] use strip. Let's say I'm building a [107:41] recipe search app. Users will type in [107:43] what they're craving, but I can't always [107:46] control how they type it. Someone might [107:48] search for pasta carbonara in all caps [107:52] or add extra spaces around their query. [107:56] String methods will let you clean up [107:58] that input so that it's consistent no [108:00] matter what the user types. So for [108:02] example, let's say I have a recipe named [108:05] chicken tikka masala. If I wanted to [108:09] display this in a bold way, I can go [108:11] ahead and print this. And I am going to [108:13] call the string method upper on the [108:16] value of recipe. And you can see what [108:18] that does. It returns the string in all [108:21] caps. So this could come in handy for [108:23] displaying a title or a header. One [108:25] thing to keep in mind here is that [108:27] string methods don't change the original [108:30] string. They return a new one. So if I [108:33] were to print recipe again, you can see [108:35] that here when I call upper on recipe, [108:38] it returns an uppercase version of the [108:41] string, but that the regular string is [108:43] still intact. So if I wanted to save [108:45] this uppercase string and do something [108:47] with it, I'd need to save it to a [108:50] variable. And here you can see I have my [108:52] original string and then the uppercase [108:54] version of the string which I have saved [108:56] to header. So the lower string method [108:59] does the opposite of upper. So let's say [109:02] I have a search query in my recipe app [109:05] and the user has searched for hasta [109:08] carbonara. I'll print the search and I [109:10] will call the lower method on it and [109:12] that returns an all lowercase version of [109:14] the string. This is great for [109:16] normalizing a search query before [109:18] matching it against results. There's [109:21] also the string method title which [109:23] capitalizes the first letter of every [109:26] word. So, this can be good for cleaning [109:28] up names. Let's say I have a chef named [109:31] Grace Smith, and I want her first and [109:34] last name to be capitalized. So, I can [109:36] call the title method on the string, and [109:40] that will capitalize her first and last [109:42] name. You've used strip before to remove [109:45] a specific character, like removing a [109:47] percent sign from a percentage like [109:50] this. So, if we print this, it's going [109:53] to return the string with the percent [109:55] sign removed. But when you call strip [109:57] with no argument at all, it removes [109:59] white space from the beginning and end [110:01] of a string instead. So let's say I have [110:04] a recipe or a search query where the [110:07] user has included a bunch of extra [110:10] spaces. I can call strip on the string [110:14] without passing anything into it. You'll [110:17] see it returns a string with all of the [110:19] extra space removed. You can also chain [110:22] methods together, which means calling [110:24] one right after the other on the same [110:26] line. So let's say a search query comes [110:28] into my recipe app and it's a big mess. [110:31] We'll say raw for raw data. We'll say [110:33] that there is a bunch of spaces and then [110:37] you know they type something like this. [110:40] So we'll make a variable to save the [110:42] cleaned up version which instead of [110:44] calling cleaned up, let's just pretend [110:46] that this is a search query that we're [110:47] cleaning up. So I can take raw which is [110:50] this string right here and I can call [110:53] strip on it to strip out all of the [110:55] unnecessary space and then I can use [110:57] another dot and connect this directly as [111:01] a chain and I can call lower. So this [111:03] will both strip out all of the extra [111:05] space and convert this to lowercase. So [111:08] let's print query and see the result. [111:11] All the white space is gone and it's [111:14] been converted to completely lowercase. [111:16] And that is how you can chain methods [111:18] together. Now, let me give you your [111:20] challenge. Your challenge is to do some [111:22] data cleanup. You're building a signup [111:24] form that tidies up whatever the user [111:27] types in. So, each of these values below [111:29] has come in a little bit messy. Your [111:32] task is to figure out which string [111:34] method or multiple string methods will [111:36] help get the data to its cleanest [111:38] version. And then you're going to print [111:40] the result. So, some of these only need [111:42] one method to clean it up, and some [111:44] might need two. So, here we have the raw [111:47] data that is saved a promo code, and [111:50] this is what the cleaned up version [111:51] needs to look like. And same with the [111:54] rest of these on the list. Here's the [111:56] raw data, and here's what you need to [111:58] end up with. So, go ahead and get [112:00] started on this challenge. Give it a [112:02] try. [112:05] All right, I hope that went really [112:06] smoothly for you. Let's get started. So [112:08] for this first one, I can see that it [112:10] just needs to be in all caps. So I'm [112:13] going to print the result of calling [112:17] upper on promo code. Let's give this a [112:20] quick check. And there we go. Spring 25 [112:22] in all caps. Next, I can see that the [112:25] first and last name needs to be [112:27] capitalized. So I'm going to use the [112:30] title method on full name. I am going to [112:33] call title. Let's give this one a quick [112:36] check. There we go. That's now in title [112:38] case. For the next one, I can tell I [112:40] have some extra space that I'm going to [112:42] need to strip out. And I can see that [112:44] the finished result needs to be in all [112:46] lowercase because it's an email. To [112:49] email, I'm going to first strip out the [112:52] white space. And then I am going to [112:54] chain the lower method, which should get [112:57] rid of the extra space and convert [113:00] everything to lowercase. And it does. [113:02] Finally, for the display name, I can see [113:05] that I need title case and to strip out [113:08] some extra space. So to display name, I [113:12] will first call strip and then title. [113:15] Let's take a final look. And everything [113:18] is looking how it should. [113:19] Congratulations, you've cleaned some [113:21] data. Cleaning data is a very important [113:23] and very often used skill for a [113:26] programmer. [113:33] You've done great work so far. I hope [113:35] you're feeling good. We now have the [113:38] skills to add some interactivity to the [113:40] word scrambled game. At this stage, we [113:42] want to be able to prompt the player to [113:44] either guess or skip the scrambled word. [113:47] Then, we want our game to respond based [113:49] on whether the player is right, wrong, [113:51] or chose to skip. So, here's what you'll [113:53] need to do. You'll want to add [113:55] interactivity so a player can either A [113:58] skip the word and get the correct answer [114:00] or B guess the word and find out if [114:03] they're correct. So your first step will [114:05] be to prompt the player for input and [114:07] give them two options. The option to [114:09] type a guess or to type skip to skip the [114:12] word. As a second step, I want you to [114:14] use string methods to clean the player's [114:16] guess and do a minor improvement on the [114:19] display. We want to be as forgiving as [114:20] we can with the player's guess. And that [114:23] means we need to clean the player's [114:25] guess so that the capitalization and [114:27] whites space don't matter when comparing [114:29] the user's input to the correct answer. [114:32] So in other words, if the correct answer [114:35] is bandwidth, we want the player to be [114:39] able to type bandwidth or bandwidth or [114:43] even, you know, something like this. [114:46] Basically, as long as they've entered [114:47] the right word, we want to accept it as [114:50] a correct answer. The second part of [114:52] this stage, I want you to make a minor [114:53] improvement, which is display the [114:55] scrambled word in all caps so it stands [114:58] out on screen. The third part is to use [115:01] if l if else to handle these three [115:03] cases. So if the player types skip, we [115:07] want to print the message skipped the [115:09] word was whatever the correct word was. [115:12] If the player typed a correct guess, we [115:14] want to tell them your guess was [115:15] correct. And finally, if the player's [115:17] guess is incorrect, we want to give them [115:19] a nice little message that says, "Sorry, [115:21] this was actually the word." So, go [115:24] ahead and work through this step by [115:26] step, I know you can do it. [115:31] Okay, let's do the first step, which is [115:33] to prompt the player with two options to [115:35] either type a guess or type skip. So, to [115:38] a variable called guess, I'm going to [115:41] have an input to prompt the user. And [115:44] I'll keep it simple. I'll say guess the [115:46] word or type skip to skip. Now I'll do [115:50] part one of the second step which is [115:53] cleaning the player's guess. So the [115:55] input function is going to prompt the [115:57] player and when I get that guess back I [116:00] want to go ahead and strip it for any [116:03] white space on either end of the guess [116:05] and I'm going to make it all lowercase [116:07] and that will effectively make the guess [116:10] case insensitive. The second part of [116:12] this stage is to display the scrambled [116:14] word in all caps so it stands out on [116:16] screen. So I'm going to come here to [116:17] where I am joining my scrambled word and [116:20] I'm going to make sure that it's in all [116:22] uppercase. Now for the if l if else [116:26] block. So first I'm going to check if [116:29] the user has typed skip. So if guess [116:32] equals skip and I'll make sure it's a [116:34] double equals. I want to print an f [116:36] string that says skip and the word. And [116:39] instead of apple here, I've got the word [116:41] that was randomly chosen from the list [116:44] up here. So in curly brackets, I'll go [116:47] ahead and display whatever word was [116:49] chosen. Let's check our work so far. So [116:52] we have a couple of small little [116:54] problems here. For one, we don't want to [116:56] print the correct answer. So I'm going [116:57] to go ahead and get rid of this print [116:59] statement. And then we've got our [117:01] capitalized scrambled words. So that's [117:03] great. Looks like we need to add a colon [117:06] and a little bit of space here so that [117:08] this prompt looks nicer. I'll do that [117:10] now. I'm going to go ahead and control C [117:12] to get out of this and we'll clear and [117:14] run it again. And that looks a lot [117:16] better. Let's see what happens when we [117:18] type skip. Great. So, we've got our [117:21] skipped message which is displaying the [117:23] correct answer. Let's try it one more [117:24] time just for fun. Looks like we got [117:27] apple again. Let's see if we can get [117:29] something besides apple. Okay, here's [117:31] banana. we skip the word was banana. So [117:35] fantastic. This is all working great so [117:37] far. So next, let's check for a correct [117:40] guess. So I'm going to say else if guess [117:43] equals word. So we input the player for [117:45] a guess. And whatever they input, we're [117:48] going to compare to what we know is the [117:50] correct answer. If these two are equal, [117:52] we'll know it's correct. And we can [117:54] print a message correct. I'm going to go [117:57] ahead and add a little emoji here. This [117:59] is totally optional. and make sure that [118:01] it has adequate space. Let's go ahead [118:03] and make sure a correct guess is [118:05] working. So, we got banana. Let's type [118:08] banana and correct. So, that's [118:10] fantastic. Finally, we want to handle [118:12] the case of an incorrect guess. So, here [118:15] we can go ahead and use an else because [118:18] unless the player types skip or unless [118:20] the player types the correct word, we [118:23] know that their guess is incorrect. So, [118:25] we can just let this fall to the else [118:27] block, whatever doesn't match these two [118:29] conditions. and we'll go ahead and print [118:32] this message, but we're going to drop [118:35] word in here like we did for skip. [118:39] So now we're testing an incorrect [118:41] answer. So the scrambled word is [118:43] obviously apple. I'm going to type [118:45] orange. And we get the message, sorry, [118:47] the word was word looks like we have a [118:49] little mistake here. So let's see what [118:52] is happening. What's happening is we [118:54] forgot the f for fstring. So let's try [118:57] this one more time. So the scrambled [118:59] word is apple. Let's once again type [119:01] orange. And now we get no. Sorry, the [119:03] word was apple. I'm going to make sure [119:05] that there is a period at the end of [119:08] this sentence. And we can go ahead and [119:10] call this done. Fantastic work. I do [119:14] want to note that you can check for skip [119:16] or check the correct answer in any order [119:18] here. So it's totally fine if you did it [119:21] the opposite way. We're on our way to a [119:24] fun little working game here. So let's [119:26] keep at it. [119:32] This scrim is going to cover a Python [119:34] data type called tpples. For the record, [119:37] there's no consensus on whether it's [119:39] pronounced tupil or tpple. I say tpple, [119:42] but either is fine. Let's say I'm [119:45] building a design tool and I need to [119:46] store a color. On the web, colors are [119:49] often written as a hexadimal code like a [119:51] hash followed by a series of numbers and [119:54] letters. But under the hood, it's really [119:56] three numbers. The amount of red, green, [119:58] and blue in a color. For example, the [120:01] RGB values of the color steel, blue are [120:04] 70, 130, and 180. So, this is the syntax [120:09] of a tpple. It looks a lot like a list [120:11] only with parentheses instead of square [120:14] brackets. And a tpple is perfect for [120:16] storing values that always belong [120:18] together, like the red, green, and blue [120:20] values that make up steel blue. You can [120:22] get the values out by index. the same as [120:25] you would a list. So I'm going to print [120:27] steel blue at index zero and that will [120:30] give me the value in the tpple at index [120:32] zero. The big difference between tpples [120:34] and a list are that tpples are [120:36] immutable. Once you've created one, you [120:38] can't change the values inside. So, for [120:41] example, if I were to try to change the [120:44] red value to 300, I'll grab steel blue [120:47] at the index of zero, which is the red [120:49] value, and I'll try to reassign the [120:52] variable to 300. Then I'll attempt to [120:54] print it again, and I get a type error. [120:57] Tupppel does not support item [120:59] assignment. So, keep in mind that there [121:01] is a difference between changing the [121:04] tpple itself right here. So, I could [121:06] change this to 300 right here if I [121:08] wanted. That would be no problem. But [121:10] when I try to reassign it a different [121:11] value, that's where the trouble comes [121:13] in. And that's where Python will say, [121:14] "No, this is the value. You can't change [121:17] it." This is Python's way of enforcing [121:19] the grouping. These three numbers [121:21] describe one specific color. So, it [121:23] makes sense that they stay locked [121:25] together. And that's why you might [121:26] choose to use a tpple over another data [121:29] type like a list. With tpples, there's [121:32] also a nice way to pull out values [121:34] that's called unpacking. Instead of [121:36] using indexes, I can unpack the tpple in [121:40] one line with a series of variables [121:43] separated by commas. Because there are [121:45] three values in the tpple, Python will [121:48] know that red is going to equal 70, [121:50] green is going to equal 130, and blue is [121:53] going to equal 180. So the names on the [121:57] left that we're assigning to these [121:58] values just need to match the number of [122:01] items in the tpple. I'll print out the [122:03] three variables so you can see how [122:04] they're assigned. You can see that red [122:06] is now 70, green is 130, and blue is [122:10] 180. So this is a quick way to assign [122:12] every value in a tpple to a variable. In [122:15] practice, you'd often store a whole list [122:17] of tpples into a color palette list. I'm [122:20] going to save three tpples representing [122:22] the RGB values of three colors. These [122:25] tpples are list items. So to access the [122:28] first item in the list, for example, I [122:30] can access it by index. So I'm going to [122:33] print color palette at the zero index [122:37] and that'll give me the first tuple in [122:38] my list. To unpack the first palette in [122:41] the list, I can unpack exactly how I did [122:44] up here. So I'm going to unpack the red, [122:47] green, and blue values, except this time [122:50] I'm accessing the list and then I'm [122:52] accessing the item in the zero index of [122:56] the list. And then I am unpacking each [122:58] of these values into a variable. To show [123:01] you, I'm going to print a string that [123:04] prints out these three values. [123:07] If I wanted to print out the values from [123:09] the second item in the list, I could do [123:10] the same thing. Only this time, I'm [123:12] going to unpack the tupil at index one [123:15] of the list. So that'll be this one. Go [123:18] ahead and copy it and paste this line. [123:20] And that prints the values of the second [123:22] tpple in the list. Notice that I am [123:25] repeating myself using red, green, and [123:28] blue and copying the same pair of lines [123:30] for each color. This works, but if we [123:33] wanted to unpack a lot of tpples, it [123:34] would get tedious pretty fast. Python [123:36] has a cleaner way to handle doing [123:38] something to every item in a list, and [123:40] we'll get to that later on in the [123:41] course. But for now, I have a little [123:43] challenge for you. Your challenge is to [123:45] build an inventory display feature for a [123:48] small office supply store. For step one, [123:51] you'll unpack the item and the quantity [123:54] for each entry in this list of tpples. [123:57] In step two, I want you to print each [123:58] item and its quantity in this format. [124:01] So, the string will have the item and [124:03] then the quantity in stock. Go ahead and [124:06] get started on the challenge. [124:09] Hopefully, that went really well for [124:11] you. Let me show you my solution. I'm [124:13] going to start by unpacking the item and [124:15] the quantity. And I'm going to grab the [124:17] tpple that is at index zero in the list. [124:20] So inventory index zero. And I'll print [124:23] my f string. And looking at the format [124:26] here, it's going to be item colon [124:29] quantity in stock. Let's check this [124:33] before we move on. Tiny little typo [124:35] here. Let's try this again. All right. [124:37] Notebooks 42 in stock. Perfect. Going to [124:41] come up here and comment this out really [124:43] quick. Then I'm going to pull out the [124:45] item at index one. And I'm going to go [124:47] ahead and copy and paste this print [124:49] statement. Let's give this a look. There [124:52] we go. Pens 130 in stock. And finally, I [124:55] will get the item at index 2 and print [124:58] out my string. Looks good. That is how [125:00] you unpack a tpple in a list of tpples. [125:10] Currently in our jargon jumble game, the [125:13] players see a jumble of letters that [125:15] could be really tough to guess without [125:16] any hints. So, let's give them the [125:18] option to ask for a hint. I've replaced [125:21] the small list we've been working with [125:23] with a list of tpples that pairs a word [125:26] and a hint. Notice that I've also [125:28] changed the variable the list of tpples [125:30] is saved to to wordbank. And wordbank is [125:33] also what I'm now passing into random [125:35] choice. We don't want to give the hint [125:37] away automatically. So, we'll let the [125:39] player type hint to ask for a hint. And [125:42] wiring that up is going to be your job [125:44] in this challenge. So, the word bank [125:47] below pairs each word with hint. Wire up [125:49] a hint option so a stuck player can [125:52] reveal the clue and then keep guessing. [125:55] Your first step will be to pick a random [125:56] pair from word bank and unpack it into a [126:00] word and a hint. Then, you'll want to [126:02] update the guess prompt so that the [126:03] player knows hint is an option. If the [126:06] player types hint, you'll want to show [126:07] them the hint, then ask them to guess [126:10] again. So, here are a couple of hints [126:12] for you. Getting them to ask again will [126:14] require adding a second input prompt. [126:16] And your second hint is that you'll want [126:18] to check if the user has typed hint in a [126:22] separate if block above this skip, [126:24] correct, wrong block. And that is [126:27] because skip, correct, and wrong all end [126:30] the turn, but a hint doesn't. So, [126:32] keeping it separate lets the game show [126:35] the hint and then still be able to check [126:37] the guess the player types next. And [126:40] then finally, a little optional [126:41] challenge here. Add a couple of your own [126:44] word and hint pairs to the word bank. [126:47] This is a bigger challenge, but I know [126:49] you can do it. Take it one step at a [126:51] time, and I'm sure that you'll do great. [126:53] Go ahead and get started. [126:57] All right, step one. Pick a random pair [127:00] from word bank and unpack it into word [127:02] and hint. So here where I am choosing a [127:05] random word from the word bank, I'm [127:07] going to unpack into word and hint. And [127:11] the rest of it can stay exactly the [127:13] same. Let's go ahead and check this by [127:15] printing word and hint. The I'm going to [127:17] go ahead and comment out the rest of it [127:19] for now. So as you can see, we're [127:21] successfully printing a meeting with its [127:24] hint. So now I'll get rid of this print [127:27] statement and bring our code back so [127:29] that we can move on to step two. Step [127:31] two is to update the guest prompt so [127:33] that the player knows hint is now an [127:35] option. Okay, so here's the guest prompt [127:37] and I'm going to go ahead and change the [127:39] prompt a little bit. And I'll say or [127:42] type hints skip. Let's give this a [127:46] little bit of space and that should be [127:48] good. Now moving on to part three. We [127:51] want to check if the player types hint. [127:53] And if they type hint, we want to show [127:55] them the hint and then ask them to guess [127:58] again. So above my first if else block, [128:01] I'm going to do a new if statement that [128:04] says if guess equals hint. In other [128:08] words, if they've typed hint, I want to [128:10] go ahead and print the hint. So as part [128:12] of an fing, we'll say hint. And then [128:15] we'll print the hint, which remember [128:16] we're getting from unpacking the random [128:19] choice from our word bank on this line. [128:22] Then after we've printed the hint, we [128:24] want to ask the player to guess again so [128:27] that we don't interrupt the flow of the [128:29] game. So I'm going to create another [128:32] guess prompt in which I'll ask for the [128:34] guess again or remind them that they can [128:36] still skip. And I'll make sure to clean [128:39] and strip this input as I'm doing up [128:42] here. I think we've done it. Let's go [128:43] ahead and test this out. So, we have [128:46] this scrambled word. Let's ask for a [128:47] hint. The hint is I spent 4 hours trying [128:50] to blank my code. Turns out I was [128:52] missing a comma. So, I think the word [128:55] here is debug. Notice that this is the [128:58] second prompt that we provided in this [129:01] guess block. [129:07] So now when we guess the right answer, [129:10] it's going to move on to this guess [129:12] block. It's going to determine that the [129:14] guess of debug is equal to the word [129:17] debug and give us the message correct. [129:20] So I think a little bit of spacing would [129:22] be nice here just for a final touch. So [129:25] I'm going to add a blank print statement [129:28] here. And I'm also going to add one here [129:31] just to make a little bit of room, make [129:34] things a little bit more readable. So [129:36] let me go ahead and ask for a hint. I [129:38] spent four hours trying to blank my [129:40] code. All right, looks like we've got [129:42] debug again and we are correct. I'm [129:45] noticing that I have a missing quote [129:46] here. So, I'll also fix that and this is [129:50] looking good. Great work. [129:58] Right now in our word scramble game, you [130:00] can only play one word at a time. To get [130:02] a new word, you'd have to keep rerunning [130:04] the program over and over again. So, we [130:06] want the player to be able to play [130:08] multiple rounds. And to do that, we're [130:10] going to need a while loop. So, let me [130:12] show you a while loop that counts to [130:14] five. I'm going to start by initializing [130:16] a variable called count, which I'll set [130:19] to one. Initializing a variable means [130:22] setting its starting point before the [130:24] loop runs. So, for the loop itself, I'm [130:26] going to say while count is less than or [130:30] equal to 5, I want to print the value of [130:33] count. But here's the important part. [130:35] Every time this loop runs, I am going to [130:38] increase count by one. And I can do that [130:41] by reassigning the variable count to the [130:44] value of count + one. So this loop [130:46] basically says as long as it's true that [130:49] the value of count is less than or equal [130:52] to 5, I'll keep running the code in this [130:55] block. And this is another instance [130:57] where indentation is really important. [131:00] This indentation is what tells Python [131:03] that this is the code inside the while [131:05] loop. Let's walk through this so that [131:07] hopefully it'll be super clear. On the [131:10] first pass, count equals 1. Is it true [131:14] that count is less than or equal to 5? [131:17] Yes. So the code in this block will run. [131:19] So the loop will print the value of [131:21] count and then it will increment count [131:24] by one which would make count two. The [131:27] loop will then check again is count less [131:30] than or equal to five. Yes, because [131:32] count is two. So we'll print count which [131:35] is two and then we'll increment count by [131:37] 1. So count is now three. Then once [131:40] again is count less than or equal to 5? [131:43] Yes, because three is less than or equal [131:45] to 5. So it'll print the count and then [131:48] increment the count by 1. So now count [131:51] is four. And so on and so on until we [131:54] reach count six. Then the while loop [131:57] will ask is 6 less than or equal to 5 [132:00] and that is false. So the loop will end. [132:03] Incrementing a variable like this is a [132:06] very common thing to do. So Python has a [132:08] shortcut for it which is that we can say [132:11] count plus equals 1. This is a shorthand [132:16] way to say increase the count by one. [132:18] I'm going to initialize count back to [132:20] one and actually run this so you can see [132:22] it in action. It prints the value of [132:24] count until the condition count is less [132:27] than or equal to 5 is no longer true and [132:30] then it exits and the result is that it [132:32] prints out 1 through 5. Something that's [132:34] really common when writing loops is the [132:37] accidental infinite loop. So let's say I [132:39] write a loop but I forget to increment [132:42] count every time. What's going to happen [132:44] is that the loop will say is count less [132:47] than or equal to 5? Yes, count is one. [132:50] So, it's going to print count and then [132:51] ask again, is count less than or equal [132:54] to five? Yes. And it'll just keep going [132:56] on and on like that forever. And it can [132:58] eventually crash your browser. I'm not [133:01] going to demonstrate because I don't [133:02] want to mess up the terminal or this [133:04] recording. But just know that you can [133:06] usually stop an infinite loop by using [133:08] the keyboard shortcuttrl C. And that [133:11] kind of forces it to stop and break out [133:12] of the program. I'm going to go ahead [133:14] and add my count back. something inside [133:16] the loop must eventually make this [133:18] condition false so that it will stop. [133:21] There's also a way to exit a loop [133:23] intentionally from inside and that is [133:25] with a break statement. So I can say [133:27] something like if count equals 3 then [133:31] break. The break statement will stop the [133:33] loop immediately no matter what the [133:35] condition says. So let's run this and [133:37] you'll see that when it gets to three [133:39] it'll automatically break out of the [133:41] loop. So, as you can see, it prints one [133:43] and two and then it stops. We're going [133:45] to use break in our word scramble game [133:47] to let the player quit midame. So, this [133:50] while loop pattern is something that [133:51] you'll end up using a lot. Initializing [133:53] a variable before the loop, using that [133:55] variable in a condition, and updating it [133:58] inside the loop. Let me show you one [134:00] more example. Let's say that I'm [134:01] tracking a runner through a race. I'm [134:04] going to set the total number of laps [134:06] and track which lap they're on. So, I'm [134:09] going to set total laps to five. And I'm [134:11] going to initialize a lap to one. I've [134:14] put total laps in all caps because [134:16] that's a Python convention for a [134:18] constant. A constant is a value you set [134:20] once and that doesn't change anywhere in [134:23] your application. So this is in contrast [134:25] to the lap variable, for example, where [134:28] we're going to keep incrementing it. So [134:30] I'm going to say while lap is less than [134:32] or equal to total laps, I'm going to [134:36] print which lap we're on. And each time [134:38] the loop runs, I'm going to increment [134:41] lap by one. Just for fun, so we can see [134:44] something a little different. I'm [134:45] actually going to make this 10 laps. [134:47] Let's run. And you'll see that it counts [134:49] the laps until we get to 10 and then it [134:51] breaks out of the loop. We're going to [134:53] do something really similar with the [134:55] word scramble game to make sure that the [134:57] player can play multiple rounds of words [134:59] before the game ends. So, here's a [135:01] chance to practice this pattern. Your [135:03] challenge is to build an airport app [135:04] that prints a boarding pass for each [135:06] passenger on a group booking. So, you're [135:09] going to want to write a while loop that [135:11] prints one line per passenger. And that [135:14] should look like this. Printing boarding [135:16] pass 1 through 5, printing boarding pass [135:18] 2 through 5, and so on till you get to [135:21] the last passenger. So, you have a total [135:24] of five passengers, and you want to loop [135:26] through all five passengers starting [135:28] with passenger number one. Go ahead and [135:31] give this a try. [135:34] Okay, so I know I want to go through [135:36] passengers 1 through 5. So I'm going to [135:38] write a while loop that says while [135:41] passenger num is less than or equal the [135:44] total number of passengers. When I write [135:47] a while loop, I like to start with the [135:49] condition that is going to eventually [135:51] stop the while loop so that I can make [135:53] sure and prevent an infinite loop. So [135:55] I'm actually going to start by [135:57] incrementing the passenger number. So [135:59] every time this loop runs, we want to [136:01] increment it by one. So I know that no [136:04] matter what I do, this number is going [136:06] to increase by one so that this [136:08] condition is eventually false so that [136:10] the loop stops. All right. Now that I've [136:12] done that, I can print my message. So [136:15] I'm going to say printing boarding pass [136:18] and I want to print boarding passes 1 [136:20] through 5. So I want to print the value [136:24] of passenger num each time the loop runs [136:28] along with the total number of [136:30] passengers. All right, that should be [136:32] good. Let's give it a look. And we have [136:34] successfully printed our boarding [136:36] passes. Super awesome work. Let's [136:39] continue on. [136:46] You've just had a chance to work with [136:48] the counter loop pattern, which uses a [136:50] constant to determine how long a loop [136:52] should run and a counter that climbs [136:55] toward that target number. Let's use [136:57] this pattern to give the word scramble [136:59] game multiple rounds. So, here is your [137:01] challenge. Right now, the game ends [137:03] after a single word. Add the ability to [137:06] play multiple rounds and quit out of the [137:08] game at any point. Step one is to wrap [137:10] the game code in a loop that runs for [137:12] five rounds. Step two, display the round [137:15] number at the beginning of each round. [137:18] And step three, give the player a way to [137:20] quit early by typing quit. And here's a [137:23] hint. You'll want to break out of the [137:24] loop when they type quit. You've done [137:27] some really fantastic work so far, and I [137:29] know you can do it. Go ahead and get [137:30] started on the challenge. [137:35] Let me show you how I did it. First, [137:37] I'll set up the variables for my while [137:39] loop. So, I'll create a constant called [137:40] rounds, which I'll set to five, and my [137:43] counter variable, which I'll set to [137:45] round number, which I'll initialize to [137:47] one. I'll create my while loop, which [137:49] checks for the condition while round num [137:52] is less than or equal to the constant [137:55] rounds. Then, I'll highlight all of my [137:57] code and push it forward so that it's [138:00] indented inside of the while loop. Next, [138:03] I'll want to display the round number at [138:04] the beginning of each round. And I'm [138:06] going to put that right here above where [138:08] I display the scrambled word. That [138:10] should take the game through five rounds [138:12] and display a round number. Let's check [138:14] it out. So, I've got my round number. [138:16] Let's type hint for a hint. I'm getting [138:18] a 500 error, which means the blank is [138:21] down again. So, I think the word is [138:23] server. So, we are going through the [138:25] rounds. Notice that the round number [138:27] isn't incrementing. And that is because [138:29] we still need to make sure that that [138:31] number is incrementing. So way down here [138:33] at the bottom of my loop after we've [138:35] done everything, I'm going to say round [138:38] plus equals 1. Let's control C to get [138:41] out of this and run it again. So we've [138:43] got round one. Let's get a hint. The [138:45] word is debug. Now we're at round two, [138:49] which is great. Let's get a hint. I [138:51] think the word is deadline. And then [138:53] we've got round three. Let's just keep [138:56] going here. Let's skip to make sure that [138:58] we get to round four. I'm noticing that [139:01] it would be nice to have some space [139:03] here. So, I'm going to go ahead and add [139:05] that. Let's skip one more time to get to [139:06] the fifth round. And let's try to guess [139:09] this one. The word is meeting. Round [139:11] five was reached. So, the game exits. [139:14] So, it's working just as we'd expect. [139:16] So, that's great. For aesthetic [139:18] purposes, I'm going to add some space [139:20] here. I'll add a blank line above and [139:22] below round and another blank line after [139:25] the scrambled word. Let's go ahead and [139:27] take a look at this. All right. It looks [139:29] a lot better with the spacing. So, go [139:31] ahead and quit. And let's do the final [139:33] step, which is to add the ability for [139:35] the player to exit out of the game. [139:37] First, to my options menu, I'm going to [139:40] add the option to quit. So, we'll add it [139:43] right here at the end. I'll make sure to [139:45] add it to this one, too. You can guess [139:47] skip or quit. Here in my if else chain, [139:51] I'm going to add an L if that checks if [139:54] the player typed quit. I'll go ahead and [139:56] change this to an L if and then we'll [139:59] start with if guess equals quit. Let's [140:04] print thanks for playing. And we will [140:07] break to exit the loop. Let's check this [140:09] out. Type quit. It says thanks for [140:12] playing and exits out of the game. [140:15] Excellent work. Really fantastic. As you [140:17] play through your game, you might notice [140:19] that some words keep coming up more than [140:21] once. That's because random choice picks [140:24] randomly each round with no awareness of [140:26] what it's already picked. We're going to [140:28] fix that a little bit later, but for [140:30] now, let's keep going. [140:39] So far, we've made lists by writing out [140:41] all of the items at once. But a lot of [140:43] times, you don't have everything up [140:45] front. You start with an empty list and [140:47] add to it as your program runs. whether [140:50] that's items a user types in, results [140:53] you get back one at a time, or things [140:55] that happen while the game is playing. [140:57] The append function is for adding to a [140:59] list. So, let's take a look at it. Let's [141:02] say I'm building a simple task tracker [141:04] or to-do list or something like that. [141:06] I'll start with an empty list called [141:08] tasks. And I can use the append function [141:11] to add items to an empty list as they [141:13] arrive. So, I can say tasks.append [141:16] send invoices. Then we can use append [141:20] again to add a second item. We'll also [141:23] add a third item. Now I will print [141:25] tasks. All those items have been added [141:27] to the list. Append changes the list [141:30] directly. So I don't need to save these [141:33] to a variable in order for it to stick. [141:36] This may seem a little bit strange. You [141:38] might be asking yourself, why don't you [141:39] just add them up here? Send invoices, [141:43] book the venue, and so on. Well, say you [141:45] were building a to-do list and you [141:47] wanted the user to be able to add items [141:49] to a list so that you could display it [141:51] back to them. So, I'm going to make a [141:54] prompt called task item and I will ask [141:57] the user for input. Then I can say [141:59] tasks.append [142:01] task item. Let's see what this looks [142:03] like. So, I want to add an item. Let's [142:06] say by pencils. And as you can see, that [142:09] ends up at the end of the list. Let's [142:11] add another one just for fun. You can [142:14] see that call printer repair is in the [142:17] list. Notice that by pencils is gone. [142:19] And that's because our data doesn't [142:21] persist. It kind of starts over every [142:24] time we rerun the program. Persisting [142:26] the data so we can keep adding the list [142:28] is a whole subject in and of itself, [142:30] which we'll get to much later in the [142:32] course. But for now, I just wanted to [142:33] show you a practical example of how you [142:36] might use append in a program. Because [142:38] with just a list, an input, and a [142:40] function like append, you're already [142:41] halfway to making a to-do list [142:43] application. As you'll see soon, append [142:46] is going to come in handy in our word [142:47] scramble game. It's going to help us [142:49] keep track of words that have already [142:51] been used so we can avoid repeating [142:52] them. We'll get to that, but first, your [142:55] challenge. Your challenge is to imagine [142:57] that you're building a multiplayer game [143:00] wherein players join the lobby one at a [143:02] time. So, start with an empty list [143:04] called lobby. append these players in [143:07] order and then print the final list. Go [143:10] ahead and get started. [143:13] To complete this challenge, I'm going to [143:15] start with an empty list called lobby. [143:17] Then I'll go ahead and append these [143:19] players one by one. I've appended all [143:22] the players. Now I will print lobby and [143:24] let's check it out. There we go. My list [143:26] of players. Fantastic work. Let's move [143:29] along. [143:36] We've learned how to keep a while loop [143:38] running with a counter that stops the [143:40] loop once it reaches a target number. A [143:42] while loop can also be driven by any [143:45] condition that's true or false. Here [143:47] we're going to see how to use a while [143:49] loop with a membership test, which is [143:51] just checking whether a value is in a [143:53] list. To demonstrate, let's say I'm [143:56] building a bingo caller. We have bingo [143:58] numbers, which holds every possible [144:00] call, or at least we're pretending it [144:01] does for the purpose of this [144:03] demonstration, and already called, which [144:06] tracks the bingo numbers that have come [144:08] up so far. The in keyword will let me [144:10] check whether a bingo number is in the [144:12] list already called. So, let's check if [144:15] B7 is in already called. That gives me [144:18] true because yes, B7 is already in the [144:21] list. If we try to look for a bingo [144:24] number that hasn't come up, let's say [144:26] 068, [144:28] that will give me false. Remember that a [144:30] boolean is a Python data type that can [144:32] only have two values, true or false. The [144:35] in keyword returns a boolean, which [144:38] means you can use it anywhere a boolean [144:39] works, including as a while condition. [144:42] If you've played bingo, you'll know that [144:44] a bingo caller should never call the [144:46] same bingo number twice. From the list [144:48] of possible bingo numbers, I want to [144:50] pick a random number and keep repicking [144:52] until I land on one that hasn't come up [144:55] yet. Let me show you what I mean. First, [144:57] I want to pick a random bingo number [144:59] from the list of possible bingo numbers. [145:02] I'll import random, then create a [145:04] variable called pick, where I'll use [145:06] random choice to choose a random bingo [145:09] number from the bingo numbers list. Now [145:11] I'll create a while loop and I'll say [145:14] while pick in already called I want to [145:17] pick a new random number. What this says [145:20] is while my pick is already in the [145:24] already called list go ahead and pick [145:27] another random bingo number. So let's [145:29] say that I pick a random number and the [145:32] program randomly picks I22. We'll look [145:35] and see is I22 in already called? Yes, [145:39] it is. So this condition is going to [145:42] evaluate to true. It's true that we've [145:45] already chosen this number. So go ahead [145:47] and pick a new number. Then let's say it [145:50] randomly picks B7. Now it's going to [145:52] say, is it true that B7 isn't already [145:55] called? Yes, it is. So let's choose a [145:58] random number again. Let's say this time [146:00] it chooses 068. Is it true that 068 is [146:06] in already called? No, it's not. So, we [146:10] know that we have a unique bingo number [146:11] that hasn't already been called. So, [146:14] instead of picking a new one, we will [146:16] break out of the loop and we can be [146:18] confident that we have a unique bingo [146:20] number. So, now I can print my fresh [146:22] bingo number and then let's append that [146:24] number to the already called list. And [146:27] that way, the next time we need to pick [146:29] a number, 068 will be in the list and [146:32] we'll know not to pick it again. As you [146:34] can see, it happened to randomly pick [146:35] 068, which is indeed a bingo number that [146:38] hasn't already been called. If I were to [146:40] print already called here, you can see [146:42] that it has randomly picked B3, which is [146:45] not in the already called list, but [146:47] because we used append, it has added it [146:49] to the list. In a while, we're going to [146:52] use this mechanism in our word scramble [146:54] game. We're going to pick a random word, [146:56] check if that word has already been [146:58] used, and if it has, we'll keep picking [147:00] until we find a fresh word. And that [147:02] way, as the game is going through its [147:04] five rounds, we can prevent it from [147:06] showing the user repeating words. But [147:09] first, I want to give you a challenge. [147:11] Your challenge is to build a feature [147:12] that manages a charity raffle. The [147:15] program picks a random winner, but make [147:17] sure that nobody wins twice. If the [147:20] random winner has already won a prize, [147:22] keep drawing a random winner until you [147:24] land on someone new. So, I'm also going [147:26] to copy and paste a couple of lists. And [147:29] your first step will be to draw a random [147:30] name from the entrance. [147:33] If the name you draw is already in the [147:35] winner's list, keep drawing until you [147:38] get somebody who isn't. Then finally, [147:40] add the new winner to the winners list [147:42] and print the name of the winner. I know [147:45] you can do it. Go ahead and get started. [147:50] I'll start by importing random. And then [147:52] I'll choose a random name from the [147:54] entrance list and save it to a variable [147:56] called name. Then I'll say, well, name [147:59] in winners. In other words, if my random [148:02] choice is already in the winners list, [148:06] I'm going to pick a new random choice. [148:08] I'll keep doing that until I find a [148:10] random choice that is not in the [148:12] winner's list. I'll append them to my [148:14] winners list and finally print the [148:16] winner's name. Let's make sure this [148:18] works. So, I've got a slight typo here. [148:22] Let's clear and try again. We have [148:24] successfully picked a winner who has not [148:26] yet won a prize. [148:35] The random choice function picks a word [148:36] randomly from the word bank and then [148:38] that's it. It's done. It doesn't keep [148:41] track of what it's already picked. That [148:43] means that as you're playing through the [148:44] rounds of the word scramble, there's a [148:46] risk that the same word will show up [148:48] twice or even multiple times over the [148:51] course of a single game. that's not [148:53] going to be a very nice playing [148:55] experience. So, your task will be to fix [148:57] this by tracking the words that have [148:59] already come up and making sure they [149:01] don't repeat. So, we want to ensure that [149:03] a word shows up no more than once per [149:05] game. Outside the game loop, make an [149:07] empty list called used to track already [149:10] used word hint pairs. Inside the game [149:13] loop, write another loop that checks if [149:15] the picked pair is already in the used [149:18] list. And the while loop should keep [149:20] repicking until it finds an unused pair. [149:23] Once you found a fresh pair, append it [149:25] to the used list so it won't come up [149:27] again. And finally, test your game to [149:30] make sure it plays five unique words. Go [149:33] ahead and get started on the challenge [149:35] and good luck. [149:38] Step one, I'm going to create an empty [149:41] used list. Then inside the loop, here's [149:43] where I'm choosing my original word hint [149:45] pair. Under that, I will start my second [149:47] while loop, which will check if the word [149:50] hint pair is in the used list. If the [149:52] chosen word hint pair is in the used [149:55] list, I want to go ahead and pick again. [149:57] So, we'll ask it to choose a random [150:00] choice from the word bank and unpack it [150:03] into word and hint. When a fresh pair is [150:06] found, I want to go ahead and append it [150:08] to my used list so that it won't be [150:11] chosen again. Let's run and make sure we [150:13] get five unique words. [150:16] So the words that came up were [150:18] prototype, deadline, deploy, debug, and [150:22] server. That's five unique words. So [150:24] this is working just as expected. One [150:27] thing that is worth keeping in mind is [150:29] that this repicking loop only works [150:31] because the word bank is larger than the [150:34] number of rounds. We've got 10 words and [150:36] five rounds. So there's always a fresh [150:39] word left to find. But say we had a word [150:41] bank that had exactly five words and a [150:44] game that had exactly five rounds. By [150:47] the last round, every word is already [150:49] going to be in the used list. This would [150:52] cause the inner loop to keep picking [150:53] used words over and over again forever, [150:56] never being able to find a new one, and [150:59] so the game would just freeze up. It [151:01] would hang. So whenever you use this [151:03] pattern, make sure the pool you're [151:04] picking from is bigger than the number [151:06] of items you'll pull out of it. Really [151:09] fantastic work here. We are so close to [151:11] being able to call this game finished. [151:20] You've built a scrambler, added hints, [151:22] set up a game loop, and made sure words [151:25] don't repeat. You've done an incredible [151:27] amount of work, and your game is almost [151:30] complete. There's just one feature left, [151:32] and that is keeping score. Before we get [151:35] started, I want to quickly point out [151:36] that I've added a little welcome screen [151:38] to the game. It's just a few print [151:40] statements, but it helps the game feel a [151:42] little bit more complete and it will be [151:44] fun to customize. But first, your [151:46] challenge. You're going to want to tell [151:48] the player their score and how they did. [151:50] Before the game loop, you're going to [151:52] want to set up a score variable to count [151:54] the number of correct guesses. And go [151:57] ahead and start by initializing that to [151:59] zero. Each time the player guesses [152:00] correctly, you're going to want to [152:02] increment the score by one. A little [152:04] hint here, if you don't know where to [152:05] increment the score, go ahead and look [152:08] for a place in your code where you're [152:09] already comparing the player's answer to [152:12] the correct answer. When the game ends, [152:14] I'd like you to show a final score out [152:17] of the total number of rounds. And [152:19] here's an example of what that should [152:21] look like. So, in this example, they've [152:23] gotten a score of three. So, you'll [152:24] display a message that says final score [152:27] three out of five. Then you'll use an if [152:30] l if else chain to give fun feedback [152:32] based on the player score. I've included [152:35] some example output, but I want you to [152:37] feel free to write your own text. So for [152:39] a score of five, we want to let them [152:41] know that their score was perfect. Or a [152:43] score of four, we want to let them know [152:45] that they were almost perfect or did [152:48] great. With a score of three, we want to [152:50] let them know that they did fairly [152:51] decently. And a score under three is a [152:55] try again next time. go ahead and get [152:57] started on this challenge. [153:02] I hope that went really well and you're [153:04] excited about your finished game. Let me [153:06] show you my solution. First, I'll come [153:08] down here and add a new variable called [153:11] score, which I will initialize to zero. [153:14] Then, I'll come down here to this if [153:16] else chain. And here's the block where I [153:18] am comparing the player's guess to the [153:20] correct word. This is where I determine [153:22] whether the guess is correct. So, this [153:24] is a great place to increment the score. [153:27] So, here I'll say score plus equals 1. [153:30] So, every time the player guesses a word [153:32] correctly, it's going to add a point to [153:35] the score. Next, at the very bottom [153:38] after my game exits is where I want to [153:41] add my score feedback code. I'm going to [153:44] pay extra attention to the indentation [153:46] here to make sure that this code is [153:48] outside of the loop. I will print my [153:51] final score and I'm going to display [153:54] whatever their score is. And here I'm [153:56] actually going to use the constant [153:58] rounds. I could very easily just put a [154:01] five here, but just in case I someday [154:03] want to change the number of rounds. [154:05] This will give me a little bit more [154:07] flexibility. Next, I'll start writing my [154:09] if chain that'll give feedback based on [154:11] the score. So, if the score equals 5, [154:14] which is the maximum score, I'm going to [154:17] keep things simple here and assume that [154:18] my game is always going to have exactly [154:20] five rounds when I score. But if I [154:23] wanted to make it a little bit more [154:25] flexible, I could base this on the [154:27] number of rounds in the game because the [154:29] number of rounds in the game is always [154:31] going to be the maximum score. So, if [154:33] there are seven rounds, they can score a [154:35] maximum of seven points. And that would [154:38] keep the score relative to the number of [154:40] rounds. So if we were to continue in [154:43] this vein, the next conditional might be [154:46] else if score equals rounds minus one. [154:51] So if we had seven rounds in the game, [154:54] that would mean we'd be checking here if [154:56] their score was equal to six. Rounds [154:58] minus one is six. So that's something to [155:01] think about when it comes to making your [155:03] games flexible and maintainable. But for [155:06] right now, let's not make things too [155:08] complicated. We'll assume five rounds in [155:10] the game. So if the score equals five, [155:13] I'm going to go ahead and print my [155:15] message, which I'll copy and paste in. [155:17] Else if the score equals 4, I'll paste [155:20] my second message in. The score is [155:24] three. I'll print my good effort [155:26] message. And now the remaining possible [155:28] scores are 1 or two. And I'll let else [155:32] cover both of them. So unless the score [155:34] is three, four, or five, we'll say [155:37] better luck next time. For aesthetic [155:40] purposes, I'm going to add a couple of [155:42] blank print statements. And let's make [155:44] sure this works. Here you can see the [155:46] welcome screen. We've got our first [155:48] word. I've played through the game. And [155:50] as you can see, we have a final score of [155:52] five out of five. And a little message [155:54] here to wrap things up. And that's the [155:56] last feature. Your word game is complete [155:58] and fully playable. [156:06] Congratulations. You have done it. [156:09] You've built a finished word scramble [156:11] game with a lot of moving parts. And I [156:13] hope you're extremely impressed with [156:15] yourself. I am certainly very impressed. [156:18] You've learned a lot in this section of [156:20] the course. Lists and tpples, the random [156:22] module, while loops, conditionals, and [156:25] string methods. That's a solid stack of [156:27] Python skills. I want to encourage you [156:30] to have fun making this game your own [156:32] because I think one of the funnest [156:34] things about it is how customizable it [156:36] is. You could completely rename it and [156:38] change the theme. Mine is tech jargon, [156:41] but yours could be about animals, [156:43] movies, sports, mythical creatures, [156:45] whatever else sounds fun. You could [156:48] expand or completely replace the word [156:50] bank. You could ask your favorite [156:52] chatbot to generate hundreds of word and [156:54] hint pairs to create a massive game [156:57] where words rarely repeat. You could [156:59] alter and improve the game's appearance [157:01] by changing the welcome screen borders [157:03] or adding emojis. There's really so much [157:05] that you could do. So have fun, be [157:08] creative, and I'll see you in the next [157:10] one. [157:17] Picture a karaoke night. Crowds are [157:19] signing up to sing. Groups of singers [157:22] are constantly coming and going. Some [157:24] beg to be bumped to the top of the [157:25] queue. Whatever happens, the host has to [157:28] keep track. And in this module, we're [157:30] going to build an app called Sing Out to [157:32] help them do it. So, let's take a look [157:34] at the finished app. As the developer, [157:36] you'll give the karaoke host a complete [157:38] set of commands to manage the queue [157:40] with. And notice the queue is numbered, [157:42] so every singer will be able to see [157:44] where they are in line. Let's say a [157:46] couple of people walk in wanting to [157:48] sing. So, the host adds them to the end [157:50] of the queue. I can do that by typing [157:52] add, and then it'll ask for a name and a [157:55] song. Let's add one more. Notice that [157:58] the app formats the names and songs for [158:00] us. Let's say it turns out it's Mike's [158:02] birthday. So, the host wants to bump him [158:04] up to the top of the queue. Can type [158:06] top. Then, it's going to ask me for the [158:08] number of the person in the list. I want [158:10] Mike, so I'm going to type four. And [158:12] that bumps Mike to the top of the list. [158:14] If the karaoke host wants to call a [158:17] singer up to the mic, they can type next [158:19] to bring up the next singer. Now, the [158:21] singer is removed from the list and [158:23] announced here. A karaoke night is [158:25] pretty loud and hectic, and the host is [158:27] bound to mistype things. So, we're going [158:29] to build this app with some guard rails. [158:32] Let me show you. Let's say I want to [158:33] move someone else to the top of the [158:35] list. And it's asking me for a number, [158:37] but let's see what happens if I type a [158:39] word. It doesn't crash. It just asks for [158:42] a number. and the app carries on. What [158:44] if I call singers up when there's nobody [158:46] left in the queue? I'm going to call the [158:49] singers up until the list is empty. [158:52] You'll see now it says the queue is [158:54] currently empty. If I try to call next [158:56] again, it simply repeats. The queue is [158:58] empty. No crashing. So, this is what [159:01] we'll be building in this section of the [159:03] course. By building this project, we are [159:06] going to learn about functions. You've [159:08] been using functions since your very [159:10] first Python program. Every time you've [159:12] called print or input, you're using a [159:14] function that comes built into Python. [159:17] But now you're going to learn how to [159:18] write your own functions. Every command [159:20] the host types in the Karaoke Q app is [159:23] going to be a function that you write. [159:25] We're also going to go deeper into [159:26] planning, scaffolding, and organizing [159:28] application code, which includes an [159:30] important concept in software [159:32] development called separation of [159:34] concerns. The idea is to use functions [159:36] to separate the different kinds of tasks [159:38] your program needs to accomplish. [159:40] Instead of writing code top to bottom [159:42] the way we have so far, you'll learn [159:44] about another type of loop called a for [159:46] loop, which lets you run the same block [159:48] of code once for every item in a list. [159:51] Very useful, as you'll see. We'll learn [159:53] a few more list methods to help manage [159:56] the karaoke queue, like removing singers [159:58] from the queue or moving them to a [160:00] different position. Finally, we'll learn [160:02] how to handle bad input and prevent the [160:04] app from crashing with guard clauses and [160:07] try except. A guard clause is a check at [160:10] the top of a function that handles when [160:12] something goes wrong. And try except [160:14] lets us decide what to do when a block [160:16] of code fails. As usual, we'll build the [160:19] project in stages with lots of [160:21] opportunities to practice along the way. [160:23] Are you ready? Let's go ahead and get [160:25] into it. [160:32] Let's talk about functions in Python. A [160:35] function lets you save blocks of [160:38] reusable code. Let's say I'm building a [160:41] game that involves a dice roll. To [160:43] simulate a dice roll, I'll first start [160:45] by importing random. And then I'm going [160:48] to use a function available on random [160:50] called rand int. rand int takes two [160:53] numbers. I'm going to pass it a 1 and a [160:56] six. And it's going to return to me a [160:58] whole number between 1 and six. And I'm [161:01] going to save that to a variable called [161:03] roll. Then I'm going to print the random [161:05] number as a roll. Let's run this. And [161:08] you'll see that every time I run the [161:10] file, it'll give me a random roll. Now [161:13] imagine I was building a game that [161:15] required a dice roll over and over and [161:19] over again. Instead of repeating these [161:21] two lines of code everywhere, I can [161:23] package them up into a function. Here's [161:26] how you make a function. A function [161:28] starts with the keyword defaf, and that [161:31] is short for define. This tells Python [161:33] I'm about to write or define a function. [161:36] Now we can give the function a name. I'm [161:38] going to name it roll dice. Naming a [161:41] function is very similar to naming a [161:43] variable. It should be lowercase words [161:46] joined with underscores. And the name [161:48] should describe what the function does. [161:50] So just like with a variable, we want to [161:52] avoid naming functions that don't mean [161:54] anything like fu or x. After the [161:58] function name, we need parentheses and a [162:00] colon. Then I'll move my code into this [162:02] function by making sure that I indent [162:05] it. So this is another place where [162:07] indentation is really important. [162:08] Whatever I indent inside the function is [162:11] called the body of the function. To run [162:13] the code inside of roll dice, I'll need [162:15] to call the function. We've seen this [162:17] many times before when calling built-in [162:19] Python functions like print for example. [162:22] So I'm going to call my function using [162:24] its name followed by parenthesis. So [162:26] just to be really clear, this is me [162:28] defining a function and this is me [162:31] calling a function. So here I'm saying [162:33] whenever I call a function called roll [162:36] dice, here's what I want you to do. And [162:38] now I'm calling roll dice. So let's run [162:41] this and see what happens. I rolled a [162:43] one. The fun and useful part about this [162:45] is that I can call this function over [162:47] and over and get a new dice roll each [162:50] time. I can also call functions inside [162:52] of functions. So say I'm building a game [162:55] where I need to throw two dice at once. [162:57] I'll define a function called throw dice [163:00] and inside I'll roll the dice twice. Now [163:03] I can call throw dice and each time it's [163:05] going to give me two rolls. So as the [163:07] programs you write get more and more [163:09] complex, you can use functions to neatly [163:12] organize your code into different [163:14] reusable tasks. So for example, roll [163:16] dice is one task. Throwing multiple dice [163:18] is another task. And another might be [163:21] displaying a welcome screen. I'll define [163:23] yet another function show welcome and in [163:27] it I will print welcome to dice fight. [163:30] Then maybe to create a little space I'll [163:32] add some empty print statements. And [163:35] then you might wrap all these functions [163:36] into yet another function called play [163:38] game. And inside of play game I'll call [163:41] show welcome and also throw dice. And [163:45] now if we call play game, instead of [163:47] having to repeat multiple lines of code [163:49] all over my game, I've wrapped it up [163:51] neatly in a function I can call with one [163:53] line anywhere I need to, as much as I [163:56] need to. So functions are extremely [163:58] important when it comes to keeping your [164:00] code organized and maintainable. And [164:02] we'll be talking much more about them in [164:04] the scrims to come. But first, let's [164:06] give you a chance to practice writing [164:08] some functions. You've very generously [164:10] decided to pick up coffee for six of [164:12] your favorite co-workers this morning. [164:14] So, first I want you to write a function [164:16] announcing your coffee run. And this is [164:19] your example output. You're going to see [164:21] this a lot from now on. I'm going to [164:23] show you an example of what your [164:25] function should produce. So, feel free [164:27] to be creative with what the text [164:29] actually says, but your function should [164:31] print something to the effect of, I'm [164:34] headed to the coffee shop. Who wants a [164:35] latte? Step two, write a function to [164:38] calculate the total cost if you buy each [164:40] of your co-workers a latte for $5. So, [164:44] this function will print out six lattes [164:46] comes to $30. Notice it says, calculate [164:50] the total cost. So, go ahead and do some [164:52] math inside of your function. And step [164:55] three, your co-workers thank you [164:57] profusely. To save yourself a little [164:59] time, write a function that prints [165:01] you're welcome twice and then call it as [165:03] many times as you need to to thank all [165:06] six of your co-workers. And your final [165:08] step will be to put all your function [165:10] calls in a new function called coffee [165:12] run and call it to start your coffee run [165:15] and to make sure that everything works. [165:17] Go ahead and get started on this [165:19] challenge. [165:23] We're back. I hope that went smoothly [165:25] and you're properly caffeinated. Let me [165:27] show you how I wrote my functions. Step [165:29] one is to write a function announcing my [165:31] coffee run. So I'm going to name my [165:34] function announce coffee run. I'll put a [165:36] print statement into the body of the [165:38] function and I'll call my function [165:40] really quick just to make sure it works. [165:42] Looking good. Let's move on to the next [165:44] function. In the next function, I'm [165:46] going to calculate my coffee total. So [165:48] I'll name my function calculate coffee [165:51] total, the little abbreviation. In this [165:54] function, I'm going to start by defining [165:56] some variables. So, I'm going to say I [165:57] have six lattes, and I'm going to say my [166:00] cost per cup is five. And then I will [166:03] print an f string with a number of [166:05] lattes and my total, which would be [166:08] lattes times cost per cup. If you did [166:11] this a little differently where your [166:13] variables are outside of the function, [166:16] this is also totally fine. Let's go [166:18] ahead and call the function and make [166:20] sure it works. That also works just [166:22] fine. And we'll talk a lot more about [166:24] variables and functions later in the [166:26] course. Let's move on to the third [166:28] function where we need to say you're [166:30] welcome to our co-workers. I'll make a [166:33] variable called say welcome where I'm [166:36] going to print you're welcome twice. And [166:38] we have six co-workers. So I'm going to [166:41] call say welcome three times. There's [166:44] our six you're welcomes. What a [166:46] timesaver. And now let's write our final [166:48] function which is to put all of these [166:50] functions in one function called coffee [166:52] run. So I'm going to come up here and [166:54] define a function called coffee run. [166:56] I'll indent my say welcomes and above [166:59] that I'm going to call first I'll [167:01] announce my coffee run and then I will [167:04] calculate my coffee total. Let's run [167:07] this a final time and you'll see that I [167:10] have actually forgotten to call coffee [167:12] run and I have a little typo. So always [167:14] make sure that you've called your [167:16] function. So now that we're definitely [167:18] calling coffee run, let's try this [167:20] again. And there is our entire coffee [167:23] run. Up next, we have even more about [167:26] functions. So please join me in the next [167:28] one. [167:35] Say I'm building an app and I want to [167:36] greet users by name when they log in. [167:40] With what we know so far, I'd write a [167:42] function for the first person. So let's [167:44] say we want to greet somebody named [167:46] Jenny. So I have my function greet Jenny [167:49] and in it I will print welcome Jenny. [167:52] And then I'll need to define another [167:53] function for the next person. And in [167:56] this function I'll print welcome Marcus. [167:59] So this isn't going to work because a [168:01] thousand users would mean a thousand [168:03] nearly identical functions. So let's not [168:06] do that. Instead I'm going to define a [168:08] function called greet and I'll pass it a [168:11] parameter called name. A parameter is [168:13] essentially a variable. So I'm saying to [168:16] Python, when I call this greet function, [168:19] I'm going to pass you a name to use [168:21] inside of the function. Inside of the [168:23] function, I can use name like I'd use [168:26] any other variable. So I'm going to make [168:27] an F string that says welcome. Then I'm [168:30] going to drop that name right in there. [168:32] So I'll call my function greet. Then I [168:34] will pass it the string Jenny. Let's run [168:37] the file. And it says welcome Jenny. The [168:40] awesome part about this is I can call [168:42] the greet function again with somebody [168:44] else. Thanks to my name parameter, I can [168:47] use this one function over and over to [168:50] greet an infinite number of users. [168:53] Something worth calling out here is the [168:55] difference between a parameter and an [168:58] argument. You define a function with a [169:01] parameter. When you call a function, you [169:03] pass in arguments. Another way to put it [169:06] is when you define a function, [169:08] parameters are your variables. And when [169:10] you call a function, arguments are the [169:13] values you're assigning those variables. [169:15] You can define a function with any [169:17] number of parameters. I can pass a [169:20] second parameter here called unread [169:22] messages. Now I can use both parameters [169:25] inside my function. So let me expand [169:28] this to say you have unread messages. [169:31] This will be a number. So it'll say you [169:33] have x number of new messages. Now when [169:37] I call the function I'll pass in two [169:39] arguments. They line up in order. So the [169:42] first argument goes into name. So I'll [169:44] say Jenny again. And the second goes [169:47] into unread messages. Let's say 15. [169:49] Let's go ahead and run again. Welcome [169:51] Jenny. You have 15 new messages. So the [169:54] order that you pass arguments is [169:56] important here. If I were to flip these [169:58] values. So let's say I put in 15 first [170:01] and then Jenny. It's going to say [170:03] welcome 15. You have Jenny new messages. [170:06] So it's important that you pass [170:07] arguments in the same order that you've [170:09] defined your parameters. I'll go ahead [170:12] and switch this back. The variables, [170:14] these parameters and their assignments [170:16] are only for this function. That means [170:19] that if outside of the function, I'm [170:21] going to comment this out. If outside of [170:23] the function I were to try to print the [170:25] variable name, Python has no idea what [170:28] I'm talking about. It doesn't know what [170:29] name is, I get this error because name [170:32] and unread messages are only available [170:35] in what's called local scope. That means [170:38] that only this function has access to [170:41] name and unread messages. If I define a [170:44] variable outside the function, it's in [170:46] what's called the global scope. So I'm [170:48] going to define a variable called shop [170:51] name. and I can make a function that [170:53] reaches out and works with that [170:54] variable. So I'll make a function called [170:57] show welcome and we'll print an fstring [170:59] that uses that variable. When I call the [171:02] function, you can see that my function [171:05] does have access to this variable. [171:07] That's because this entire program has [171:10] access to this variable. It's in what's [171:12] called the global scope. So the idea [171:14] that I'm trying to get across here is [171:16] that the parameters and variables that [171:18] you use inside of a function are only [171:20] accessible to that function. A function [171:22] can reach out and use variables in the [171:25] global scope, but nothing can reach in [171:28] and access the function's parameters. So [171:30] you might be wondering why bother using [171:32] parameters if a function can just access [171:35] variables outside of itself. And the [171:37] reason is because they help keep a [171:39] function contained. I know that I can [171:41] use this great function anywhere because [171:44] it doesn't depend on any variables in [171:46] the global scope. It comes packaged with [171:49] everything it needs or you'll pass in [171:51] the arguments it needs when you call it. [171:53] Because the function doesn't depend on [171:55] any outside variables that frees you up [171:57] to use it in multiple files or in [171:59] multiple areas. I'm going to go ahead [172:01] and comment all of this out so I can [172:02] give you your challenge. Your challenge [172:05] is to write two functions with [172:07] parameters. For the first one, I want [172:09] you to write a function called add [172:10] numbers that prints the sum of two [172:12] numbers you pass in. And I want you to [172:15] call it a couple of times with different [172:17] numbers. So here's an example output. If [172:20] you give it the numbers 2 and 3, it [172:22] should print five. If you give it the [172:25] number 10 and the number 45, 45 + 10 is [172:29] 55, so it should print 55. Function [172:32] number two, you've scrambled a word [172:34] before. Now, I want you to create a [172:36] function that can take in any word and [172:38] scramble it. So, remember to scramble a [172:41] word, you turn it into a list of [172:42] letters, shuffle those letters, and then [172:45] join those letters back together into a [172:47] list. So, let's make that reusable. [172:50] Write a function called scramble that [172:51] takes in a word and prints a scrambled [172:54] version of that word. So, for example, [172:56] if you call it and pass the argument [172:59] Python, it might print a scrambled [173:01] version that looks like this. go ahead [173:03] and get started. [173:07] First, I'll define a function called add [173:09] numbers. And my function will take two [173:12] parameters, which I will call number one [173:14] and number two. And then I'm going to [173:17] print num one plus num two. And that [173:20] should print the sum of those two [173:22] numbers. So, I'm going to call add [173:24] numbers with the numbers two and three. [173:27] So, that should be five. And I'm going [173:30] to call add numbers again with 10 and [173:33] 45. And that should print 55. Let's make [173:36] sure my function works. There we go. It [173:39] prints 5 and 55. For the second one, [173:42] I'll create a function called scramble. [173:44] And to scramble, I'm going to pass in a [173:46] word. And inside the function, I'm going [173:49] to split the word into a list. And I'm [173:51] going to save that list to a variable [173:54] called letters. Then I'm going to [173:56] randomly shuffle the letters. And once [173:59] those letters are shuffled, I'm going to [174:02] join them together with a blank string [174:05] so that it's all one word. And to join, [174:07] I will pass my letters list. And I'm [174:09] going to go ahead and print the result [174:11] of joining these back together. Now, I'm [174:13] going to call my scramble function with [174:16] my own name. Why not? And we run that. [174:18] Looks like we need to remember to import [174:21] random. So, at the top of my code, I'm [174:24] going to import random. And let's try [174:25] this again. We run this a couple of [174:28] times. There are scrambled versions of [174:30] my name. [174:38] You've already used built-in functions [174:39] that hand you a value. A good example of [174:42] this is the list function. The list [174:44] function breaks a string into individual [174:47] letters and then returns you or hands [174:49] you back a list which you then save to a [174:52] variable. So, it doesn't just print the [174:54] word listen as a list. it actually [174:56] handed you back that list so you could [174:58] save it to a variable and do something [175:00] with it. Now, let's write our own [175:02] functions that return values rather than [175:05] just printing them. Say I'm planning a [175:07] pizza party and I want to work out how [175:09] many pizzas I need to order. I'll start [175:11] with a function that calculates how many [175:13] slices I need. I'm going to pass in the [175:16] number of guests and I'm going to [175:18] estimate that each guest will eat two [175:20] slices. So, I'm going to print guests* [175:24] 2. Then I'll run my function assuming [175:27] I'm expecting 10 guests. And that gives [175:29] me 20 slices of pizza. Now I'm going to [175:32] write a second function to figure out [175:33] how many whole pizzas I need because you [175:36] can't order half or a quarter of a [175:38] pizza. First up here, I'm going to [175:40] import math so that I can use math. And [175:43] in my function, which I will call pizzas [175:47] needed, we'll have that take in the [175:48] number of slices. And we're going to say [175:51] each pizza has eight slices. So, I need [175:55] to divide the number of slices I need by [175:57] eight to get the total number of pizzas, [176:00] which I will round up to the nearest [176:02] whole pizza. And then I'm going to do [176:04] something different now. I'm going to [176:06] have the function return this value. So, [176:08] to slices, I'll save the result of [176:10] calling slices needed. I'm going to say [176:13] I need 10 slices again. And then to a [176:15] variable called pizza, I'm going to save [176:18] the result of calling pizzas needed. And [176:20] I'm going to pass in the number of [176:23] slices. So basically I need this value. [176:26] Going to save it to a variable so that I [176:28] can pass that value to the pieces needed [176:31] function. Then finally I'm going to [176:32] print the number of pizzas that I need. [176:35] Let's run this. And maybe some of you [176:37] have already guessed what's going to [176:39] happen. Mhm. It broke. The problem is [176:42] this print statement right here. I can't [176:44] just print this value. I need the slices [176:47] needed function to actually hand me that [176:50] value back so that I can pass it to [176:53] pizza slices. So the return statement is [176:55] how we get a value out of a function so [176:58] that we can use it rather than just [177:00] display it. So if instead of printing I [177:03] return here. Let's see if that works. It [177:06] tells me I need three pizzas which is [177:08] correct because I need 20 slices. 10 [177:11] guests eating two slices each is 20 [177:14] slices. divided by the eight slices in [177:17] one pizza. That would be two and a half [177:19] pizzas, which it rounds up to three. So, [177:22] the difference between print and return [177:24] is that print shows you a value on the [177:27] screen in the terminal. Return gives the [177:29] value back to your code so that you can [177:31] save it and use it. So, I'm going to [177:33] comment this out and give you a [177:36] challenge. Your challenge is to write [177:38] some functions that return values. For [177:41] each function, save the result to a [177:42] variable and then use the result to [177:44] print an fstring. First, write a [177:46] function called room area that takes in [177:49] a length and a width and returns the [177:51] area of a room. I want you to get the [177:54] area of a 12x10 room. And your final [177:56] output should look like this. The room [177:58] is 120 ft. For the second one, write a [178:02] function called add tax price that [178:04] returns a price with an 8% tax added. [178:07] And you can calculate that by [178:08] multiplying the price by 1.08. [178:12] Use your function to get a total for a [178:14] $50 item. And this is what your final [178:16] output should look like. Third, write a [178:18] function called full name that takes in [178:20] a first and a last name and returns the [178:23] first and last name joined with a space. [178:26] Then use your function to build a name [178:28] and print a greeting with it. And here [178:30] is what your final output should look [178:32] like. Go ahead and get started on the [178:35] challenge. [178:39] Okay, let's do this first one. I'm going [178:41] to start by defining a variable called [178:43] room area. And to it, I will pass a [178:45] parameter called length and a parameter [178:47] called width. Then I'm going to return [178:51] length time width calculating the area. [178:54] And then to a variable called area, I [178:57] will call my room area function. And I'm [178:59] going to pass in 12 and 10. Then I'm [179:02] going to print an F string that says the [179:04] room is area square ft. Let's make sure [179:09] this works. There we go. Moving on to [179:11] the second one. I'll define a variable [179:14] called add tax. Pass in a parameter [179:16] called price. And then I'm going to [179:19] return price time 1.08. [179:23] I'll have a total variable where I'll [179:25] call add tax and I will pass in 50. Then [179:29] in my fring I'll say with tax that comes [179:33] to total. [179:36] Let's double check this one. With tax [179:38] that comes to $54. Just for fun I'm [179:41] going to add a colon.2f [179:44] here just so the formatting looks a [179:46] little bit nicer. Now on to my final [179:48] function called full name that takes in [179:51] a first and last name. Then I'll return [179:54] first plus a space plus last. Then in my [179:58] fstring I will say welcome name. But I [180:02] need to make sure to create a variable [180:04] called name and call my function in it. [180:07] Let's test our final function out. There [180:09] we go. Welcome paraborggan. Go ahead and [180:12] make sure not to forget my exclamation [180:14] point. And there you go. Beautiful. [180:23] Let's get a basic skeleton up and [180:25] running for the Singout karaoke Q [180:27] manager. When you strip the karaoke [180:29] theme away, this app is really just [180:31] about managing a list. Adding items to a [180:34] list, removing items from a list, and [180:36] moving things around the list. Managing [180:38] a list is the basis of many application [180:41] features. It could be a playlist, a [180:43] to-do list, or an online shopping cart. [180:46] The underlying ideas are very similar. [180:48] So our list is a singer's Q and each [180:51] singer is a name and a song paired [180:53] together. I've also defined here a run [180:56] app function which so far takes in the [180:58] queue and prints a banner that says [181:00] welcome to Singout Karaoke Q manager. So [181:03] let's think for a second about the main [181:05] things that this app needs to do. As [181:08] we're thinking about how it will run, we [181:10] know that it needs to show a list of [181:12] commands. We know we want to be able to [181:14] show the list of singers. We know we [181:17] need to be able to respond to user [181:19] commands. So what commands do we need to [181:22] respond to? We want the user of our [181:24] program to be able to add a singer, [181:26] remove a singer, and quit or exit the [181:28] program. Another way to state this is [181:31] that the app needs to keep running until [181:33] the host decides to quit. You may [181:36] remember that the word scramble game ran [181:38] for a set number of rounds, but this app [181:40] is a little different because we want [181:41] the user to be able to run it until they [181:44] decide to quit out of it. So instead of [181:46] counting rounds, I'm going to use a [181:48] variable to track whether the app is [181:50] still going. So here inside of my run [181:52] app function, going to create a variable [181:54] called is running, which I'll set to [181:56] true. And still inside of my run app [181:59] definition, I'll create a while loop [182:01] that checks for the condition is [182:03] running. So as long as is running is [182:06] true, this loop will keep going. If I [182:08] want it to keep running until the user [182:10] quits, I'm going to have to listen for a [182:13] command from the user. In other words, [182:16] I'm going to have to ask for some input [182:18] from the user. So, I'm going to create [182:19] an input prompt, and we're going to [182:21] change this. But for right now, I'll [182:23] just say, do you want to quit? I'll save [182:26] their response to a variable called [182:28] command. And now, I can listen for that [182:30] command and respond to it. So, if [182:32] command equals quit, I'm going to change [182:35] is running to false. That will change [182:38] this variable up here to false, which [182:40] will cause the loop to stop running and [182:42] the program will exit. I'm now going to [182:45] run run app passing in the queue. And [182:48] let's run this. So you see our banner, [182:50] do you want to quit? I'm going to type [182:52] quit and it says good night and exits [182:54] the program. So we know that's all wired [182:56] up. What I want to do now is instead of [182:59] saying do you want to quit? We want to [183:01] listen for several types of input. So, [183:04] I'm just going to add a little carrot [183:05] here to indicate that I expect the user [183:08] to type something. And then above that, [183:10] let's add an options menu. So, we'll say [183:13] options. By the time we're done with [183:15] this, we want the option to add a [183:17] singer, remove a singer, or quit. I'm [183:20] going to say the options are add, [183:22] remove, and quit. Now, let's start [183:25] stubbing out our functions. I'm going to [183:28] show you an example before I hand the [183:30] rest over to you. going to move this [183:32] list up here because this is where we're [183:34] going to start stubbing out functions. [183:36] I'm going to delete the ones that we've [183:37] done. So, we are showing a list of [183:39] commands and let's take a look at this. [183:41] As you can see, here are my options and [183:44] the only one that works so far is quit. [183:47] So, we can delete this line and we've [183:49] also added the ability to quit or delete [183:52] the program. And so, what we are left [183:54] with are the functions that we need to [183:56] stub out. I'm going to do show Q. I'm [184:00] going to make a function called show q [184:03] and I will pass in the Q and then I'm [184:05] going to give this a dock string. A dock [184:07] string is very similar to a code [184:09] comment, but usually it's a sentence in [184:11] triple quotes that describes what the [184:13] function will do. So in my triple [184:16] quotes, I'll say that this function is [184:18] going to print everyone currently in the [184:21] queue. In the body of the function, [184:23] we're not going to write it yet. [184:24] Instead, I'm going to print a [184:25] placeholder in square brackets, and it's [184:28] going to say the Q goes here. And the [184:31] reason that I've done that is now here [184:34] in my game loop, right before the [184:36] options menu, I can call show Q, passing [184:39] in the Q. I'm also going to add a little [184:41] white space here just to make it a [184:43] little bit easier to read. And if we run [184:46] this, we can see my little placeholder [184:48] here. So you are going to do something [184:50] similar with the add singer function and [184:53] the remove singer function. So that [184:55] you'll be able to run the app and a [184:57] little placeholder will show up here and [185:00] you'll add remove and a placeholder will [185:02] show up here and it will look something [185:05] like this. We've got our banner, we've [185:07] got our Q goes here because we want to [185:10] keep showing the Q after any command is [185:12] typed pretty much. So, you'll be able to [185:14] type add and see add a singer. And if [185:17] you type something like sing, the app [185:20] will responds, sorry, I don't know the [185:22] command sing. And if you type quit, it [185:24] will say the queue is closed. Good [185:26] night. So, we're not fully building out [185:28] any of the functions yet. We're getting [185:30] the app running with empty placeholder [185:32] functions. So, we can start it up and [185:35] see the commands working and make sure [185:37] that everything is properly wired up [185:40] before we start filling in the logic of [185:42] the functions. This is called [185:43] scaffolding or building an app shell. So [185:46] you get a skeleton up and running first [185:48] so that you're able to build a more [185:50] complex app while still making sure that [185:53] everything works along the way. So here [185:55] is your challenge. It's a little bit [185:57] long as is the example output and that's [186:00] why I put it in a different file. So the [186:02] app has the show q function stubbed and [186:04] the quit command wired up. Two more [186:07] functions need stubs and the loop only [186:09] handles a quit command so far. So what [186:12] you'll need to do is stub add singer and [186:15] remove singer. And you'll do that by [186:17] following the show Q example. Each dub [186:20] will take in the Q as a parameter will [186:22] have a dock string describing what it [186:24] does and it will print a placeholder. [186:26] Then I want you to finish this if l if [186:30] else chain so that it handles the other [186:32] two commands. So when the command is add [186:35] or remove, you'll need to call the [186:37] matching functions. Then to the end of [186:40] your chain, you'll need to add an else [186:42] that handles when the app receives an [186:43] unrecognized command. So that's what I [186:46] showed you down here. If you type a [186:48] command that it isn't wired up for, like [186:50] sing or banana or apple, it's going to [186:53] say, "Sorry, I don't know that command." [186:55] And then finally, run the app and test [186:57] it. Make sure add, remove, and quit each [187:00] work. And then if you type a command [187:02] that doesn't exist, it will print a [187:04] message instead of crashing the app. So, [187:07] your two function stubs will go here, [187:10] and your commands will go here. Go ahead [187:12] and get started on this challenge. [187:14] You've totally got this. [187:19] All right, I hope that went really well [187:21] for you. Let me show you how I did it. [187:23] So, I'm going to make a little room [187:24] here. And first, I'm going to define the [187:27] function remove singer. I'll pass in the [187:30] Q, and I'll add a dock string that says [187:32] remove singer from the que. We'll go [187:34] ahead and print the string remove a [187:37] singer then and actually I'm going to [187:40] put my next function above this and that [187:44] is my add singer function then I will [187:46] add a dock string that says ask for a [187:51] singer and add them to the que and I'll [187:54] print my string add a singer. So down [187:57] here I want to listen else if the [188:00] command is add I want to call the add [188:04] singer function. Else if the command is [188:08] remove I want to call the remove singer [188:11] function. Else if we get a command that [188:14] we don't recognize I'm going to say [188:16] sorry I don't know the command whatever [188:19] they typed in. Now let's check and make [188:21] sure everything's wired up. So we see [188:22] our banner. Here's where our Q will be. [188:25] Now let's type add. The add a singer [188:27] function ran which is great and we're [188:30] redising the Q. Now let's try typing [188:32] remove. The remove function ran and [188:35] we're again showing the Q. Now let's try [188:37] a command that we don't recognize. And [188:40] now I described this as a crash in the [188:42] instructions and it's not exactly a [188:44] crash. It's more like a silent failing. [188:46] So before they could type in an [188:48] unrecognized command and absolutely [188:50] nothing would happen which is just as [188:52] bad as a crash. But now we have a [188:54] message informing them, hey, sorry, I [188:56] don't know the command that you typed [188:59] in. So that's all great. I'm going to [189:01] quit out of this. I'm going to make this [189:03] goodn night message a little bit more [189:04] descriptive. [189:07] So we have a beautiful skeleton here [189:09] that we can keep improving upon. Really, [189:11] really fantastic job. [189:19] You've used a while loop to keep code [189:20] running until a condition is met. I want [189:23] to introduce you to a new kind of loop [189:25] called a for loop. A for loop runs a [189:28] block of code once for every item in a [189:30] list. So let's say I have a list of [189:33] party guests. Let's loop over the list [189:35] and individually print each name. I can [189:37] do that with four guest in guests. then [189:42] indented so it's inside of the for loop. [189:45] I'll print each guest. Let's see what [189:47] that looks like. And you'll see it [189:49] prints every name in the list. So in [189:51] English, you can read this code as for [189:54] each guest in the list called guests, [189:57] run this indented code. Just like other [190:00] loops, indentation is how Python knows [190:02] this code is inside the loop. This is [190:05] called the body of the loop. When this [190:07] code runs, Python starts with the first [190:09] item in the list. It'll run this code [190:11] which says print that item. So it'll [190:14] print Marcus, then it moves on to the [190:16] next item in the list, runs the code, [190:18] and so on until it reaches the end of [190:20] the list. So it's always going to run [190:22] exactly as many times as there are items [190:25] in the list. The word guest here is just [190:27] a variable that represents each item in [190:30] the list. So I could, for example, drop [190:33] it into an F string and format it [190:35] however I want. So I could say something [190:37] like welcome guest and that is going to [190:40] print for every guest in the list. It's [190:42] worth mentioning as well that this needs [190:44] to be the name of the list that you want [190:46] to loop through. But because this is [190:48] just a variable, you could really name [190:50] it anything. You could call it for [190:51] example person and guests or item and [190:55] guest or you could even name it [190:56] something totally meaningless like for [190:58] fu and guests. But it is convention and [191:01] also best practice to give it a [191:04] meaningful name. And a lot of times the [191:06] list will be a plural and this variable [191:08] will be the single of whatever the [191:10] plural list is called. If I want to [191:12] continue writing code after my loop, [191:15] I'll need to make sure that it is not [191:17] indented. So it should line up with the [191:19] leftmost code. And that's how Python [191:21] knows that it's outside of the loop. So [191:24] if after I'm done printing the loop, I [191:26] wanted to say something like that's [191:28] everyone, then you'll see that will [191:30] print once when the loop is finished. [191:32] And if I were to indent this line, then [191:35] Python would assume that it's inside the [191:37] loop. So it would print once after every [191:40] item in the list. I'm going to move this [191:42] back out of the loop and comment this [191:45] out so that I can give you your [191:47] challenge. It's awards night and here [191:49] are the nominees for best new app. The [191:52] list of nominees can grow or shrink year [191:54] to year, so your program shouldn't care [191:57] how many names are on the list. What [191:59] you'll need to do is loop over these [192:02] nominees and print each one on its own [192:04] line. And I want you to format it like [192:07] this example. So it should say nominated [192:09] for best new app plus the name of the [192:12] app. Then after the loop, print one [192:15] closing line that says and those are [192:17] your nominees. And that should print [192:19] just once after all the names. Go ahead [192:21] and get started. [192:25] To loop through the nominees, I'm going [192:27] to say for nominee in nominees. Then in [192:31] an F string, I'm going to print [192:34] nominated for best new app and then the [192:37] name of each nominee. And outside of the [192:40] loop, I'm going to print and those are [192:43] your nominees. Let's check this out and [192:46] make sure it works. So, as we move [192:49] through this section of the course, [192:50] you'll see that loops come in very [192:52] handy. You can write some code once and [192:54] run it for multiple items, whether there [192:57] are three items or 300. And that helps [192:59] the apps you write do a lot more. [193:08] A karaoke Q manager is going to need to [193:11] manage a list of tpples, a singer who is [193:14] matched with the song that they want to [193:15] sing. So let's talk about how to loop [193:17] through a list of tpples. So, I've got [193:20] my list of party guests, but now each [193:22] one is bringing a dish. So, I'm storing [193:25] both the name of my party guest and the [193:27] dish they're bringing together. I'm [193:29] still going to call my loop or guest in [193:31] guests. But this time, the guest isn't [193:34] just a string containing the person's [193:36] name. It is a tpple. So, inside the for [193:39] loop, I can unpack a tpple just as we [193:42] have done before. So, I'm going to [193:44] unpack the tpple into name and dish. And [193:47] then I can go ahead and print both the [193:49] name and the dish in an fstring. So I'll [193:51] say name is bringing and then the dish [193:54] they're bringing. Let's make sure this [193:56] prints. Okay, great. So for each pass [193:59] through the loop, Python hands me a [194:01] tpple. I unpack it in the body of the [194:03] loop and then I've got both values to [194:06] work with. Before we move on, here is a [194:08] chance to practice this. Each act in [194:11] this festival lineup is a tpple. So, we [194:14] have the band, the genre, and how many [194:17] minutes they are going to play. Your [194:19] challenge is to loop over the lineup, [194:21] unpacking each act into band, genre, and [194:24] minutes. Then you'll want to use if else [194:26] to print a long set line for any act [194:29] playing 90 minutes or more. And the rest [194:32] will have a normal line. So, here's an [194:35] example of what your output should look [194:37] like. So, go ahead and give this a try. [194:42] Before I show you the solution, I'm [194:44] going to come up here and comment this [194:46] code out. I'll begin by writing my for [194:49] loop. I'm going to name this a little [194:51] bit differently. I'm going to name it [194:53] for act in lineup. And I'll unpack the [194:56] act tpple into band genre and minutes. I [195:01] want a different message of the band is [195:03] going to be playing for 90 minutes or [195:05] longer. So I'm going to say if minutes [195:08] is greater than or equal to 90 I want to [195:12] say that they are doing a longer set. [195:15] I'll start with the band and then in [195:17] parentheses I'll put the genre plays a [195:21] long set of however many minutes over [195:24] 90. Else I will print my normal message. [195:27] Let's give this a check. Looks like I [195:29] have a little typo right here. Let's [195:32] check this again. The 90-minut set and [195:35] the 100 minute set display different [195:37] messages and that's exactly what we were [195:39] looking for. Really excellent work. [195:41] Let's keep it moving. [195:51] Congratulations. You've done an amazing [195:53] job so far and you have the knowledge [195:55] and skill to start displaying the [195:57] karaoke cue. So, we're going to jump [195:59] right into your challenge, and that will [196:02] be to replace show Q's placeholder code [196:05] with working code. So, here are your [196:07] instructions. First, you'll add a header [196:10] that says current Q, and give it some [196:12] visual space by adding a blank line [196:14] above and below. So, when you run your [196:17] app, it should look something like this. [196:20] Then, you'll want to loop over the Q and [196:22] print each singer's name and the song [196:25] that they want to sing. For the third [196:27] step, I want you to move the options [196:29] menu into the show Q function. Every [196:32] time we display the queue, we want to [196:34] remind the user what their options are [196:37] and prompt them so that they can enter [196:39] another option. Go ahead and get [196:41] started. [196:45] First, let's get rid of the placeholder [196:47] code and print a header. So, I'll print [196:50] a line that says current Q and some [196:52] blank print statements above and below. [196:54] Let's double check this before we move [196:56] on. Great. There's our current Q banner. [196:59] Now, what I want to do is loop through [197:01] all of the tpples in this list and [197:03] display them. So, under my banner, let's [197:06] make a little room here. Under my [197:08] banner, I'm going to make a loop where [197:10] I'll say for singer in Q. Then, I'll [197:13] unpack the name and the song from each [197:15] singer. And in the example, you can see [197:17] that we're printing each name with a [197:19] dash in between. So, I'll create an F [197:22] string that prints name dash song. Then, [197:26] I'm going to grab my options menu and [197:29] this empty print statement that is [197:31] creating space. Then, I'll move that [197:33] just below where I'm printing out the [197:35] que. And let's take a look. I'll quit [197:38] out of this, clear, and run again. We've [197:41] got our header. We're displaying the Q. [197:43] And we have our options menu and prompt. [197:46] This is really starting to take shape. [197:48] Good job, [197:56] Let's give the host a way to add [197:59] singers. So adding a singer is two [198:01] separate tasks. Number one, prompting [198:04] the host for a name in a song. And [198:06] number two, appending that singer to the [198:08] queue. So I want you to write a function [198:11] for each. First to write a function [198:14] called prompt for singer. And you can go [198:16] ahead and add the new function right [198:18] here below show q [198:21] in prompt for singer. We want to ask the [198:23] host for a name and a song. And the [198:25] function should return the name and the [198:28] song title cased and stripped of any [198:30] extra spaces. And keep in mind here that [198:33] a function can return two values at once [198:35] if you separate them with a comma. And [198:37] here's an example of that. Then when you [198:40] call this function, you can get the [198:41] values out by unpacking them the same [198:43] way that you would a tpple, which is [198:45] what you're going to do in the add [198:47] singer function. You'll call prompt for [198:49] singer, unpack what comes back and saved [198:52] variables. Then once you have the singer [198:54] and their song, you'll add it to the end [198:56] of the queue. And you'll also print a [198:59] message confirming that the singer was [199:01] added. So here is your example output. [199:04] We show the host their options. They [199:06] type add. Then we'll show them a name [199:08] prompt and a song prompt. But notice [199:11] when it's added to the queue, it's in [199:13] title case just like the rest of the [199:15] singers and their songs. So we prompt [199:18] the user for a name and a song. Once [199:20] we've added it to the queue, we include [199:22] a message confirming that we've added [199:24] that name to the queue. Go ahead and get [199:27] started on this challenge. [199:32] First, let's write the prompt for singer [199:34] function. prompt for singer doesn't need [199:36] to take in the Q because it's not acting [199:38] on it. It's instead prompting the user [199:40] for a name in a song and then returning [199:42] the name in the song. So to the variable [199:44] name, I'm going to add a prompt that [199:47] says name. And I'm going to make sure to [199:50] strip and title case whatever I get back [199:53] from the user. Then I'll prompt for a [199:55] song doing something very similar, which [199:58] I'll also make sure is stripped and in [200:00] title case. Then I'm going to return [200:02] name and song. To be consistent, I'm [200:05] going to add a little dock string here [200:07] that says ask for name and a song and [200:09] return them cleaned up. Now in the add [200:12] singer function, I'm going to unpack [200:14] name and song, which will be the result [200:17] of calling prompt for singer. Let's go [200:19] ahead and print name and song just to [200:22] make sure this is working correctly so [200:24] far. So let's say we want to add a [200:27] singer and I'll say Sam. Here is our [200:30] print statement right here. So, you can [200:31] see we're successfully getting the name [200:33] and song out and the song name is title [200:36] case even though we entered it in all [200:39] lowercase. Now that I've confirmed that [200:41] I'm successfully getting the name and [200:43] the song, I can append the singer and [200:45] the song to the end of the que. So, [200:48] Q.append I'm going to append this as a [200:50] tpple name and song. Then I'll print my [200:54] confirmation added name to the Q. Let's [200:58] give this a final check. And there is [201:01] Bob and singing in the rain at the end [201:04] of my queue. One thing I want to do here [201:07] is fix this typo and add some space in [201:10] between the prompt and our confirmation. [201:12] Fix my typo. And I want to add a space [201:15] here. I'll quit out, clear, and run [201:18] again. [201:20] And there we go. The confirmation [201:22] message is a little bit more readable. [201:24] Great work. [201:30] Karaoke singers often change their mind [201:32] about singing a song or head home early. [201:35] So, the host needs a way to take them [201:37] out of the queue. We can remove an item [201:40] from a list with the remove function. [201:42] So, I have here a list of contacts and I [201:45] can remove an element from this contacts [201:47] list by using a function called remove. [201:51] And then I'm going to pass the value of [201:52] the item I want to remove. So, let's [201:54] remove Homer. Then I'm going to print [201:56] the contacts list. And if we run this, [201:59] you'll see that Homer has been removed [202:01] from the list. So it's pretty [202:03] straightforward. You tell it what item [202:05] you want to remove and then it removes [202:07] it. But there is one complication, which [202:09] is when you try to remove an item that [202:12] is not in the list. So there's no Alex [202:14] in the list. What happens when we try to [202:16] remove Alex? We get an error saying that [202:19] Alex is not in the list. So, we'll need [202:21] to account for the fact that remove is [202:23] going to throw an error if it doesn't [202:25] find what we're asking for. Before we [202:28] try to remove an item, we'll need to [202:30] make sure that that item exists. So, I'm [202:33] going to define a function called remove [202:35] contacts. And to it, I'm going to pass [202:38] my list of contacts and the name that I [202:41] want to remove. Inside of my function, I [202:44] want to loop through this list of [202:46] contacts and look for a name that [202:48] matches the name that I'm going to pass [202:50] in when I call the function. So, I'm [202:52] going to loop through the list by saying [202:54] for contact in contacts. Then, I'll say [202:57] if contact equals name, I want to remove [203:00] that contact from the contacts list. So, [203:03] contacts.re [203:05] the name in the list that matches the [203:07] name that I've passed in. So in other [203:09] words, let's say again that I want to [203:11] remove Homer. I'm going to call this [203:13] function. I'm going to pass in the list [203:15] that I want to remove from. Then I'm [203:18] going to say I want to remove Homer. So [203:20] the function is going to loop through [203:22] every item in the list. And it's going [203:24] to check does the item that I'm [203:26] currently looking at match the name [203:28] Homer? And if it finds the value Homer [203:31] in the list, it's going to remove it [203:34] from the list. If it finds a match and [203:36] successfully removes it, I want to [203:38] confirm to the user that that item has [203:40] been removed. So once we find a match, [203:42] I'll print that we removed the name that [203:45] they asked us to remove. If this whole [203:47] loop finishes and no match is found, I [203:50] want to tell the user that too. So [203:52] outside of the loop, I want to print a [203:54] message saying, "Sorry, we didn't find a [203:56] match." I'll say, "Name isn't in your [203:59] contacts." There is still a small [204:02] problem here. I'm going to run this so [204:04] you can see what it is. So, what [204:06] happened is that it found Homer, but [204:08] then the loop continues looking for [204:11] another match. When it didn't find one, [204:14] it ends and then the function moves on [204:16] to the next line of code. So, what [204:18] happens is that removed Homer and Homer [204:21] isn't in your contacts both ended up [204:23] running. The way we can prevent this is [204:26] by adding a return statement inside this [204:29] if. This is called a bare return and it [204:33] tells the function to exit. We're using [204:35] it to say once you find a match and [204:37] remove it, stop. We're done. And because [204:40] the loop stops immediately when it finds [204:42] a match, it will only ever reach this [204:45] print statement when the match isn't [204:47] found. So now when we run, we simply get [204:50] a message that Homer was removed. And if [204:53] we try to search for somebody who isn't [204:55] in the list, then we get one message [204:57] that person isn't in your contacts. So, [204:59] that is how we can remove an item from a [205:02] list. And I want you to use what you've [205:05] learned to fill in the remove singer [205:08] function. Here are your instructions. [205:11] You're going to find the singer in the [205:12] queue and remove them. So, in the remove [205:15] singer function, prompt the host for who [205:17] to remove. And be sure to clean the [205:19] input. We want it title case with no [205:21] extra spaces. Then, you'll want to loop [205:23] through the queue looking for a matching [205:25] singer name. The extra challenge here is [205:28] that in Singout the Q is a list of [205:32] tpples, a singer name and a song. So [205:35] you'll need to compare against the name [205:36] inside the tpple rather than the tpple [205:39] itself. And I've included a hints MD [205:41] file over here if you need help. So go [205:43] ahead and read it for some guidance. If [205:45] you find a match, remove the whole tpple [205:47] with the remove function. Print a [205:49] confirmation and return. And finally, if [205:51] the loop finishes without a match, print [205:53] a message telling the host that no match [205:56] was found. Here's an example of what [205:58] that should look like. When you run the [206:00] app, you'll prompt saying something [206:02] like, "Who do you want to remove?" [206:04] Person enters a name. Then behind the [206:06] scenes, you'll remove that name and [206:08] print a message that says removed Allen [206:11] from the queue. You should be able to [206:13] confirm that the singer was successfully [206:15] removed because the queue will reprint [206:18] without that singer. And this is what it [206:20] should look like if you search for a [206:22] name that is not in the queue. You [206:24] prompt, who do you want to remove? The [206:26] user types in Sarah and a message prints [206:28] that says there's no one named Sarah in [206:30] the queue. Go ahead and get started. I [206:33] know you're going to do a fantastic job. [206:37] Let's go to the Singout file and down to [206:40] remove singer. I'm going to start by [206:42] deleting this placeholder and prompting [206:45] the user for some input. to the variable [206:47] name. I'm going to save the result of [206:50] asking the user, who do you want to [206:52] remove? I'm going to make sure that I [206:55] strip and title case the input. Then I'm [206:58] going to go ahead and add a blank space [207:00] here so that whatever messages we print [207:03] below are a little bit easier to see. [207:05] Now I will loop through my Q. So I'll [207:08] say for singer in Q. And here, if you [207:11] took a look at the hints file, it talked [207:14] about how you can unpack a tpple like [207:17] this, like we usually unpack a tpple. So [207:20] the tpple is called singer. And we're [207:22] saving the name of the singer to singer [207:24] name and the song to a variable called [207:26] song. And then we're using it below. But [207:28] in this case, we just need the first [207:30] part of the tpple. We're just looking [207:32] for the name of the singer. So I'm going [207:35] to access the name of the singer in the [207:36] tpple using indexing. So when you're [207:39] using indexing, singer zero is the name [207:42] in the tpple and singer one is the song. [207:45] So for every singer tpple, I'm going to [207:48] want to look at singer zero. So if we [207:51] look at the queue up here, the loop [207:54] singer in Q is getting us into each [207:57] tpple. And as we're looking at each [207:59] tpple, I'm saying that I want to get at [208:01] the item in the tpple at index zero. So [208:04] I want to check if singer zero equals [208:07] name and if we find a match I want to go [208:10] ahead and remove that entire tpple from [208:12] the list. So I'll remove the entire [208:15] singer tpple. Then I'm going to print a [208:18] message saying removed name from the [208:21] que. Once the loop finds a match I want [208:24] to return to completely exit out of the [208:26] function. And if we don't find a match I [208:28] want to print there's no one named name [208:32] in the queue. Now, let's check to make [208:35] sure this works. I'm going to say I want [208:37] to remove someone from the list. Who do [208:39] I want to remove? Let's try somebody who [208:41] doesn't exist. First, I want to try to [208:43] remove Ellen. It says there's no one [208:45] named Ellen in the queue. Great. That's [208:47] exactly what we want. Now, let's try to [208:50] remove Allen. It says removed Allen from [208:53] the queue. And we can see in our current [208:55] queue that Allen is gone. Perfect. [208:57] Excellent work. You've done an awesome [208:59] job. [209:05] It would be great if our karaoke queue [209:07] was numbered. Then the host would know [209:09] how many people are in the list and the [209:11] singers would know what they're always [209:12] dying to know. How many songs are ahead [209:15] of theirs? So, how do you number a list [209:17] that's constantly changing? I'll show [209:19] you an example. I have my list of [209:22] contacts here. And as you know, if I [209:24] wanted to loop through them, I could say [209:26] something like for contact in contacts. [209:29] If I wrap contacts in a built-in [209:32] function called enumerate, that's going [209:34] to give me access to the index of each [209:37] element as I loop through it. So I now [209:40] have access to two variables, index and [209:43] contact, which represents the item in [209:46] the list. By convention, when we access [209:48] the index, we shorten it to i. So now [209:51] let me print I and contact. And when we [209:55] run it, prints every item in the list [209:57] and its index. Now I'm going to hand [210:00] this over to you. Here in Singout, I'm [210:03] going to go to show q. And here are your [210:06] instructions. I want you to update show [210:09] q so that the list is always numbered. [210:12] That means you want to print each singer [210:13] with their number starting with one. So [210:17] notice when we looped, we start at zero [210:19] because Python starts counting at zero, [210:22] but humans start counting at one. So, [210:24] you'll need to figure out how to do [210:25] that. And here's a hint. You can do math [210:27] inside of an F string. And then finally, [210:30] try adding and removing several singers [210:32] from the list to make sure that the [210:34] numbering stays consistent. And when [210:36] you're done, here's what you want the Q [210:37] to look like. The number in the queue, [210:39] their name, and the song that they're [210:41] singing. Go ahead and get started. [210:47] Okay. Okay, I'm going to come down here [210:48] into show Q and I'm going to update this [210:51] so I have access to I and Ser and I'm [210:54] going to wrap Q in the enumerate [210:57] function. Now I'm going to add to my F [211:00] string. So at the beginning it prints I [211:03] with a period at the end. Let's check [211:05] this out so far. Looks like I have [211:08] spelled enumerate wrong, which is bound [211:11] to happen. All right, we've got Annie [211:13] starting at number zero and Allen [211:15] starting at one. So, how can I fix this? [211:18] I'm going to come here into my f string. [211:21] And this is what's called an off by one [211:23] error. It's the idea that Python starts [211:25] counting at zero and humans start [211:27] counting at 1. So, I can fix this by [211:30] saying that I want to display I + 1. So, [211:33] that should correct the way the Q is [211:35] numbered and quit out of this and run it [211:37] again. There we go. Now, the numbering [211:39] is correct. Let's try adding somebody [211:41] just to make sure. Now, we have share at [211:44] number three. Now let's try removing [211:46] somebody. Let's remove share. So that [211:49] number is correct. Even though singers [211:50] are constantly being added and leaving [211:52] the queue, [211:59] one of a karaoke host's most important [212:01] job is calling the next singer up to the [212:04] mic. That singer is at the front of the [212:05] queue. So we need to be able to take [212:07] them off the front of the list and [212:09] announce that they're the next one [212:10] singing. Let me show you how we can do [212:12] that. I have a list of tasks. Let's [212:14] pretend that it's a to-do list. And [212:16] let's say that I finished the first task [212:18] on my list. So, I want to remove it. I [212:21] can do that with a built-in Python [212:23] function called pop. Unlike remove, [212:26] which takes in a value, pop takes an [212:28] index. So, if I want the first item in [212:30] the list, I'm going to need to pass it [212:32] zero. I'm going to have to specify which [212:34] list I want to work on. So, I'm going to [212:36] say tasks. And the other thing that pop [212:39] does is that it returns you the item [212:41] that you removed. So the item you [212:43] removed is available to save to a [212:46] variable. So I'll name the variable [212:47] first as if I'm removing the first task [212:50] on my list. So let's print the first [212:52] variable. And let's also print the tasks [212:55] list. That returns me the item I popped [212:58] from the beginning of the list and also [213:00] my list which no longer contains that [213:02] item. So the difference between pop and [213:05] remove is that remove takes an item out [213:07] by its value and returns nothing. and [213:10] pop takes an item out of a list by its [213:13] position and returns you that item. So [213:15] now it's your turn. Here are your [213:17] instructions. I want you to write a [213:19] brand new function called next singer [213:22] which will take in the que. And if you [213:24] have a look at the singout file, you'll [213:26] see that I've marked where that function [213:28] should go. So in this function, you'll [213:30] want to take the singer off the front of [213:32] the queue using pop and save the return [213:35] value. When you use pop on our list, [213:37] it's going to return the whole tpple and [213:39] not just the singer's name. So, you want [213:42] to unpack the singer into a name in a [213:44] song and announce that they're next. And [213:46] then you'll want to add next to the [213:48] options menu and make sure next singer [213:51] is called when a user types next. Here's [213:54] our example output. Here's our Q. We [213:57] have a next option added to the options [214:00] menu. When the user types next, we'll [214:03] see an announcement that says now up [214:05] Annie who is singing dancing queen. And [214:07] then when the queue reprints, we'll see [214:10] that there is only one item in it. And [214:12] if you have more than one item in your [214:14] list, you should see that the first item [214:16] is gone. Go ahead and give this [214:18] challenge a shot. [214:22] Over here in Singout.py, I'm going to [214:25] define a function called next singer. [214:28] I'll pass in the Q. Then I want to call [214:30] pop on my Q and I want to remove the [214:33] first item in the list at index zero. [214:35] And this is a tpple. So I'm going to [214:38] unpack this into name and song. Now that [214:41] I have name and song saved to variables, [214:44] I'm going to create an F string and it's [214:46] going to say now up name dash song. Now [214:51] I need to come down here to my else if [214:54] chain and somewhere in here I'm going to [214:56] add a new l. I'll add it after add and [214:59] I'll say l if command equals next. I [215:03] want to call the next singer function [215:06] passing in the que. Let's see if this [215:08] works. So we've got Annie and Allen in [215:10] the queue. I still need to add this to [215:12] my options menu. Let's go ahead and type [215:15] next and see what happens. There we go. [215:17] Now up. Annie singing dancing queen. And [215:20] we can see that that has disappeared [215:22] from our que. So that's perfect. Let's [215:25] go up to the options menu and add next [215:28] as an option. And also let's quit and [215:30] run again. Say next. And it looks like [215:33] we could use a space here. So I'm going [215:35] to go ahead and add that. Add a blank [215:37] space right here. And let's check this [215:39] one more time. There we go. That's [215:41] looking great. Let's keep going. [215:49] Often a karaoke host needs to bump [215:51] someone to the top of the queue. Maybe [215:53] it's their birthday or they've slid the [215:55] karaoke host a generous tip to move a [215:57] singer to an exact spot. We can use the [216:00] insert function. So I have a list of [216:02] tasks here and let's say I have a task [216:04] that's more urgent. So I want to put it [216:06] at the front of the list rather than [216:08] appending it to the end. So I can say I [216:10] want to insert and insert takes two [216:13] things. The desired position or index [216:16] where I want to insert a value and the [216:18] value itself. So I can say in the tasks [216:21] list at position zero I want to insert [216:24] the item pay rent. Now when we print [216:26] tasks you'll see that item has been [216:28] inserted. There it is. Pay rent inserted [216:30] at the top of the queue. To move an item [216:32] already in a list is two steps. First we [216:35] need to pop it out of where it is and [216:37] then insert it where we want it to go. [216:40] Let's say that calling my mom becomes [216:41] the most important item on my tasks [216:43] list. So I can say tasks.pop pop and I [216:47] want to pop from the list the item at [216:49] position two. So we've inserted pay [216:52] rent. So pay rent is at position zero, [216:54] do laundry at one, and call mom at two. [216:57] This is going to return to me the call [216:58] mom task. So I'm going to save that to a [217:01] variable called to-do. And now that I [217:03] have call mom saved to a variable, I can [217:05] go ahead and insert it back into the [217:07] list. So into the task list, I want to [217:11] insert at position zero the to-do list [217:14] item call mom. Now let's move this print [217:16] statement down here. And you'll see that [217:18] the list has transformed and we've moved [217:20] the call mom item to the front of the [217:22] list. So now it is your turn. Your task [217:26] is to write the entire move to top [217:28] function. And you'll do that here in [217:29] Singout.py. And here are your [217:32] instructions. Moving a singer to the top [217:34] of the queue is two steps. Number one, [217:37] take them out of their current position. [217:39] And number two, insert them at the [217:41] beginning of the queue. So in your move [217:43] to top function which needs to take in [217:45] the queue, you'll first ask the host [217:47] which position they want to move and [217:49] convert their answer to a number. Then [217:51] you'll take that singer out of the queue [217:52] with pop. And this is important. You'll [217:55] need to watch for what's called an off [217:57] by one error. Our Q starts counting at [217:59] one, but remember that Python starts [218:02] counting at zero. So when we're looking [218:04] at our Q, Annie is at position one, but [218:07] in our list, she is at position zero. So [218:10] you'll need to account for that in your [218:12] code. And here's a hint. Pass the host [218:14] number minus one as the argument to pop. [218:17] Then you'll put the singer back at the [218:18] front of the queue with the insert [218:20] function. And finally print a message [218:23] announcing who has been moved to the [218:24] top. You'll also need to call move to [218:27] the top in the app loop so that the host [218:29] can run the command and also add it to [218:32] the options menu. So here's your example [218:34] output. You'll see in the options menu, [218:36] we've added a top option here. When the [218:39] user types top, it should say, "Who do [218:41] you want to move to the top? Enter a [218:43] number." The user enters something like [218:45] two. Then behind the scenes, we'll move [218:47] Allen up to the top of the queue and [218:49] send the message moved Allen to the top [218:51] of the queue. And then here's what the [218:53] new queue looks like with Allen at the [218:55] top. Go ahead and get started on the [218:57] challenge. [219:01] Okay, hopefully that went well. I'm [219:03] going to go into Singout.py [219:06] and start creating my move to top [219:08] function. I will take in the Q and I'll [219:10] start by prompting the user for a [219:12] position number. I'll convert the [219:14] position number to an int and save to a [219:17] variable to capture their answer. I'm [219:19] going to make a little room in the [219:20] display by adding a blank print [219:22] statement here. And now whatever [219:24] position they've entered, I'm going to [219:25] want to use the pop function to remove [219:28] it from the que. So from the queue, I [219:31] want to pop the item at the position [219:33] number that I've gotten from the user. [219:36] But to take care of the off by one [219:38] error, I'm going to need to say pop [219:40] position minus one. So again, when the [219:42] user is looking at the list, they're [219:44] going to see Annie as number one and [219:46] Allen as number two. If they want to [219:48] move Allen, they're going to say they [219:50] want to move the person at position two. [219:52] But for us in our list, because it [219:54] starts counting at zero, this is [219:56] actually going to be position one, 0 and [219:59] one. So for example, if we were asking [220:01] for Allen, we would be asking for [220:03] position 2 minus one, which is position [220:06] one. So that's how we take care of the [220:07] off by one error. Now I'm going to save [220:10] the item at this position to a variable, [220:12] which I'll call singer. And I'll use [220:14] insert to move them to the front of the [220:16] queue. So into our Q list, I want to [220:19] insert at position zero this singer that [220:22] I've popped off the list. Now that I've [220:25] successfully moved the singer, I want to [220:27] give the host a message letting them [220:29] know that the singer has been moved. So [220:31] I'll say something like moved name to [220:34] the top of the queue. And because I need [220:37] the singer's name, that means I'm going [220:38] to have to unpack this tpple that we get [220:41] back from singer. So I'm going to unpack [220:43] into name and song. And then the first [220:45] item in the tpple, which I've saved with [220:47] a variable name, will end up in our [220:49] fstring. There's my function done. Now, [220:52] I'm going to need to wire this up to the [220:54] app. So, I'm going to come down here to [220:56] my ifels chain. And really, I could put [220:59] this anywhere I want, but here under [221:01] next, I'm going to say if the command [221:04] equals top, then I want to run the move [221:07] to top function. And my final step will [221:10] be to go into show Q and add top as an [221:13] option in the menu. Let's run and [221:16] confirm that everything's working. I'll [221:18] type top. I want to move the singer at [221:20] position two. And we have a message that [221:22] says moved Allen to the top of the [221:24] queue. And here's our current queue. And [221:26] you can see that we have successfully [221:28] moved Allen to the top. Perfect. Great [221:31] job. Excellent work. [221:37] Every if statement you've written checks [221:39] for a single condition, but you often [221:41] need to check for several conditions. [221:44] Say I'm writing the rules for an [221:45] amusement park ride where you have to be [221:47] over a certain age. Let's say 12 or over [221:51] and also a certain height to ride a [221:53] ride. Let's say 140 or over. With an if [221:57] statement, I can say if age is greater [222:00] than or equal to 12 and their height is [222:05] greater than or equal to 140, then we [222:09] can print this person can ride. And we [222:12] can include an else here that says sorry [222:15] not this time. Now I'll create two [222:17] variables. I'll say age is 70 and height [222:22] is 150. Let's run this and find out if [222:25] the person can ride. This person can [222:27] ride. If I change the age to 11, we'll [222:31] get the opposite message. So that's the [222:33] and logical operator. It's going to [222:35] evaluate both of these conditions. And [222:38] both of these conditions must evaluate [222:40] to true for it to run the code in the if [222:43] block. So you can think of this as [222:45] saying if true and true print this else [222:49] print the second message. The or [222:52] operator evaluates both of these [222:54] statements and one of them must be true [222:56] in order for this code to run. Age [222:58] equals 11. So age greater than or equal [223:01] to 12 will evaluate to false. But height [223:05] is greater than or equal to 140. We'll [223:07] evaluate to true because it has to be [223:10] either or. If we run this, we should see [223:12] this person can ride. There's also a [223:15] logical operator called not. So I'll [223:18] create a variable called logged in which [223:20] I'll set to false. Then I can say [223:23] something like if not logged in, print [223:26] please log in. Not essentially flips a [223:28] boolean to its opposite. Logged in is [223:31] false. So not logged in evaluates to [223:34] true which runs the code in the if [223:36] statement. You can also pair not with a [223:39] list and it checks that an item isn't in [223:41] the list. So let's say I want to see if [223:43] a show is sold out or not and I know [223:45] that it's sold out on Tuesday and [223:49] Saturday and I also know that today is [223:52] Wednesday. Then I could write something [223:54] like if day not in sold out print [223:58] tickets are available. So day is [224:01] Wednesday which is not in sold out. So [224:04] when we run this we should see that [224:05] tickets are available. And now it's your [224:08] turn to practice using some logical [224:10] operators. Here is your challenge. Your [224:12] challenge is to write one if statement [224:14] for each situation combining the values [224:17] given with and or not. Number one, a [224:20] house plant only blooms if it got enough [224:22] sun and someone watered it. Print it [224:24] bloomed when both are true. Number two, [224:27] you'll wear a ridiculous hat to the [224:29] party if it's a costume party or you [224:32] don't know anyone there. Print hats [224:34] going on if either is true. Number [224:37] three, the cat lays across your keyboard [224:39] on work days, so it wins when it is not [224:42] the weekend. Print cat wins when it [224:45] isn't the weekend. Go ahead and get [224:46] started on the challenge. [224:51] All right, for the first one, I'll say [224:53] if got enough sun and was watered, we'll [224:58] print it bloomed. For the second one, if [225:01] is costume party or knows nobody, print [225:05] hats going on. And for the third, if not [225:09] is weekend, print cat wins. Let's run [225:13] and make sure these work. There we go. [225:16] Logical operators. Remember that and [225:18] evaluates to true only when both sides [225:20] of the condition are true or evaluates [225:23] to true when either side of the [225:25] condition is true and not flips a [225:27] boolean to its opposite. [225:34] This serve order function pops the first [225:37] order off the list and serves it. But [225:40] there's one problem. What if you call [225:42] serve order on an empty list? This [225:44] throws an error and as it helpfully [225:46] tells us, it's because we're trying to [225:48] pop from an empty list. To catch the [225:51] crash before it happens, we need a way [225:53] to check whether the list is empty. And [225:55] we can do that with the len function. [225:58] Let's say I have a list of orders with [226:01] some stuff that you would find in a [226:02] coffee shop. Now I can print orders and [226:06] wrap the len function around it. And [226:09] that will tell me how many items are in [226:10] the list. An empty list has a length of [226:13] zero. So we can use that to check [226:15] whether a list is empty. So back in my [226:17] function here, I'm going to make some [226:18] space. I'm going to say if the length of [226:22] orders equals zero, I'm going to print [226:26] nothing left to serve and immediately [226:28] return. This is called a guard clause. A [226:31] guard clause lives at the top of a [226:33] function to check for a bad case. And if [226:36] it finds a bad case, such as a list [226:38] being empty, it handles it and returns [226:40] right away. So here if the list is empty [226:43] we print a message and return so the [226:46] function never reaches pop where it will [226:48] error out and if you get past the guard [226:51] you can assume that we found an item and [226:54] the code can continue. So let's save and [226:56] run this and see how it goes. Now [226:58] instead of crashing we get the message [227:00] nothing left to serve and I'll just show [227:02] you that if there is an item in the list [227:05] then this code goes ahead and runs. You [227:08] can also stack guards to check for [227:10] multiple bad states. For example, I will [227:13] make a function called fill order and [227:15] let's say it takes a menu and an order. [227:18] So I could do something for example like [227:21] check if there are any items on the [227:24] menu, maybe the entire restaurant sold [227:26] out. And if not, I can print nothing [227:28] available and return. And then I could [227:31] also write another clause. And let's say [227:33] I want to make sure that an order hasn't [227:34] been placed that's not on the menu. So I [227:37] could say order not in menu. And if [227:39] someone tries to order something that's [227:40] not on the menu, I can print a message [227:42] like order isn't on the menu and return. [227:47] And so once I've made sure that there's [227:49] food on the menu and that the order is [227:52] on the menu, I can go ahead and do the [227:54] regular tasks of my function. For [227:56] example, I could remove an order from a [227:59] menu or print that an order has been [228:03] placed. Something like that. So now it [228:05] is your turn. Call Next seats the first [228:08] guest on a restaurant's weight list. But [228:10] when the wait list is empty, the app [228:12] crashes. So here's our empty weight [228:14] list. And here we have a function call [228:16] next that takes in weight list. And it's [228:19] looking for the first name on the weight [228:20] list so that it can print a message [228:22] about it. And as you can see, if we call [228:25] this function, it's going to crash with [228:28] an index out of range error. So, what [228:31] you need to do is add a guard clause to [228:33] call next that exits early when the [228:35] weight list is empty and prints a [228:37] message instead of crashing. Then go [228:39] ahead and test it with an empty weight [228:40] list to confirm that it no longer [228:42] crashes. Go ahead and give this a try. [228:49] All right, I hope that went well for [228:50] you. At the top of my function is where [228:53] my guard clause goes. So, that's where [228:55] I'm going to start. And I'm going to [228:57] check for an empty weight list. So I'm [228:59] going to check the length of the weight [229:01] list and if the weight list equals zero [229:04] I'm going to print the weight list is [229:06] empty and I am going to return with an [229:10] empty weight list it should prevent this [229:12] code from ever running because the [229:14] length of weight list is zero. So it [229:16] will print this message and exit out of [229:18] the function. Let's go ahead and give [229:20] this a check. So it says we have an [229:22] unexpected token weight list at line 30 [229:25] and that probably means I'm missing a [229:27] quotation mark. Yes, I am. Let's try [229:30] again. The wait list is empty. Great [229:32] job. [229:39] Sing out has all its planned [229:41] functionality, which is definitely worth [229:43] celebrating. So, big congratulations. [229:46] But there's still a little bit more work [229:47] we need to do. And that's because every [229:49] single function in the app assumes that [229:51] there are singers in the queue and that [229:53] the host's input is going to be usable. [229:56] When the queue is empty or if the host [229:58] enters blank input, we're going to run [230:00] into some problems. Let me show you. [230:02] Going to go ahead and get the app up and [230:04] running. I'll type next twice to empty [230:06] the queue. As you can see, show Q prints [230:09] current Q with a blank space underneath [230:11] it instead of a list of singers because [230:13] the queue is empty. This isn't a crash, [230:15] but it does look a little bit broken. [230:18] Here's another problem. Let's see what [230:19] happens if I type next again when the [230:22] queue is already empty. That's actually [230:23] going to cause a crash because we're [230:25] trying to use pop on an empty list. Now, [230:27] I'm going to clear and restart. Here is [230:30] another issue. When I type top, it asks [230:32] me who do I want to move to the top. [230:34] Enter a number. What if I enter the [230:36] number for a singer that doesn't exist? [230:38] So, I'm going to say I want to move the [230:40] singer at position 10. This is also [230:42] going to cause a crash because pop can't [230:45] find that index because it doesn't [230:47] exist. There's no one to move. The next [230:49] one I want to show you is if there's [230:51] only one person in the queue, I'm going [230:53] to type next to call a singer up. So now [230:56] there's only one person in the queue. [230:58] Now if I type top, it's going to ask me [231:00] who I want to move to the top. So I'm [231:01] going to type one. The app very happily [231:04] claims to move that singer to the top [231:06] when it should be telling me there [231:07] aren't enough singers to reorder the [231:09] list. I'm going to quit out of this. [231:11] Clear and restart. And yet another [231:14] problem is say I'm going to add a [231:15] singer. I can actually just hit return [231:17] and hit return again. And the app will [231:20] allow me to add blanks to the queue. So [231:22] there's just a dash. Not ideal. Again, [231:24] this isn't exactly a crash, but it does [231:27] look strange and we want to try to [231:28] prevent that behavior. The final one I [231:30] want to show you is a problem with the [231:32] remove command. I'm going to use next to [231:34] empty the queue. And then I'm going to [231:36] type remove. And it's going to ask me [231:38] who I want to remove. Let's say I want [231:40] to remove Shelly. And it's going to tell [231:43] me that there's no one named Shelly in [231:45] the queue, which is technically true. [231:47] But if the queue is empty, we don't want [231:48] the user to have to go through all the [231:50] rigomearroll of typing a name to remove [231:52] only to be told that there's no one by [231:54] that name in the queue. Instead, it [231:56] should just tell me that the que is [231:58] empty. To fix all of this, we're going [232:00] to need to use some guard clauses. [232:02] Remember, a guard clause is a check at [232:04] the top of a function that catches bad [232:07] input and returns it before we get to [232:09] the lines of code that put the app at [232:12] risk for crashing. I'm going to make [232:14] this window a little bit smaller and I'm [232:16] going to demonstrate using the next [232:18] singer function. The next singer [232:20] function pops the first singer off the [232:22] queue and then displays the now up [232:25] message. So, what I want to do here is [232:27] add a guard clause at the very beginning [232:29] that's going to make sure that the Q is [232:31] not empty before it moves on to this [232:32] code. So, I'm going to check the length [232:34] of the Q. And if the length of the Q [232:38] equals zero, then I'm going to print a [232:40] message saying oops, there's no one left [232:43] to call up. And then I'm going to go [232:46] ahead and return. So, all that will [232:48] happen if the que is empty is it will [232:50] print this. And then the function will [232:52] exit. Then unless we quit out of the [232:54] app, it's going to trigger show q to run [232:57] again with our command prompt so that [232:59] they can try again with a new command. [233:01] So your challenge is to add the rest of [233:04] the guard clauses that we need. So under [233:07] each function that needs a guard clause, [233:09] I have included some instructions as [233:12] code comments. Let's go through them [233:14] really quick. For show Q, when the Q is [233:17] empty, the user sees the current Q [233:19] header with nothing under it. This one [233:21] is a little bit unique because your [233:23] guard clause will use an if else. If the [233:26] Q is empty, you'll print a message [233:29] saying that the Q is empty or else [233:31] you'll want to redraw the que. Here I [233:34] have an example output file so you can [233:36] see what is supposed to happen once your [233:39] guard clauses are in. So in show Q, when [233:42] the Q is empty, the message should be [233:44] the Q is currently empty followed by the [233:47] command menu. We don't need to do [233:48] anything for prompt for singers. So, [233:50] we'll skip that one. For add singer, [233:52] you'll need to write one guard clause [233:54] that stops the function and prints a [233:56] warning if the host has entered a blank [233:58] name or song. And here's a hint. If name [234:02] or song are equal to blank strings, then [234:05] you'll know that you need to print a [234:06] warning and exit out of the function. [234:09] We've already done next singer, but [234:11] let's go ahead and check it really [234:13] quick. I'm going to quit out of this and [234:15] run again. Let's do next and keep doing [234:18] next until we are out of singers. And [234:21] there we see no crash. Instead, we see a [234:24] message that says, "Oops, there's no one [234:26] left to call up." So that's great. Now, [234:28] let's look at the move to top function. [234:31] For the first one, and this is where it [234:32] should go. You need at least two singers [234:35] to reorder the queue. So, warn and stop [234:37] if there are fewer. So, for this guard [234:39] clause, you'll need to check the length [234:41] of the queue and make sure there are at [234:43] least two singers. and if not, print a [234:47] message and exit out of the function. [234:49] And here's what that should look like. [234:50] You attempt to move a singer to the top [234:52] of the queue when there are fewer than [234:53] two singers. The user types top and you [234:56] print the message, you need at least two [234:58] singers in the queue to move someone to [235:00] the top. Then after you get the position [235:02] of the person in the queue that the user [235:04] wants to move, you'll need to add a [235:06] second guard clause. Entering an invalid [235:08] position crashes the app. Make sure the [235:11] position the user enters isn't out of [235:13] range. And that means it can't be less [235:15] than one because the position of the [235:17] first person in the list is one and it [235:20] can't be greater than the length of the [235:22] list. If we have a list with five [235:24] people, then nobody exists at position [235:27] six. And finally, we need a guard clause [235:30] for the remove singer function. So, as [235:32] we saw, this function runs normally even [235:35] if the queue is empty and there's no one [235:37] to remove. So you'll want to write a [235:39] guard clause that warns the user and [235:41] stops the function if the queue is [235:43] empty. This is very similar to what we [235:46] did in the next singer function. So [235:48] here's the example output for that. The [235:51] user types remove on an empty Q. You'll [235:54] print a message that says oops, there's [235:56] no one left to remove. And then this [235:58] comes from show q already. The que is [236:00] currently empty. Plus the command menu [236:03] reprints. So go ahead and go down these [236:06] list of functions one by one. Make sure [236:09] that you look at the expected output for [236:12] each condition. I'm confident that you [236:15] can do it. But if you get stuck, don't [236:17] worry because you'll be able to look at [236:19] my solution. Go ahead and get started [236:22] writing guard clauses. [236:27] Okay, let's start by writing guard [236:28] clauses for show Q. We want to make sure [236:31] to print a message if the Q is empty. So [236:35] I'm going to say if the length of the Q [236:38] equals zero, we'll print a message that [236:40] says the Q is currently empty. Else we [236:43] want to redraw or display the Q [236:46] normally. So I put my else here. And now [236:49] I'm going to indent the rest of the code [236:51] to put it inside of the else. So in [236:54] other words, if the Q is empty, print [236:56] this. And if it's not empty, print this. [236:59] The next one is add singer. So I need to [237:02] guard against entering a blank name or [237:05] song. So after I've prompted for a name [237:08] in a song, I'm going to say if name is [237:11] an empty string or song is an empty [237:14] string. I'm going to print a warning [237:16] message and return. So we'll get the [237:19] name and the song. We'll make sure it's [237:20] not blank. If it is blank, we'll go [237:22] ahead and exit out of the function. And [237:24] if it's not blank, Python will move on [237:26] to these lines of code. Let's check our [237:29] work so far. I'm going to quit to exit [237:31] out and clear. And let's rerun. Let's [237:34] hit next a couple of times to make the [237:36] queue empty. Now we can see we get a [237:39] message. The que is currently empty. [237:41] That's great. Now let's try adding [237:43] somebody. We added somebody back to the [237:45] queue. Now let's see what happens if we [237:47] add a blank name and song. Instead of [237:49] adding it to the list, it says, "Oops, I [237:51] need a name or a song to add someone to [237:53] the queue." So that's exactly what we're [237:55] looking for. Let's keep going with these [237:57] guard clauses. The next one is move to [238:00] top. And we need two guard clauses here. [238:03] First, we need at least two singers to [238:05] reorder the que and to warn or stop if [238:08] there are fewer than two singers. So, [238:10] I'm going to check the length of the Q [238:12] again, but this time I'm going to say if [238:15] the Q is less than or equal to 1. So, [238:19] that guards against an empty Q and a Q [238:22] with only one person in it. So if we [238:25] have zero or one people in the queue, [238:28] I'm going to print a warning and return [238:30] to exit the function. The second one [238:33] comes after we have asked for an input, [238:36] which is the position of the person they [238:38] want to move to the top. So just as a [238:40] reminder, if I were to rerun the app and [238:43] I say top and then I enter 99, then it's [238:47] going to crash out because there's [238:48] nobody at position 99. So, I need a [238:51] condition that's going to check and make [238:53] sure that the number is not out of [238:55] range. So, I have my position number [238:57] that I've got from the user. I need to [238:59] make sure that position is greater than [239:02] one. So, I'm going to say if the [239:05] position is less than one or the [239:08] position is greater than the length of [239:10] the Q, then I need to print a message [239:13] and return. So, in other words, if the [239:16] position is zero or a negative number, [239:18] or if the position is longer than the Q [239:22] itself, let's print a warning message. [239:25] There's no singer at position number. [239:28] Let's check both of these. I'm going to [239:30] hit next. So, the queue only has one [239:32] person in it. And then I'm going to [239:34] attempt to move somebody to the top. And [239:36] it's going to tell me you need at least [239:38] two singers in the queue to move someone [239:39] to the top. So, that saves the user a [239:42] little bit of time. That's great. Now, [239:44] let's add someone back to the queue and [239:46] try to move a position that doesn't [239:48] exist to the top of the queue. So, I'm [239:50] going to try 10. And instead of [239:52] crashing, we get a message that says [239:54] there's no singer at position 10. We've [239:56] addressed a big range of errors and [239:58] other things that could confuse our [240:00] user, the karaoke host. If you want to [240:03] go even further, try looking for other [240:04] gaps in the app. Here's an example. If I [240:07] try to remove someone who isn't in the [240:09] queue, that's covered. It says there's [240:11] no one named Rachel in the queue. But I [240:14] can also hit remove and then hit enter [240:16] again with the blank and it's going to [240:18] say there's no one named blank in the [240:19] queue. So that's another example of a [240:22] guard clause you could write if you're [240:23] looking for more practice. [240:30] The move to top function in the Singout [240:33] app ask the host for a position number, [240:36] but there's nothing stopping the host [240:37] from typing a word instead. I have no [240:41] problems converting some types of [240:42] strings into an integer. Let's say I [240:44] have a number and I have a string 42. I [240:48] can very easily convert that to a number [240:50] by wrapping it in int. And if I print [240:53] the number, that's going to go just [240:55] fine. But if I try to wrap a word like [240:58] banana in the int function, int's not [241:02] going to know what to do with that and [241:03] it's going to crash. So, int can convert [241:06] a number that is a string into the [241:08] Python data type number, but it can't [241:11] convert a word to a number. It raises [241:13] this value error instead. To keep the [241:16] app from crashing and give us an [241:18] opportunity to address this, we can use [241:21] what's called a try except. So, I can [241:24] say try converting this value into an [241:27] integer. And if the result is a value [241:30] error or if the exception is a value [241:33] error, then I can print something like [241:35] please enter a number. So it's going to [241:38] try converting banana to a number and if [241:40] it can't do it, it's going to fall to [241:43] this accept block and run this code [241:45] instead. And if we were running an app [241:47] like the Singout app that runs [241:49] continuously until the user quits out, [241:52] this would have caused the app to crash [241:53] and quit out. So this is a way to [241:56] prevent bad input from crashing an app. [241:59] You're almost always going to use try [242:00] except around an input. So for example, [242:03] here inside the try block, let's say I [242:06] want to prompt the user for an age. If [242:08] I'm able to successfully convert this to [242:11] an int, then I can print something like [242:14] you'll be age + 1 next year. And if I [242:18] get this value error because int can't [242:20] convert whatever the user inputs to a [242:23] number then we'll print please enter a [242:25] number. So I get how old are you? I'm [242:27] going to print 20 and it says you'll be [242:30] 21 next year. Let's try this again. And [242:33] we'll type 55. And then we get the [242:36] output. Please enter a number. So now [242:38] it's your turn to use try except with a [242:40] little challenge. You're building a sign [242:43] up for a hot dog eating contest. [242:45] entrance type how many hot dogs they [242:47] think they can eat, but nothing stops [242:48] them from typing something that isn't a [242:51] number. So, step one will be to ask the [242:54] entrant how many hot dogs they can eat [242:56] and convert that number to an int. Step [242:58] two, if the number that you get back [243:00] isn't a whole number, print I need a [243:03] number to sign you up. And step three, [243:05] if the answer is a whole number, print [243:08] signed up for however many numbers of [243:10] hot dogs. Good luck. Here's what your [243:13] output should look like. You ask how [243:15] many hot dogs can you eat? They put in a [243:17] number which is seven. You convert that [243:19] to an integer because if you'll remember [243:22] inputs always come back as strings. So [243:24] you convert that to an integer and [243:25] you're able to print signed up for seven [243:27] hot dogs. Good luck. And here's an [243:29] example of the bad output. You ask them [243:32] how many hot dogs can you eat? And they [243:34] type in something like a lot. In which [243:36] case you will print a message that says [243:38] I need a number to sign you up. Go ahead [243:40] and get started on the challenge. [243:45] First, I'm going to try prompting the [243:48] user for how many hot dogs they can eat. [243:50] I'm going to save the result to a [243:52] variable called count. If I'm successful [243:54] at getting a number, I'm going to print [243:57] a message telling them how many hot dogs [243:59] they signed up to eat. And if a value [244:02] error exception is thrown, we're going [244:04] to print I need a number to sign you up. [244:09] I'm going to comment out the previous [244:10] code and let's give this a try. Looks [244:13] like I ended up with an extra quote. So, [244:15] I'll fix that. Try this again. I'm going [244:18] to say 25. Signed up for 25 hot dogs. [244:21] Good luck. Now, let's try with a [244:23] non-number. And that's going to come [244:25] back with I need a number to sign you [244:27] up. So, this is an example of how you [244:30] can use try and accept. If this int call [244:33] fails, Python will jump straight down to [244:37] what is inside this accept block, which [244:40] allows you to determine what's going to [244:42] happen if you run across a bad value. [244:45] Instead of your user encountering a [244:47] strange error that they might have to [244:49] parse or giving them a userfriendly [244:52] message instead. [244:59] We are so close to wrapping this up and [245:01] calling the karaoke queue manager. [245:03] Finished. There's one last crash that [245:05] we're going to address. So, I'm going to [245:07] run the app. I'm going to type top to [245:10] move somebody to the top of the queue. [245:13] And let's say instead of a number, I [245:15] accidentally type Allen. Yes, that is [245:17] going to cause the app to crash. As you [245:20] can see, it says we get a value error. [245:22] Invalid literal for int with base 10. [245:25] Allen. That's a fancy way of saying I [245:28] have no idea how to convert the word [245:30] Allen into a number. I'm going to leave [245:32] fixing this up to you. Here are your [245:34] instructions. When trying to move a [245:36] singer to the top of the queue, the app [245:38] will crash if the user enters input that [245:41] can't be converted to an integer. Use [245:43] try except to handle the error. Here is [245:46] your expected output. The app asks, "Who [245:49] do you want to move to the top? Enter a [245:51] number." The user enters a word like two [245:54] that can't be converted to an integer [245:56] and the app instead of crashing will say [245:59] please enter a number. If they enter [246:01] valid input, so enter a number and they [246:03] enter the number two, it will say moved [246:06] Allen to the top of the queue. You have [246:08] already written the code that does this. [246:10] So you just need to confirm it. You [246:12] don't need to write it. I've marked [246:14] where you should validate your input [246:16] right here. So go ahead and get started. [246:22] I'm going to move this user prompt [246:25] inside of a try block. So, we're going [246:27] to try to prompt the user for a number [246:29] and convert it to an int. If we can't do [246:32] it, we're going to catch that value [246:34] error. I'll add a blank line and then [246:37] we're going to print please enter a [246:40] number. Then, we need to return out of [246:42] this function which will trigger the [246:44] command menu to show again so that they [246:47] can enter another prompt or try again. [246:49] Let's confirm that this works. So, I'm [246:52] going to type top. It says enter a [246:54] number. I'm going to put Allen. And it [246:57] says, "Please enter a number." And then [246:59] I get my Q again. And my options menu [247:02] again. Just the behavior that we're [247:03] looking for. Let's confirm that top [247:06] still works as expected. So, I want to [247:08] say move the person at position two to [247:11] the top. And that has moved Allen to the [247:14] top. Perfect. Really fantastic work. [247:17] This app is done. [247:24] Congratulations, you've built Sing Out, [247:27] a complete karaoke queue manager. The [247:30] host can add singers, call the next [247:32] singer up, move a singer to the top of [247:34] the queue, and remove people from the [247:36] queue. You've also made it robust. [247:38] Rather than crashing on user input that [247:40] it doesn't expect, your app gives the [247:43] user an informative message and keeps [247:45] running. You've covered a lot to get [247:47] here. You plan the app before writing [247:49] it, naming the tasks, stubbing out the [247:51] functions, and documenting using dock [247:53] strings. You practice separation of [247:55] concerns by keeping each task in its own [247:58] function. You wrote functions that take [248:00] arguments and return values, looped over [248:02] lists of tpples, and used append, [248:04] remove, pop, and insert to manage the [248:06] queue. You combine conditions with [248:08] logical operators, and you harden every [248:10] function with guard clauses and try [248:13] except. Absolutely amazing work you did [248:16] here. And you can still go further with [248:18] this. For example, you could add a clear [248:20] command that empties the queue or a [248:22] swapped command that trades two singers [248:25] position rather than just moving them to [248:27] the top. This is a big stop on your [248:29] Python journey, so you should be very [248:31] proud. I'll see you in the next one and [248:33] happy coding.