(The following links jump down to the various topics in these notes.)
Last week we talked about working with Python outside of the Processing framework.
We started off by talking about how you can run small bits of Python code interactively in the Python shell. With this method, you type Python code one line at a time and see it get immediately evaluated. This is useful for testing syntax and small bits of logic before adding it to a computer program file.
To do this, you have to first access the command line. On Mac you do that by opening Terminal. On Windows you'll need cygwin, the Power Shell, or the bash shell available from git.
Remember that the command line is a text-based
interface that simply offers a different way of viewing the same
files that you can see in Finder (mac) or Explorer
(Windows). Command line commands
include pwd to show the current
directory (folder), ls to list the
contents of the current directory,
or cd to change the current
directory. In my notes I'll show command line commands like
this:
$ ls in_class.py
Remember that $ signifies
the command prompt: where you type
commands. You should not type this. I include it to
show you that what follows is a commnd for you to type. The
lines that follow are the output of running that
command. Sometimes what you see may be slightly different.
To access the Python shell, run
the python3 command:
$ python3 Python 3.8.3 (v3.8.3:6f8c8320e9, May 13 2020, 16:29:34) Type "help", "copyright", "credits" or "license" for more information. >>>
Note that now the command prompt has changed
to >>>. This signifies that
you are in the interactive Python shell and you can now type any
valid Python syntax.
If you ever see an error like NameError: name
'pwd' is not defined, that means you are trying to run
a command line command in the Python shell. To resolve this,
type ^D or exit() to exit the Python
shell.
If you ever see an error like -bash: syntax
error near unexpected token, that means you are trying to
type Python code in the command line. To resolve this, run the
Python shell and try again.
This can be useful but can get tiresome for testing larger chunks of code, and it is not possible using this method to save your code to run later or to give to other people to run. For this, we need to save Python code in files. In our class, we'll be using VS Code for this purpose. See the class notes for last week for detailed instructions about how to open VS Code, how to create new code files, and how to run them.
Lastly, we talked about a new data structure called a dictionary.
Dictionaries are similar to lists in that they can store many values, but they are different in key ways.
Lists store values in sequential order: the order in which you add values to a list is the order in which they will be stored, and you access individual values by number, based on the position of the value in order. Here's a short review of the basic operations of lists:
>>> # create a new empty list
>>> my_list = []
>>> # create a new list with values
>>> my_list = ["a", "b", "c"]
>>> # add a new value to the end of a list
>>> my_list.append("d")
>>> # get the length of a list (number of items)
>>> len(my_list)
4
>>> # access a single item in a list
>>> my_list[3]
'd'
>>> # remember you can also index a list with a variable, useful in loops:
>>> i = 3
>>> my_list[i]
'd'
>>> # this is useful in loops
Now let's look at the similar operations of dictionaries:
>>> # create a new empty dictionary
>>> d = {}
>>> # create a dictionary with some key/value pairs, in this case two
>>> d = {"name": "Rory", "hair": "brown"}
>>> # add a new key/value pair to a list
>>> d["species"] = "human"
>>> # get the length of a dictionary (number of key/value pairs)
>>> len(d)
3
>>> # access a single item in a dictionary
>>> d["name"]
'Rory'
>>> # check if a key is in the dictionary
>>> "name" in d
True
>>> "age" in d
False
We also looked at how you can put data structures inside other data structures, for example lists inside dictionaries or dictionaries inside lists. Here's an example:
>>> # make two dictionaries:
>>> person1 = {"name": "Rory", "hair": "brown", "species": "human"}
>>> person2 = {"name": "Gritty", "hair": "orange", "species": "monster"}
>>> # add a list to each one:
>>> person1["likes"] = [ "computers", "media", "teaching"]
>>> person2["likes"] = [ "hockey", "Philadelphia", "pranks"]
>>> # put both dictionaries in a list:
>>> personel_file = [ person1, person2 ]
>>> # display the list:
>>> personel_file
[{'name': 'Rory', 'hair': 'brown', 'species': 'human', 'likes': ['computers', 'media', 'teaching']},
{'name': 'Gritty', 'hair': 'orange', 'species': 'monster', 'likes': ['hockey', 'Philadelphia', 'pranks']}]
>>> # access the second person's name:
>>> personel_file[1]["name"]
'Gritty'
>>> # access the second person's first like:
>>> personel_file[1]["likes"][0]
'hockey'
Pay close attention to how you index data structures within data structures. This is not a contrived example but actually a very common practice that is very useful in a lot of cases.
Lastly, we reviewed some solutions to the homework from last week.
Here's the most basic implementation of part 1:
import random
number = random.randint(1,10)
name = input("Enter your name: ")
guess = int( input("Guess a number between 1 and 10: ") )
if number == guess:
print("Congrats!")
else:
print("Sorry, that's wrong.")
This code picks a random number between 1 and 10 and stores that
in the variable number, then it prompts the user
for their name and stores that in the
variable name, then it prompts the user for a
guess, converts that to a number with int() and
stores that in the variable guess. Then it checks
if the user's guess is equal to the randomly picked number and
prints a message accordingly.
But this only allows one guess. To allow the user multiple guesses, there are a couple options. To offer the user an indefinite number of guesses, we can intentionally create an infinite loop like this: (Note the addition of the indentation.)
import random
number = random.randint(1,10)
name = input("Enter your name: ")
while True:
guess = int( input("Guess a number between 1 and 10: ") )
if number == guess:
print("Congrats!")
break
else:
print("Sorry, that's wrong.")
Since True is always, well, true,
this while loop will repeat forever. But by using
the break command, we can exit out of this loop. In
this case, we use break if the user guesses the
number correctly.
We can also offer the user a little bit of help if they guess
wrong by replacing our "Sorry" message in the else
case with this if / else statement:
import random
number = random.randint(1,10)
name = input("Enter your name: ")
while True:
guess = int( input("Guess a number between 1 and 10: ") )
if number == guess:
print("Congrats!")
break
else:
if guess < number:
print("Too low.")
else:
print("Too high.")
If you'd rather limit the number of guesses instead of giving an
unlimited amount, you can create a while loop with
a variable, similar to how we've been doing all semester:
import random
number = random.randint(1,10)
name = input("Enter your name: ")
i = 0
while i < 10:
guess = int( input("Guess a number between 1 and 10: ") )
if number == guess:
print("Congrats!")
break
else:
if guess < number:
print("Too low.")
else:
print("Too high.")
i = i + 1
And if you want to tell the user how many guesses they have left you could add something like this:
import random
number = random.randint(1,10)
name = input("Enter your name: ")
print("You have 10 guesses")
i = 0
while i < 10:
print("Guess number #" + str(i) )
guess = int( input("Guess a number between 1 and 10: ") )
if number == guess:
print("Congrats!")
break
else:
if guess < number:
print("Too low.")
else:
print("Too high.")
i = i + 1
Note that I'm using str() to convert the
number i to a string so that I
can concatenate it with the +
operator. str() is like the opposite
of int(). The latter converts a text number into a
numerical number, and the former converts a numerical number
into the text character of that number.
Here's a solution for part two. This creates a new empty dictionary, adds some definitions, asks a user for a word, checks if that word is in the dictionary, and if so displays the definition of that word.
dictionary = {}
dictionary["carrot"] = "An orange vegetable"
dictionary["orange"] = "An orange fruit"
dictionary["cherry"] = "A red tree fruit"
dictionary["strawberry"] = "A red ground fruit"
while True:
word = input("Enter a word (or 'exit' to exit): ")
if word == 'exit':
print("Bye")
break
if word in dictionary:
print( dictionary[word] )
else:
print("Sorry, I don't know that word.")
Now to allow the user to add new definitions, add the following:
dictionary = {}
dictionary["carrot"] = "An orange vegetable"
dictionary["orange"] = "An orange fruit"
dictionary["cherry"] = "A red tree fruit"
dictionary["strawberry"] = "A red ground fruit"
while True:
word = input("Enter a word (or 'exit' to exit): ")
if word == 'exit':
print("Bye")
break
if word in dictionary:
print( dictionary[word] )
else:
defn = input("I don't know that word. Please define it: ")
dictionary[word.lower()] = defn
Of course, the sad thing about this code is that if a user were to add a bunch of new definitions, when they exit the program, all those definitions would be lost. What would be nice is if the program could save all the definitions that have been added, and then load them up next time the program runs. That brings us to the new topic for today.
(jump back up to table of contents)
Data serialization is a term for the process of
converting variables and data structures into a kind of format
that can be imported and exported from your code. You might want
to do this to share data with another computer program, or with
the same computer program at a later
time. To serialize data means to convert it
into a series. In the cases we'll be looking at, we'll be using
a text-based serialization format, so the
conversion is to a series of characters. But other serialization
formats might convert data to a series of bits, 1
and 0.
f = open("FILENAME")
file_contents = f.read()
f = open("FILENAME","r")
f = open("FILENAME","w")
f.write("Hello")
import json
s = "[ 10, 20, 30 ]"
json.loads(s)
print( len(s) )
import json
f = open("data/data.json","r")
file_contents = f.read()
print(file_contents)
data = json.loads(file_contents)
print(data)
def setup():
size(800,800)
def draw():
background(255)
i = 0
while i < len(data):
d = data[i]
fill( d["r"], d["g"], d["b"] )
ellipse( d["x"], d["y"], 50,50 )
i = i + 1