Python - Lecture 2 - CS50's Web Programming with Python and JavaScript 2020

Video Statistics and Information

Video
Captions Word Cloud
Reddit Comments
Captions
[MUSIC PLAYING] BRIAN YU: All right, welcome back, everyone, to Web Programming with Python and JavaScript. And today, we take a look at one of the two main languages we're going to be looking at in this course. In particular, we're going to be looking at Python. Python is a very powerful language that makes it very easy to build applications quickly because there are a lot of features that are built into the language that just make it convenient for quick and productive development. So one of the goals of today is to introduce you to the Python programming language if you haven't seen it before. And even if you have seen it before, to give you a taste for what the language has to offer, exploring some of the more advanced features in some of the techniques we can use using Python to be able to develop applications all the more effectively. So we begin with our very first Python program, just a program that says, "hello, world." We're going to be writing it in a text file. And the program just looks like a single line, just like this. And if you've used other programming languages before, like C, or Java, or other languages, this probably looks pretty familiar syntax-wise. But just to break it down, we have a function called Print built into the Python programming language for us. And like many other programming languages, functions in Python take their arguments inside of parentheses. So inside of these parentheses are the argument, or the input, to the Print function, which in this case is just the words, "hello, world" followed by an exclamation point. So here's how we can actually take this program and run it. I'm going to go into my text editor and create a new file that I'll call hello.py. dot-py or dot-py is the conventional extension for Python programs. So I create a file called hello.pi inside of which will just be the Python code that we just saw a moment ago. We'll call the Print function. And as an argument, or the input, to the Print function, I'll say, "hello, world" exclamation point. Now in order to run this program, we're going to use a program in our terminal that also just so happens to be called Python. Python is what you might call an interpreted language, meaning we're going to run a program called Python, which is an interpreter that is going to read our .py file line by line, executing each line and interpreting what it is that it means in a way that the computer can actually understand. So we'll run Python followed by the name of the program that we'd like to interpret, in this case hello.py. And when we run this program, we see that the words "hello, world" are printed to the terminal. And that's it. That's the end of the program. And that's the very first program that we've written using the Python programming language. So now already we've seen a couple of features of Python. The ability to interpret Python-- there's no need to compile it into a binary first in order to run a Python program. We've seen functions. And we've also seen strings, just text that we can provide in quotation marks that we can provide as input to other functions or manipulate in other ways. And we'll see some examples of a string manipulation a little bit later. Like many other programming languages, Python also supports variables. And in order to assign a new value to a variable, the syntax looks a little something like this. If I have a line like a equals 28, what that's going to mean is take the value 28 and assign it, store it inside of this variable called a. Now, unlike other languages like C or Java which you might be familiar with, where you have to specify the type of every variable you create-- you have to say, like, int a to mean a is an integer. Python doesn't require you to tell you what the types of each of these variables actually are. So we can just say a equals 28 and Python knows that because this number is an int, that it's going to represent the variable a as an int, that it knows, it's able to infer, what the types of any these values happen to be. So all the values do indeed have types. You just don't explicitly need to state them. So for example, this here, the number 28, is a type int. It's an integer. A number like 1.5 has a decimal in it. It's a floating point number. So that, in Python, is what we might call a float type. Any type of text, something like the word "hello" wrapped in either double quotation marks or single quotation marks-- Python supports both-- is what we would call the str type, short for string. We also have a type for Boolean values, things that can be either true or false. In Python, those are represented using a capital T, true, and a capital F, false. Those are of type bool. And also, we have a special type in Python called the none type, which only has one possible value, this capital N, none. And none as a value we'll use whenever we want to represent the lack of a value somewhere. So if we have a function that is not returning anything, it is really returning none, effectively. And so you might imagine that none can be useful if ever you want a variable to represent the absence of something, for example. So lots of different possible types, and there are more types than just this. But here's a sampling of the possible variables and types that might exist inside of this language. So now let's try and actually use a variable in order to do something a little bit more interesting inside of our program. And we'll write a program that's able to take input from the user in order to say hello to them, for example. So I'll create a new file. We'll call it name.py. And to start, I'd like to prompt the user for input. I'd like to prompt the user to, for example, type in their name. So how might we do that? Well, just as there is a Print function that is built into Python that just prints out whatever the argument happens to be, Python also has a built in function called Input that prompts the user for input and asks them just type in some input. So let's provide some input and ask the user to type in their name, for example. And then we can save the result, the output of that function inside of a variable. And in this case, I'll save it inside of a variable that in this case also just happens to be called Name. Now we can run the program. I can run the program by going into my terminal and typing Python name.py. I'll press Return. And we'll see the program prompts me to type in my name. I see name colon space, which is that string I provided as the argument to the input function. And this now prompts me to type in my name, so I will. And after that, nothing seems to happen so far. So now I'd like to do something with that input. I typed in my name. I'd like to say, like, hello, for example to myself. So I'll go back into this program. And now what I can do is I can say print hello comma. And then I can say plus name. This plus operator in Python does a number of different things. If I have two numbers, it'll add those two numbers together. But with two strings, plus can actually concatenate, or combine, two strings together. So I can combine hello comma space with whatever the value of name happens to be. So now I'll rerun this program. Python name.py. Type in my name. And now we see "hello, Brian" as the output of the program. So this is one way that you can manipulate strings in Python. Another way that's quite popular in later versions of Python 3 is a method known as using f strings, short for formatted strings. And in order to use f strings in Python, it's going to be a similar but slightly different syntax. Instead of just having a string in double quotation marks, we'll put the letter f before the string. And inside of the string, I can now say hello comma-- and then if in a formatted string, if I want to plug in the value of a variable, I can do so by specifying it in curly braces. So what I'll say here is, inside of curly braces, name. And so what's going on here is I am telling this formatted string to substitute right here the value of a variable. So I prompted the user for input to type in their name. We took their name, saved it inside of this variable called name. And now here in this print statement on line two, I'm printing out a formatted string that is hello comma. And then in curly braces here, I'm saying plug in the value of the variable name. And so that is going to have the effect of taking whatever name was provided as input and printing it out. And this is a slightly more efficient way of being able to quickly create strings by plugging in values into those strings. So now I'll see the exact same behavior if I run Python name.py and prompt it to type in my name. I'm like, Brian. And then I see the result, "hello, Brian" for example. And so those are a couple of ways that we can deal with strings, manipulating strings, and combining strings using this technique. So in addition to variables, Python also supports all of the same other features that are core to many procedural programming languages, such as conditions, for example. So let's take a look at an example now of seeing whether a number is positive, or negative, or zero, for example. So I'll create a new file that I'll call conditions.py. And inside of conditions.py, I'll first prompt the user to type in some input. I'll say input number to mean type in a number. And we'll save that input inside of a variable that I'm just going to call n. And now I can ask questions. I can say something like if n is greater than zero. Then print n is positive. And so what's going on here is I have a Python condition. And the way a Python condition works is it begins with this keyword, a keyword like if, followed by a Boolean expression, some expression that's going to evaluate to true, or false, or something kind of like true or false. We can be a little bit loose about that, as we may see later. And then a colon means, all right, here is the beginning of the body of the if statement. And in Python, the way we know that we're inside the body of an if statement or inside the body of any other block of code is via indentation. So in some languages, like C, or in languages like HTML, which we saw a couple of lectures ago, the indentation isn't strictly required by the computer to be able to parse and understand what's inside the program. In Python, it's different. The indentation is required because the indentation is how the program knows what code is inside of the if statement and what code is outside of the if statement. So we have if n is greater than zero colon. And then everything indented underneath the if, is all of the body of the if statement. It is the lines of code that will execute if this condition, this Boolean expression and greater than zero, happens to be true. So if end is greater than zero, will print out n is positive. And then we can add an additional condition. I can say something like-- well, I could say something like else print n is not positive. But I can be a little bit more specific than that. Here is a sort of two branches. One if n is greater than 0, and one else case to handle all of the other possible scenarios. But really, what I'd like to do is perform a second check. In other languages, this might be called an else-if. Like, if this condition is not true but this other condition is true. Python abbreviated this to just elif-- E-L-I-F, just short for else-if. So I can say elif n is less than zero, then let's go ahead and print out n is negative, and else print n is zero, So the idea here now is that if n is greater than zero, we perform some task elif-- in other words, if it's not greater than zero-- then we check to see if it is less than zero. In which case, we print out that n as negative. Else, if neither of those two conditions are true, it's not positive and it's not negative, the only remaining possibility is that n is zero. So we can print out that n zero. And so we might like for this program to work. But watch what happens if I now try and run conditions.py. Even though logically in our heads and looking at it now, it probably seems pretty logical, if I run Python conditions.py and type in a number-- I'll type in the number five, for example, just see what happens. All right, something weird just happened. And this is our very first Python exception, an error that happens because something didn't quite go right inside of our Python program. And over time, you'll begin to learn how to parse this exception, and understand what it means, and where to begin to debug. But learning how to read these exceptions and figure out how to deal with them is definitely a very valuable skill on your way to becoming a Python developer. And so let's see if we can figure out what this exception to saying. Oftentimes, I start by looking at the bottom. I see that there is a type error. That is the type of the exception that has happened. There are a lot of exceptions that can go wrong in Python, things that we can do that cause errors. In this case, it's a type error, which generally means that there's some mismatch of types, that Python expected something to be of one type but it turned out to be a different type. So let's try and understand what this might be. It says greater than sine, not supported between instances of stir, short for string, and int. So what does that mean? Well, I guess it means that the greater than symbol that checks if one thing is greater than another doesn't work if you're comparing a string to an integer. And that's probably pretty reasonable. It doesn't really make sense to say a string is greater than or less than an integer. When we're talking about greater than or less than, usually we're talking about numbers. So they should both be integers, for example. So why do we think that greater than is comparing a string and an integer? Well, now we can look a little bit further up at the trace-back, which will show which parts of the code are really causing this problem. And in this case, the trace-back is pretty short. It's just pointing me to a single line of a single file. It's saying in the file conditions.py on line three, here is the line that triggered the exception-- if n is greater than zero. So, what's the exception here? Well, zero is obviously an integer because that just is an integer. And so if greater than thinks that it's comparing a string with an integer, then n somehow must be a string. Even though I typed in the number five, it must still think n is a string. So why might that be? Let's take a look at the code again and see if we can figure out what's going on. Well, it seems that this input function doesn't care what you type in. It's always going to give you back a string. n somehow is ending up as a string, which is pretty reasonable because the input function has no idea whether I typed in a number, or whether I typed in a letter, or I typed in other characters altogether. So input doesn't know to give back its data in the form of an int, or in the form of a float, or in any other form. So by default, it's just going to return a string. What characters did the user type in as their input? So what I'd like to do now, in order to make this program work the way I want it to, is take this and convert it into an integer, or cast it into an integer, so to speak. And the way that I can do that is by using a function in Python called int, that takes anything and turns it into an integer. So here, I can say int-- and then as the argument to the int function, the input to the int function, I'm just going to include this whole expression, input number. So I'm going to ask the user to input a number. They type in some text. The input function gives me back a string. And that string is going to serve as the input to the int function, which then gets saved inside of this variable called n. So now that we know that n is indeed an integer, let's try and run this program again. I'll go back into the terminal, run Python, conditions.py, I'm asked to type in a number. I type in a number like five. And all right, that still doesn't seem to have worked. And it didn't work because I didn't save the file. So I'll go ahead and save the file, try it again, type in a number. And now we see that indeed, n is positive. We get no more exception. We were able to run the code successfully and see that the value of n is positive. And I could try this again to test the other conditional branches. Type in negative one for example to see that n is negative. And otherwise if it isn't either positive or negative, then we know that n is zero. And so here was our first exposure to conditions in Python, the ability to have multiple different branches and do different code depending on some expression that we're going to evaluate to either be a true expression or a false expression. All right, so let's take a look at some of the other features that are going to be present inside the Python language. And one of the most powerful features of Python are its various different types of sequences, data types that store values in some sort of sequence or some collection of values altogether. So I go ahead and create a new file that we'll call sequences.py. And there are a number of different types of sequences that all obey similar properties. But one of the types of sequences is the type we've already seen, which is just a string, for example. So if I have a name, and the name is something like Harry, for instance, and this sequence allows me to access individual elements inside of the sequence. And in order to do so, it's much like an array in other languages, if you've experienced them before. But I can print out name square bracket zero. This square bracket notation takes a sequence, some ordered sequence of elements, and gets me access to one particular element inside of that sequence. And so if I have a string-like name and I say name square bracket zero, the effect of that is going to be take this long sequence and get me the zero-th element. In many programming languages and in programming more generally, we often start counting things at zero. So the very first item in the sequence is item zero, the second item is item one. So it's easy to get slight off by one errors there. But just know that item zero of the name should be the first character in the name. And I can see that for sure, if I run Python-- I'll save this file, run Python sequences.py. And what I get is just the first character of Harry's name, which in this case is the letter H. If I instead asked to print out character one, which would be the second character in the name, if we run the program, now I get the letter a. And this type of indexing works for many different types of sequences, not just a string, which so happens to be a sequence of characters, but other types as well. Python, for example, has a type for lists of data. So if I have a sequence of any type of data that I want to store, I can store that information inside of a list in Python. So maybe instead of storing one name, I have multiple names that I want to store. So I want to store names like Harry, and Ron, and Hermione, for example. So now I have three names all stored in the sequence inside of a Python list. And I can-- you know, I can print out all of the names, for example, just to print out all of the names to see what the value of the variable names is equal to. And we'll see that when I do that, I get a printout of the contents of that list. Harry, Ron, Hermione, in that particular order. But you could also, much as you could index into a string, index into a list to say get me just the very first item inside of this names list, which in this case, when I run the program, is going to just be Harry. So there are a number of different sequence types that you can use in order to represent data. Another one just so happens to be called a tuple. And a tuple is often used if you have a couple of values that aren't going to change but you need to store a pair of values like two values together, or three values together, or something like it. You might imagine that if were writing a program to deal with graphing in two dimensions, for example, you might want to represent a point as an x value and a y value. And you could create two variables for it. I could say, you know, let me do, say, a coordinate x is going to be equal to 10.0. And coordinate y is equal to 20.0. But now I'm creating two variables for what's really one unit that just so happens to have two parts. And so to represent this, we can use a tuple in Python, and just say something like coordinate equals 10.0 comma 20.0. So whereas in lists we use square brackets to denote where the list begins and where the list ends, in a tuple, we just use parentheses to say we're grouping a number of values together, we're grouping one value, 10.0, with a second value, 20.0. And now we can pass around these two values as a single unit just by referencing them using the single name, which in this case is coordinate. So there are a number of different types of these various different sequences. And some of those sequences we'll take a look at are these data structures here. So list, for example, is a sequence of mutable values, which we took a look at. And mutable, just meaning we can change the elements in the list. If I have a list, I can add something to the end of the list, I can delete something from the list, I can modify the values inside the list. A tuple, on the other hand, is a sequence of immutable values those values can't change you can't add another element to the existing tuple. You'd have to create a new tuple in order to do so. And there are other data structures that exist as well. A couple that we'll take a look at in a moment include sets, which are a collection of unique values. So if you're familiar with sets from the world of mathematics, it's a very similar idea, that whereas a list in a tuple keeps things in a particular order, a set does not keep things in any particular order. It's just a collection. And in particular, all of the values need to be unique. In a list or in a tuple, you might have the same value appearing multiple times. And in a set, every value appears exactly once. And there are some advantages to sets, some ways that you can make your programs more efficient by using sets if you know that you just need a collection, if you don't care about the order, if something is only going to show up exactly once at most, then you can use a set to potentially make your programs a little more efficient and a little more elegantly designed. And finally, one other data structure that's quite powerful and that's going to come up a number of times during this course is a dictionary. In Python, shortened to just a dict, which is the collection of what we're going to call key-value pairs. And the way I like to think of this as with an actual physical dictionary that you might find in the library that maps words to their definitions. In a physical dictionary, you open up the dictionary and you look up a word and you get the definition. And a dict in Python is going to be very similar. It's going to be a data structure where I can look something up by one keyword or one value and get some other value as a result. We call the thing that I'm looking up the key. And we call what I get when I do the looking up the value. So we keep pairs of keys and values. In the case of an actual dictionary in the real world, the key is the word that we want to look up and the value is its definition. But we can use this more generally in Python anytime we want to map something to some other value such that we can very easily look up that value inside of this data structure. So we'll see examples of dictionaries as well. So let's now explore the first of these data structures, these lists, to explore what we can do by taking advantage of the features that are given to us by a Python list, for example. So we'll go ahead and create a new program that I'll call lists.py. And here, I'm just going to create a list of names. So names equals Harry, Ron, Hermione, and Ginny, for example. And as I start to write multiple lines of code, especially as my Python programs start getting longer, it can be a good idea to document what it is that I'm doing. So I can say, let me add a comment to this particular line of code just so I know what it is that I've done in this line of code. And in Python, there are a couple of different ways to create a comment. But the simplest way is just to use the pound sign or the hashtag. As soon as you include that, everything after that for the remainder of the line is a comment. The interpreter is going to ignore that comment. You can say whatever you want. It's more for you, the programmer and for someone who's reading your program to be able to look at the program, understand what it's saying, and figure out what they need to do about it. So I can just say, define a list of names, for example, just to make it clear to me what it is that I have done inside of this line of code. So I can print out that list of names, as we've done before. And we'll see that when I print out that list of names, what I get is-- oh, let me run list.py. What I get is this list-- Harry, Ron, Hermione, and Ginny. But I could also print out, as we've seen before, just the first of those names. Say, you know, print out just names square bracket zero, in which case I'm going to get just Harry, for example. But now, recall that a list is mutable. I can modify the elements that happen to exist inside of this list. So I could say names.apped a new name, something like Draco, for example. And so lists have a number of built in methods or functions which are functions that I can run on an existing list to access particular elements of the list or to modify the list in particular ways. And in the case of a list, the append method is a method or function that I can run that just adds a value to the end of an existing list. So I've added Draco to the list. And there are a number of other methods that I can use on lists, one of which is, for example, sorting a list. No need to write your own sorting algorithm in order to sort a sequence of objects. In Python, there is a built-in sort method that works on lists where I can just say names.sort. That will automatically sort everything in the list. And now if I print out all of those names-- go to print them out and get rid of this old print statement-- now we see that we get five names that are printed out because I had four elements originally in this list but then I added a fifth one. And notice now that they are actually in alphabetical order, starting with Draco, ending with Ron because I was able to sort the list by modifying the order in which those elements actually show up. And so list can definitely quite powerful anytime you need to store elements in order, a list is definitely a useful tool that Python gives to you. If you don't care about the order of the elements though, and if you know that all the elements are going to be unique, then you can use a set, which is another Python data structure that works in similar ways. The syntax is slightly different. So let's do an example with those. I'll create a new file, call it sets.py. And let me first create an empty set. And we can do that by just saying s equals-- s is going to be the variable that will store my set. And I'll say set and then parentheses. That will just create an empty set that just so happens to have nothing inside of it now we'll add some elements to the set so I can say s.add. Let's add the number one to the set. Let's add the number two. Let's add that number three. And let's add the number four. And then we can print out the set to see what happens to be inside the set right now. Now when I run this program, Python sets.py, we see that inside the set are four values, one, two, three, and four. They happen to be in order. But sets are not naturally ordered. They're not going to always keep track of what the order is going to be. But I can add-- for example, if I add three again to the set, now I've added three to the set twice. I added one, two, three, four, and then three again. When I print out the contents of the set, it still just contains the elements one, two, three, four. No element ever appears twice in the set, following with the mathematical definition of a set where no element ever appears more than once inside of a set. You can also remove elements from sets as well. So if I wanted to remove the number two from the set for example, I could say s.remove2 and then print out s to say print out whatever happens to be inside of that set now. And now when I rerun this program, I only get one, three, and four because I removed two from the set. So sets allow you to add to them, remove from them. And also, all sequences, whether they be strings, or lists, or sets, allow you to get how many elements are in the set by taking advantage of a function built into Python called len. So len we'll give you the length of a sequence, so the number of items inside of a list, or the number of characters inside of a string, or the number of elements inside of a set. And so, if I wanted to print out how many elements are in the set, I might do something like this. In a formatted string, say the set has some number of elements. And how do I know how many elements? Well, again, inside of these curly braces, I can include any expression in Python that I would like to substitute into this string. So how many elements are in the set? I can get that by calculating len of s. So what I've done here is I've said with len of s, I would like to calculate the length of the set, s, in other words, how many elements are actually inside of that set. And then using this curly brace notation, I'm saying, take that number and plug it into this string so we can see the set has some number of elements, for example. So now if I run this program, Python sets.py, I see that I get these three elements that happen to be inside of the set right now, which is one, and then three, and then four. And then it tells me that the set has three elements inside of it, which is the number of elements that are in the set right now. So now we've seen a number of different language features inside of Python. We've seen variables. We've seen conditions so that we can conditionally do things-- if something is true, if something else is true. And we've seen some of the data structures that are core to the way Python works-- lists, and sets, and tuples, and other data structures that can be helpful too. And now let's take a look at another feature of the Python programming language common to many programming languages, the idea of looping. If I want to be able to do something multiple times, I'll go ahead and create a new file called loops.py. And let's just create a simple loop. The simplest loop we could create in Python is just one that's going to count a bunch of numbers. So in order to do that, what I could say is something like this. For i in one, two, three, four, five-- or maybe I want to count zero, one, two, three, four, five, just to start counting at zero-- print i. And so here's the basic syntax for a Python loop. And here's what seems to be going on. Over here on the very first line, I have a Python list as denoted by those square brackets that contains six numbers-- zero, one, two, three, four, five. And now I have a for loop-- for i in this list. And the way Python interprets this is to say, go through this list one element to the time. And for each element, call that element i. You could've called it anything. But in this case, i is just a conventional choice for a number that keeps incrementing. And we're going to print out now the value of i for each iteration of this loop. So we try this out now and run Python loops.py. We see zero, one, two, three, four, five. Great, it printed out all of the numbers from zero to five one at a time. In practice though, if we wanted to count all the way up to five or print six numbers for example, this is fine for now. But if we wanted to print like 100 numbers or 1,000 numbers, this is going to start to get tedious. So Python has a built-in function called range where I can say for i in range six to achieve exactly the same thing. Range six means get me a range of six numbers. So if we start at zero, it's going to go from zero all the way up to five. And then we can print out each one of the elements inside of that sequence. So if I rerun in Python loops.py, we get zero, one, two, three, four, five. So loops enable us to loop over any type of sequence. So if the sequence is a list, I can say something like, if I have a list of names like Harry, and Ron, and Hermione, and this is my list of names, I can have a loop that says that for each name in my list of names, let's print out that name, for example. So we have a list. The list is called Names. We're looping over it one element at a time and printing it out. Now if I run the program, I see three names printed one on each line. And you can do this for other sequences as well. Maybe I have just a single name that is called Harry. And now I can have a line that says, you know, for every character in that name, print the character. If the name is the sequence, is a sequence of individual characters because it's a string, then when I loop over to that string, I'll be looping over each individual character in that string. So I can run the program and see one on each line, each of the letters that just so happens to be inside of Harry's name. So now we've seen conditions. We've seen loops. And we've seen a number of different data structures. We've seen lists, and sets, as well as tuples. The last important data structure that we're going to be taking a look at are Python dictionaries which, as you'll recall, are some mapping of keys to values. If I want to be able to look something up, I can use a Python dictionary just as a data structure to be able to store these sorts of values. So I'll create a new file called dictionaries.py. And maybe I want to create a dictionary that is going to keep track of, say, what house each of the students at Hogwarts happen to be in. So I might have a dictionary called Houses. And the way we specify a dictionary is by specifying a key colon of value when we're defining a dictionary for the first time. So I might say Harry colon Gryffindor and then Draco colon Slytherin, for example. And so what this line of code is doing is it is creating a new dictionary. This dictionary is called Houses. And inside this dictionary, I have two keys, two things that I can look up. I can look up Harry or I can look up Draco. And when I look up those keys, I get the value that follows their colon. So after Harry, if I look up Harry, I get Gryffindor If I look up Draco, I get Slytherin, for example. So now if I wanted to print out what house Harry is in, I can print out houses square brackets Harry. So I can here, say, I would like to print out-- take the Houses dictionary. And the square bracket notation is how I look something up inside of a dictionary. It's similar to how we use square brackets to look up a specific element inside of a list to say, like, get me element zero or element one. In this case, we're using a Python dictionary to say, take the Houses dictionary and look up Harry's value, which hopefully should be Gryffindor. And we'll see that if we look up run Python dictionaries.py, we do get Gryffindor as the value of Harry's house. We can add things to this dictionary as well using the same syntax. In the same way that I use square brackets to access the value inside of a dictionary, if I want to change the value in a dictionary or add something new to it, I could say houses and Hermione, and say that Hermione is also in Gryffindor, for example. And so this line of code here says take the Houses dictionary and look up Hermione in the Houses dictionary. And when you do, that should be set equal to this value here, Gryffindor. So we took that value and we are going to assign it to Hermione inside of the dictionary, such that now if we wanted to, we could print out Hermione's house as well, run the program, and see that Hermione is also in Gryffindor. So anytime we want to be able to map some value to some other volume, whether we're mapping people to what house they happen to be in or we're mapping users to some information about those users inside of our web application, dictionaries are going to be very, very powerful tools for us to be able to do that. The next Python language feature we'll take a look at are functions in Python that are going to be some way for us to write our own functions that take an input and produce some output. We've already seen a number of different functions that already exist in Python. We've seen the input function that takes an input from the user. We've seen the print function that takes some text or some other information and prints it to the screen. But if we want to define our own functions, we can do so as well. So here I'll go ahead and write a new program called functions.py. And let's write a function that takes a number and squares it. So the square of 10 is 10 times 10, or 100. I would like a function that very easily takes a number and returns its square. The way I define a function in Python is using the def keyword. Def, short for define. And here I can say, let me define a function called square and then, in parentheses, what inputs it takes. In this case, square just takes a single input that I'm going to call x. But if there were multiple inputs, I could separate them with commas, like x, y, z for a function that took three inputs, for example. But in this case, there is just a single input, x. And the square function could have any logic in it indented underneath the square function. But ultimately, this function is fairly simple. All it's going to do is return x times x, x multiplied by itself. And now, if I want to print out a whole bunch of squares of numbers, I can do so. I can say for i in range, let's say, 10, let's print out that the square of i is square i. So let's try and parse out what's going on here. Line four says for i in range 10, do some loop 10 times, looping from zero all the way up to nine. And for each time we loop, we're going to print something out. We're going to print out the square of-- plug in the value of i here-- is-- plug in the value of calling our square function using i as input. So that is going to have the result of running this loop 10 times and printing out this line 10 different times, each with a different value of i. So I can run Python functions.py. And here's what I see. The square of zero is zero. Square of one is one two is four, so on and so forth, all the way up to the square of 9 is 81. So we've now written a function and been able to use it. But ideally, when we write functions, we'd like to not just be able to use them in the same file, but for others to be able to use them as well. And so how can we do that? Well, in order to do that, you can import functions from other Python modules or files, so to speak. So let me create a new file called squares.py, for example. So that instead of running this loop here, let's instead run this loop in squares.py, again, separating out different parts of my code. I have one file that defines the square function inside of functions.py and then another file called squares.py, where I'm actually calling the square function. Now if I try to run Python squares.py, you'll notice I'll run into an error. Here's another error you'll see quite frequently. It's a name error, another type of exception. Which here says the name square is not defined, meaning I'm trying to use a variable, or a function name, or something else that doesn't actually have a definition. I've never said what square is. And that's because by default, Python files don't know about each other. If I want to use a function that was defined inside of another file, I need to import it from that file. And I can do so like so. I can say, from functions import square. Functions was the name of this file, functions.py. And I'm saying from that Python module, I would like to import the square function as a function that I would like to use. Now I can run Python squares.py. And we get the output that we expect-- no more exception. I've now been able to import something from another module and access it this way. So this is one way to import, to literally say from functions import a square function, import a particular name that is defined inside of functions.py. Another way I could have done this is just to say import functions, just import that whole module. But then I would need to say-- instead of just square, I would need to say functions.square, to mean go inside the functions module, and get the square function, and run that function. And this would operate in exactly the same way. So, a couple of different options-- I either import the entire module, in which case I use this dot notation to, say, access a particular part of that module. Or I say from functions import square to just import the name square into this file entirely so that I can just use the word square whenever I want to. And this works not just for modules that we have written, but also Python comes with the number of built-in modules. If you want to write programs that interact with CSV files, which are a spreadsheet file format, I can import Python's built-in CSV module to get access to a whole bunch of CSV-related features. There are a whole bunch of math-related features you can get by importing the math module, so on and so forth. And there are additional Python modules and packages that you can install that other people have written. And then you just import them when the time comes. And next time, as we take a look at Django, this is one of the techniques that we're going to be looking at, is using functions that have been written by people that are not ourselves. So that now is modules and how we can use modules to be able to import functions in order to allow for certain behavior. And this is one way that we can program using the Python programming language. But another key technique that Python supports that are supported by a number of other programming languages as well is an idea of object-oriented programming, a special type of programming or programming paradigm, so to speak, which is a way of thinking about the way that we write programs. In an object-oriented programming, we think about the world in terms of objects where objects might store information, store some data inside of them, and also support the ability to perform types of operations, some sort of actions, or methods, or functions, as we might call them, that can operate on those objects. So now we're going to take a look at some of the object-oriented capacities that the Python programming language is going to give us the ability to have. So, Python comes with a number of built in types. It has types for lists. It has types for sets and so on and so forth. Let's imagine, though, that we want to create a new type in Python, some way of representing other types of data. For example, two-dimensional points, things we've talked about before-- something that has an x value and a y value. Now, as we've already discussed, you could do this using a tuple, just using one number comma another number. But we could create an entire class of objects to be able to represent this data structure as well. And so that's what we'll take a look at now, is how to create a class in Python. So I'll create a new file called classes.py. And all a class is, is you can think of a class as a template for a type of object. We are going to define a new class called Point. And then after we've defined what a point is, we will be able to create other points. We'll be able to create points to store x and y values, for example. And so what do we need in order to create a class? Well, we need some way to say that when I create a point, what should happen? And in Python, this is defined using what's called a magic method called underscore underscore init. And underscore underscore init is a method or function that is going to automatically be called every time that I try to create a new point. And this function takes a couple of arguments. All functions that operate on objects themselves, otherwise known as methods, are going to take the first argument called self. And this argument self represents the object in question. And this is going to be important because we don't just want a single variable called x to store the points x coordinate or a single variable called y to store the y coordinate because two different points might have different x and different y values. And we want to be able to store those separately. And we're going to store them inside of the object itself. So this variable self references the object that we are currently dealing with. And it might change depending on which point we happen to be interacting with at any given time. What other inputs does a point need? Well, a point also needs an x value and a y value. So when we create a point, we're going to provide to that point an x value and a y value. Now, what do we need to do in order to store all this data inside of the point? Well, recall that self is representing the point itself. And so if we want to store data inside of that point and allow that point to store its own x and y values, then we need to store that data inside of the self, so to speak. And in order to do that, we can use this dot notation to say self.x is equal to whatever this input x happens to be. And self.y is equal to whatever this argument y happens to be. And these values, x and y, they can be called anything. They could just be called like input one and input two, for example. And then you would just reflect them here. The important thing is that these two input values are being stored inside of the point itself in properties that we're going to call x and y. All right, so that was a little bit abstract. But now let's see how we could actually use this. If I want to create a new point called p, I can say p equals point. And then the self argument is going to be provided automatically. I don't need to worry about that. But I do need to provide input one and input two-- the x value and the y value. So I'll go ahead and provide an x value of two and a y value of eight, for example. So now I've created this point. And now that I have a point, I can print out information about the point. I can print out the x value of the point. And I can print out the y value of the point. Again, I'm using this dot notation to say, go into the point and access data that is stored inside of that point. Access its x value and access its y value. So now when I run this program, Python classes.py, what I get is two on the first line, that is the x value, and then eight on the second-- or eight on the second line. That is the y value. So what we have here is a function called init that creates a point by storing the two inputs inside of the object, inside of a property called x and a property called y, such that later I can create a point which calls this init function implicitly. And after we've created the point, I can access the data inside of it. I can say print out whatever p.x is equal to, print out whatever p.y is equal to as well. So that was a fairly simple example of creating a class, just creating a class for representing a point, an x and a y value. Let's look at a more interesting example. Let's imagine that we're trying to write a program for an airline where the airline needs to keep track of booking passengers on a flight and making sure that no flight gets overbooked. We don't want more passengers on the flight than there is capacity on that flight. So let's define a new class that we're going to call flight. And this time, the init method is just going to take a single argument other than the self, which is the capacity. Every flight needs some sort of capacity to know how many people can fit on the plane. And so I'll store that inside of a value called self.capacity equals capacity. And what other information do we need to store about a flight? Well, a flight has a capacity. And it also has all of the passengers on the flight. And so we could represent this in a number of ways. But we know that lists can be used in order to store a sequence of values. So we'll go ahead and just create a list that will store in self.passengers that is going to be equal to the empty list. So we start out with an empty list of passengers. So now if I want to create a flight, I can say flight equals and then Flight, that's the name of the class, and then provide a capacity. I can say capacity of three to mean three people can go in this flight, but no more than three. That is the capacity because that is the argument that is specified inside of this init function. And when I do so, I'm automatically going to get this empty list of passengers. So now let's think about what methods, or what functions, we might care about performing when it comes to a flight. So one reasonable function to add would be a function that says, all right, let's add a passenger to the flight if I want someone new to go on the flight. So how might it go about doing that? Well, let's define a new method, also known as a function, to this flight class called Add Passenger. This method can be called whatever we want. Because this is a method that's going to work on an individual object, we need some way of referencing that object itself. So we'll use the keyword self again. And when we add a passenger, we need to add a passenger by their name. So I need to specify their name as well, such that now here, I want to add that name to the passengers list. How do I get access to the passengers list? Well, I have access to the self, the object of itself. And I store the passengers inside of self, in self.passenger, an attribute of this object. And self.passenger is a list that initially starts out as an empty list. But if I want to add something to the end of the list, we've already seen that in order to do that, I can say self-passengers.append name. So that adds in someone new to the end of this passengers list. Now, what could potentially go wrong here? Well, every time we call this Add Passenger function, what's going to happen is we are going to append to the end of this passengers list this name. But we haven't taken into consideration the capacity of the flight. Ideally, our Add Passengers function shouldn't let someone be added to a flight if the flight is already at capacity. So there are a number of things we could do here. We could just check it inside of this function. But just for good measure, let's create a new function. Let's add a new function called Open Seats that is going to return the number of open seats that are on the plane. Other than Self, there are no other inputs that we need to calculate how many open seats there are. The only thing we need to know in order to calculate open seats is we need to know the capacity minus however many passengers there are. Remember, self.passengers is our list of all the passengers. And any time we have a sequence to get the length of that sequence, I can say len, or length of that sequence, to say get me the number of passengers that there are. So now we have this function called Open Seats, which will return capacity minus the number of passengers and tell us how many open seats there are. And now in this Add Passenger function, I can add some additional logic. I can say if not self.open_seats. So this is equivalent to me saying in this case, like, if self.open_seats equals equals zero, meaning there are no open seats, a more Pythonic way, so to speak, of expressing this idea is just saying if not self.open_seats. In other words, if there aren't any more open seats, then what should we do? We should return. And maybe you might imagine this Add Passenger function returns true if it was able to successfully add a passenger and false otherwise. So in this case, I can return false to say, you know what? There aren't enough open seats. Let me return false from the function to indicate that there was some sort of error. But otherwise, if there are open seats, we can add the passenger and return true to mean that everything was OK, we were able to add the passenger successfully. So now we have these three functions-- Init that creates a new flight, Add Passenger that adds a new passenger to that flight, and Open Seats, which tells us how many open seats there are. And now let's use those functions to actually add some passengers to this flight. Let me get a list of people. We'll say Harry, Ron, Hermione, and Ginny. And now let me loop over all of those people. For every person in that list of people, let's try to flight.add_passenger person. And we can save the result in a variable called success, for example. And then I can say if success, well, then let's print out that we added the person to flight successfully. But else, otherwise, let's print out no available seats for that person. So what's going on here? We have a list of people, four people. And for each of those people, we're going to try and add the passenger to the flight calling flight.add_passenger, calling this method, passing, as input, the person's name, and save the result true or false in this variable called Success. If success is true, we print out we've added them successfully. Otherwise, we print out there are no available seats for that person. So now we can try running this program. I'll run Python classes.py. And now we see we've added Harry, Ron, and Hermione to the flight successfully. But the flight had a capacity of three, which means there are no available seats for Ginny, which we get as the error message on the fourth line. But if you're really trying to optimize, you might notice you don't really need this variable. I could just take this entire expression, flight.add_passenger person, and put it in the condition itself. I can say, try and add a passenger. Add passenger will return true or false. And if it returns true, that means it was a success. And then I can print out that we've added the person to the flight successfully. So that is a brief look at object-oriented programming, this technique within Python and other programming languages to represent objects like this particular flight and then to manipulate those objects using methods like the Add Passenger method that takes a flight and adds people to it, at least as long as there is available capacity on that flight. It's one of the many powerful features of Python that we'll be definitely taking a look at later in the term and using as we go about building these web applications. Now, there are a couple of final examples that are just worth taking a look at just to give you some exposure to some of the other features that are available in Python. One thing that will be coming up soon is the idea of decorators. And just as we can take a value in Python like a number and modify the value, decorators are a way in Python of taking a function, and modifying that function, adding some additional behavior to that function. So I'll create a new file called decorators.py just to demonstrate what we can do with decorators. And the idea of a decorator is a decorator is going to be a function that takes a function of input and returns a modified version of that function as output. So unlike other programming languages where functions just exist on their own and they can't be passed in as input or output to other functions, in Python, a function is just a value like any other. You can pass it as input to another function. You can get it as the output of another function. And this is known as a functional programming paradigm, where functions are themselves values. So let's create a function that modifies another function by announcing that the function is about to run and that the function has completed run, just to demonstrate. So this Announce function will take, as input, a function f. And it's going to return a new function. And usually, this function wraps up this function f with some additional behavior, and for that reason, is often called a wrapper function. So we may call this wrapper to say that, all right, what is my wrapper function going to do? It's first going to print about to run the function just to announce that we're about to run the function. That's what I want my Announce decorator to do. Then let's actually run the function f. And then let's print done with the function. So what my Announce decorator is doing is it's taking the function f and it's creating a new function that just announces, via a print statement, before and after the function is done running. And then at the end, we'll return this new function, which is the wrapper function. So this right here is what we might call a decorator, a function that takes a function, modifies it by adding some additional capabilities to it, and then gives us back some output. So now here, I can define a function called Hello that just prints "hello, world," for example. And then to add a decorator, I use the at symbol. I can say at announce to say add the Announce decorator to this function. And then I'll just run the function Hello. And we'll see what happens. I'll run Python decorators.py. And I see about to run the function, then "hello, world," then done with the function. So again, why did that work? It's because our Hello function that just printed 'hello, world" is wrapped inside of this Announce decorator, where what the Announce decorator does, is it takes our Hello function of input and gets us a new function that first prints an alert warning that we're about to run the function, actually runs the function, and then prints another message. So, a bit of a simple example here. But there's a lot of power in decorators for being able to very quickly take a function and add capability to it. You might imagine in a web application, if you only want certain functions to be able to run, if a user is logged in, you can imagine writing a decorator that checks to make sure that a user is logged in, and then just using that decorator on all of the functions that you want to make sure only work when a user so happens to be logged in. So decorators are a very powerful tool that web application frameworks like Django can make use of just to make the web application development process a little bit easier as well. Let's take a look at a couple other techniques that exist within Python. One is how we might be able to more efficiently represent functions. So let's imagine that I now have-- I'm going to call this lambda.py for a reason you'll see in a moment. Let's imagine that I have a list of names or people, for example. And inside of this list of people, each person, instead of being just a string, is going to be a dictionary that has both a name like Harry and a house like Gryffindor. And let me add another name like Cho and a house like Ravenclaw, and then another name like Draco and a house like Slytherin. So here we have a list where each of the elements inside of that list is a dictionary, a mapping of keys and values. And that's totally OK. In Python, we have the ability to nest the data structures within one another. We can have lists inside of other lists, or lists inside of dictionaries, or in this case, dictionaries inside of a list. And in fact, this nesting of data structures is one of the reasons why it's very easy in Python to be able to represent structured data like a list of people where every person has various different properties. What I might like to do now is something like sort all of these people and then print them all out. So I might want to say people.sort, and then print all the people. But if I try to run this, I'll get an exception. I get an exception, type error less than not supported between dict and dict, which is sort of weird because I'm not using any less than symbol at all anywhere in a program. But in the trace-back, you'll see that the line of code that it's catching on is people.sort. Somehow, people.sort is causing a type error because it's trying to use less than to compare two dictionaries. And what this appears to mean is that Python doesn't know how to sort these dictionaries. It doesn't know, does Harry belong before or after Cho because it doesn't know how to compare these two elements. And so if I want to do something like this, then I need to tell the sort function how to sort these people. And so in order to do that, one way I could do this is by defining a function that tells the sort function how to do the sorting, what to look at when sorting. So if I want to sort by people's name, let me define a function that I'll just call f, that takes a person as input and returns that person's name by looking up the name field inside of the dictionary. And now I can sort people by their name by saying sort key equals f. What this means is sort all the people. And the way to sort them, the way you know how to compare them, is by running this function where this function takes a person and gives us back their name. And this will sort everyone by name. Now, if I run Python lambda.py, you will see that I first get Cho, then Draco, then Harry in alphabetical order by name, whereas if instead I had tried to sort people by their house by changing my function that I'm using to sort and then rerun this, now I see that its first Harry who is in Gryffindor, then Ravenclaw, then Slytherin, for example. So we get the houses in alphabetical order instead. But the reason I show this is because this function is so simple and is only used in one place. Python actually gives us an easier way to represent a very short, one-line function using something called a lambda expression. And this is a way of including the function just as a single value on a single line. I can say instead of defining a function called f, I can get rid of all of this and just say, sort by this key, a lambda, which is a function that takes a person and returns the person's name. So we say person as the input, colon person name as the output. This is a condensed way of saying the same thing we saw a moment ago, of defining a function, giving it a name, and then passing in the name here. This right here is a complete function that takes a person as input and returns their name. So Python lambda.py, that will actually sort the people by their name-- Cho, then Draco, then Harry. Whereas if I have left off this key altogether and then tried to sort, well then we get this type error. Because we can't compare these two dictionaries. So we've seen a lot of different exceptions now throughout Python. So the very last example we'll take a look at is an example of how to deal with these exceptions, like what to do when things might go wrong if we want our program to be able to handle those possible exceptional cases, situations where things might, in fact, go wrong. So let's try an example. I'll create a new file that I'm going to call exceptions.py. And what exceptions.py is going to do is it's going to get some input. It's going to say let's get an integer input called x. And let's get an integer input called y. And then it lets go ahead and print out the result of x divided by y. So result equals x divided by y. And then let's print out something like x divided by y equals result. And we can literally print out the values of x and y. So this is a simple program that's just performing some division. Get a value of x, get a value of y, divide the two, and print out the result. We can try running this by running Python exceptions.py if I would type in like five and then 10, five divided by 10 is 0.5-- exactly what I might expect. But what could go wrong now? You remember from math in division, what could go wrong is if I type in five and then zero, try and do five divided by zero, what's going to happen? Well, when I do that, I get an exception. I get a zero division error, which is an error that happens whenever you try to divide by zero. What I'd like to happen though in this case is not for my program to display kind of a messy error and a trace-back like this, but to handle the exception gracefully, so to speak. To be able to catch when the user does something wrong and report a nicer looking message instead. And so how might I go about doing that. Well, one thing I can do here is instead of just saying result equals x over y, I can say try to do this, try to set result equal to x divided by y, and then say except if a zero division error happens. Then let's do something else. Let's print error cannot divide by zero, and then exit the program. How do you exit the program? It turns out there's a module in Python called sys. And if I import the sys module, I can say sys.exit1 to mean exit the program with a status code of one, where a status code of one generally means something went wrong in this program. So now I'm trying to divide-- x divided by y-- except I have an exception handler. This is a try-except expression. I'm saying try to do this except if this exception happens, rather than have the program crash, just print out this error message, can't divide by zero, and then exit the program. So now let's try it-- Python exceptions.py. Again, five and 10 works totally normally, gets me a value of 0.5. But now if I try five and zero, press Return, I get an error. Cannot divide by zero-- no long exception that's going to look complicated to the user. It's no longer messy. I've been able to handle the exception gracefully. Now, one other exception that might come up is what if instead of x is five, I type in a word like "hello," something that's not a number. Now I get another type of exception, a value error, which is happening when I try and convert something to an int because Hello cannot be converted into a base 10 integer. You can't take text that is not a number and turn it into an integer. So instead, I'm getting this value error here. How can I deal with that? Well, I can deal with it in much the same way. When I'm getting this input x and y, I can say rather than just get the input, just try to get the input. Except if a value error happens, which is the area that we got a moment ago, this value error, then print error invalid input, and go ahead and sys.exit1. So now I've been able to handle that error as well. I can say Python exceptions.py. I can say Hello. And I just get error invalid input. I can divide by zero. I get error cannot divide by zero. But if I do type of valid x and a y value, then I get the result of dividing one number by the other. So exception handling is often a helpful tool for if you expect that some lines of code you might be running might run into some sort of problem, be they a value error, or a zero division error, or some other error altogether, to be able to handle those errors gracefully. And that's probably what you want if you're going about building a web application using Python, is the ability to say that if something goes wrong, we want to handle the error nicely, display a nice error message to the user telling them what was wrong instead of having the program entirely crash. So those are some of the key features now with this Python programming languagem this language that gives us the ability to define these functions, and loops, and conditions in very convenient ways, to create classes where we can begin to build objects that are able to perform various different types of tasks. And next time using Python, we'll be able to design web applications such that users are able to make requests to our web applications and get some sort of response back. So we will see you next time.
Info
Channel: CS50
Views: 124,343
Rating: 4.9673915 out of 5
Keywords: cs50, harvard, computer, science, david, j., malan
Id: EOLPQdVj5Ac
Channel Id: undefined
Length: 67min 41sec (4061 seconds)
Published: Mon Jun 21 2021
Related Videos
Note
Please note that this website is currently a work in progress! Lots of interesting data and statistics to come.