Week 8

Notice that here we can define a function in Python with a line like def main():, without any curly braces, but indentation instead to indicate the hierarchy.

The boolean True has to be capitalized.

The variable i is our placeholder again, but we don’t need to declare it, and range(50) automatically creates a range of numbers (from 0 to 49 by default if we ask it for 50 numbers).

Notice that we don’t have parentheses around our expressions, anymore, and that instead of using curly braces, indentation is used to indicate which lines of code belong in which block.

And elif is the Python keyword that means else if.

cs50.get_char

cs50.get_float

cs50.get_int

cs50.get_string

…​

bool

float

int

str (a string, with functionality built-in to manage them easily)

complex (complex or imaginary numbers)

list (like arrays)

tuple (groups of values, like x, y coordinates)

range

set (collections of objects, like in math, with certain properties )

dict (a dictionary, like a hash table)

…​

The syntax for including a library is to use import.

Then we declare a variable called s, and not need to specify the type, and we call cs50.get_string() and store the return result into s.

Then we include s in what we print. Strings, or more generally objects, have built-in functions. We can call those functions with the syntax shown, like "hello, {}".format(s), and by passing in the correct arguments, we can substitute variables the way we want.

We can pass in a prompt inside that function, and get the typed value back at the same time.

The value we want to print is 1 / 10, and to specify the format we place :55f inside the curly braces of the string.

There is a special operator in Python, //, that divides two integers and returns an integer that’s truncated (with everything after the decimal point removed).

And comments in Python, instead of starting with //, will start with #.

And we pass in end="" as an additional argument to print if we don’t want a new line to be added for us automatically at the end.

We first get a float, f, apply the correct formula and save the result to c, and we want to format it to one decimal place so we use :1f.

We get a char, and compare it to Y or y or N or n to tell us if we said yes or no.

We just say or and and in Python instead of || and &&.

And in C, we needed to compare chars by using single quotes, but in Python single characters are also strings. The good news is, we can compare strings with a simple == and it will compare them the way we might expect, equalling True if the strings have the same contents. Even more mind-blowingly, in Python single quotes ' and double quotes " can both be used to indicate strings, as long as we use the same one on both sides of the string.

We needed to first delare the function, then a variable n, and then a do while loop.

We don’t need to declare get_positive_int before we call it, as long as it doesn’t actually need to be run before we get to the part of the code that defines it. In this case, we call get_positive_int in main, but main itself isn’t called until the very last line, so everything in our program should already be defined.

And we don’t need to specify that get_positive_int takes no arguments, so we can just add a () instead of (void).

Python also doesn’t have a do while loop, so instead we use while True, but break, or stop the loop, if n > 0.

Then it returns n, but notice that we also didn’t need to declare it outside the loop before we used it. n will be created the first time our loop runs, and then have the new value stored inside it every time after.

And finally, we need to call the main function with the last two lines.

Here cough takes in some argument n, which the language sets to an int automatically for us.

Since we’re only printing the word variable that’s passed into our say function, we can just say print(word).

We can specify the starting number and the ending number in a range (including the starting number but not the ending number).

Then we print chr(i) first, and then i, using the chr() function in Python to convert an integer into a char.

We can check the length of the arguments with len(sys.argv), and access the second one (recall that the first is the program’s own name) with sys.argv[1]. Here sys is a module built into Python that has command-line arguments and others.

With for s in sys.argv, we are accessing element in sys.argv, and calling it s. And the type of each element will be a string.

Then with for c in s, we are accessing each element in the string s, which we will call c, since each element is a character.

In Python, to end a program, since there might not always be a main function to return from, we call exit with some value.

And recall that in the command line, we can type echo $? to see the return value of the last program that ran.

Instead of null, since we don’t need to worry about pointers as much anymore, there is a special value that get_string might return, None, that indicates there is nothing returned.

In C, s and t would be two addresses that would not be the same, but in Python the contents of s and t would be compared automatically for us.

Now we can run the program and see that t has a capitalized version of s, while s itself is unchanged.

Recall that s is an object in Python, so it has built-in functions that we can call from that object with the . syntax, so we can use s.capitalize() that automatically takes the first character and capitalizes it.

Furthermore, strings in Python are immutable, meaning that they can’t be changed after they have been created. So s.capitalize() returns a copy of s that has been capitalized, which we then need to store somewhere. (Though, technically, we could store that right back into s with s = s.capitalize(), but it would be a "new" string.)

The variables don’t get swapped, since they are being passed in as copies again.

In Python, we can actually swap variables with one line. The left side and right side, x, y, and y, x are both tuples, a data structure with multiple values, and we’re setting the items inside x, y to what the items inside y, x are, which swaps the values.

First, we declare a student file that we’ll soon write, and import the Student class from it.

Then we can create an empty list to store students called students, which we can add or remove things to.

Then we get a name and dorm, create a Student objects by passing those strings in as arguments, and append it, or add it, to the end of our list students. (Lists, too, have built-in functionality, one of which is append.)

Finally, for each student, we print the properties back with the . syntax.

We declare a class of objects called Student, which will only have one method, or built-in function, init, which we won’t call directly but gets called when we create a Student as we did above with Student(name, dorm).

This function gets the object itself as an argument and the other arguments we want to be passed in when the object is created, in this case name and dorm. Then inside the function, we store the arguments to the object that’s just been created.

Now, instead of printing the students to the screen, we can write them to a file students.csv by opening it and using a built-in module, csv, that writes comma-separated values files.

With csv.writer(file), we pass in the file we open to get back a writer object that will take in tuples, and write them to the file for us with just writerow.

Here, we create a words property when each Dictionary is initialized, and set it to an empty set. In Python, sets are abstracted (so we don’t know anything about how it’s implemented in memory anymore, or whether it’s a hash table, or trie, or something else entirely) but we can easily operate with it.

We can add items to self.words with self.words.add(), check if a word is in it with word in self.words(), and get the size with len(self.words).

And since Python mananges our memory for us, we don’t even need to worry about unloading it or freeing it.

This popular paradigm, or design pattern, for web software is called MVC, Model-View-Controller.

The Controller has the logic for determining what the code does in response to requests, such as checking if a user is logged in.

The View has the look of the site, with HTML templates and CSS styles.

The Model has the data that the controller uses to fill in Views, which will then form what the user gets back.

We’ll write our own do_GET function for the server that is called when a GET request is received. We’ll always send back the response code 200, send a header, and write a message back.

And all of these functions and features we’d learn about from reading Python documentation online.

We specify the port that we want to listen to messages from, the address of the server (127.0.0.1 is always our own computer, create an HTTPServer that’s built-into Python, but giving it our own HTTPServer_RequestHandler. And finally we run it with the serve_forever function.

We first import lots of functionality from flask, and create an app.

Then we have a line @app.route("/") that says the next function should be called whenever that path on the web server is requested. In this case, the function will return render_template("index.html"), or whatever the file index.html looks like.

Then if we see @app.route("/register", methods=["POST"]), someone sending a POST request to /register, we’ll call the register function underneath. That function, if we don’t have certain elements in the form, will return the template failure.html. Otherwise, it’ll return success.html.

Even if we fill in the form, we aren’t really registered for anything since this application doesn’t have a database, or a place to store the data that we just entered.

There’s not much logic here but it looks like we’re extending a file called layout.html that probably has a basic page structure, and then with {% block title %} and {% block body %} we’re indicating what should go into the title and body.

We see the same {% block title %} and {% block body %} magic words in this file, which works not because of HTML or Python but because of the Flask framework (the render_template function) that builds pages with these templates.

The {% block body %} here has more HTML, a header and a form. The form also has {{ url_for('register') }} for its action, which calls a function that gets the register route in our app, rather than hardcodes it.

we see again the controller logic that checks whether the form is complete, and returns the correct view.

Notice that we can list each item in the cart variable with a for loop, and access fields of each of the item object, two of which at least are quantity and name.

shhh is just some secret value that we use to keep our session, or shopping cart, secure. (Though it should be longer, and harder for someone to guess!)

In the store method, we first check if the request was a POST. If so, meaning a user submitted the form, then we’ll add the quantity indicated in the form for each item into session, if it’s not in that object already, or increment its quantity if it is. And session is an object we get from the framework, that acts like a shopping cart, where we can save information for each user connected to our web server.

The cart method creates an empty list, and stores a dictionary for each item with its name and quantity, using the session to get that value. Then we pass that into render_template as an argument, so we can use it to build cart.html, which we saw above.