Code Toolkit: Python, Spring 2024
Week 10 — Wednesday, April 3 — Class notes
Python outside of Processing
Today we are going to start working with Python outside of the Processing platform.
So far this semester, you have effectively been learning two things together:
- Python, the hugely popular computer programming language used across a wide range of domains; and
- Processing, a platform oriented toward creative, multimedia programming for artists and designers.
As we shift out of Processing, many things we've learned will
carry over: variables, if statements,
while loops, lists, and functions. But many things
will not carry over, namely all the Processing shortcuts that
are focussed on visuals and interaction such
as rect()
and ellipse(), color(), millis(), setup(), draw(),
and keyPressed(). Essentially, most of the commands
described on
the Processing
documentation page are not usable outside of Processing.
But don't despair! This has not been a waste. Every time you will be using a programming language (such as Python) you will almost certainly be using it along with other libraries and APIs to facilitate your work. We can think of Processing as one such library - and Processing is a great library to get started with. Processing is also a good library to use in the future if you want to do more work on with interactive multimedia like motion graphics, games, or data visualization. Other alternatives to Processing when working in Python include PyGame or the Python Image Library (PIL), and if you ever work with either of these libraries, you will find that many concepts from Processing carry over, and all of your core Python knowledge will be essential.
Table of contents
(The following links jump down to the various topics in these notes.)
- Tools and IDEs
- The command line
- Interactive programming in the Python shell
- Writing and running Python files with VS Code
- Dictionaries: a new data structure
- Wrap-up and homework
Image of an art piece by net art team Jodi, this piece plays
with "code aesthetics" by depicting the text-based
HTML source code of a webpage as the user interface. If the user
"views source" it reveals a diagram meant to be part of plans
for a nuclear
bomb. Visit wwwwww.jodi.org
to see the piece for yourself,
or visit net-art.org to read
more.
I. Tools and IDEs
Back in week 1 I explained how to use the PDE: the Processing Development Environment. This is what is known as an integrated development environment or (IDE). It is comprised of all the tools you'll need to do your work on this platform. In the case of the PDE, this includes: a text editor as well as a play button to run your code, a console to see error messages, and other tools that you used to create Python computer programs, which the Processing world calls sketches in an effort to emphasize the experimental style of programming that the Processing project wants to encourage.
For this next unit, our development environment will be Visual Studio Code: an open source text editor for coding, that comes bundled with a command line interface and other tools. Similar to Processing, VS Code offers an easy way to run your Python programs, and its integrated command line interface will be similar to the Processing console in that it is where we will look for error messages and text-based output.
It's important to know that while VS Code integrates a command line interface that we will be using, the command line is a computing paradigm that exists outside of VS Code. The command line has been around for much longer than VS Code, or Python. You can access command line style computing through various methods, but VS Code provides an integrated command line that we will be using.
Today we will also learn a new data structure called a dictionary.
(jump back up to table of contents)II. The command line
The command line is just a different kind of interface for accessing files and running programs on your computer. While Finder (on Mac) and Explorer (on Windows) use a graphical user interface (GUI) to manage our files, folders, and programs, the command line is a text-based interface, in fact sometimes it is called the command line interface or (CLI). The command line is typically thought of as a kind of legacy mode of computer use: text-based command line interfaces were common before the rise to prominence of the GUI.
Sidenote: If you would like to learn more about the history of the command line, and watch an elaborated technical discussion, you can access this two part video tutorial that I created for another class: Command line tutorial part 1: history, Command line tutorial part 2: technical instruction. Keep in mind that these videos were created for another class, so a couple comments will be irrelevant, but the history and explanation of how to use the command line will all be relevant.
Why learn the command line? A command line context is often an easier way to develop computer programs because we as developers do not need to worry about designing and implementing graphical interfaces, which often require extra code (as you have seen in all your midterm project work). Conversely, this means that using programs in a text-based command line mode might often feel less intuitive and less user-friendly than in graphical modes. But working in a command line mode is an important skill for a software developer, as it often allows you to more rapidly run and test new code, without having to build up a more developed interface.
Also, since the command line is text-based, there are some situations, like data processing, where running a program in a command line context may actually be easier. Additionally, there may be times when you will be working in a server context — for example installing code over a network into a cloud-based machine that is physically distant and inaccessible in-person — and in these cases it is often impossible to access a GUI interface, so you would need to navigate a command line interface.
Beyond that, computer programs that run by reading and outputting text is the primary way that programs function on servers in a networked context. Computer networks operate by programs on different computers exchanging data with each other using protocols, which you'll learn about in the reading for next week, and we'll experiment with in the coming weeks. Computer network protocols are usually comprised of text-based messages. So understanding how to write a program that can send and receive text-based inputs and outputs will give you insight into how server processes work, and it will allow you to write a server-based program to create code that operates as part of a networked system, which is your assignment for the final project.
There are many ways to work within the command line mode. On Mac, you can simply open the application called Terminal. On Windows, you would probably need to install Cygwin, or use the the Windows Subsystem for Linux. But we will not be using either of these methods and instead will access the command line through VS Code.
Open VS Code, and within that, open a new command line terminal.
For now, since we will only be working in the terminal and not yet working on any code files, expand the terminal window by clicking on the little up arrow: ^
Now let's go through a few basic commands that you'll need to get started working with the command line. Note the new formatting: whenever I use a fixed-width font on a black background with rounded corners and a thin gray bar on top, I am showing you valid instructions for the command line, like this:
$ pwd /Users/rory/
pwd is a command line instruction. You
can type any command line instructions in at a command
prompt and press enter. The lines that come below are
examples of what you may see, but your results will be
different depending on the files and folders on your computer.
Please note: you should not enter the dollar
sign ($) when you are entering command
line instructions. I use the dollar sign to signify the command
prompt. (The command prompt may be signified by different
punctuation in your terminal, like %
and that is fine.) The command prompt is how
the command line tells you that it's ready for more input, and
that is where you will enter new commands. Always press enter to
execute the command you've typed.
pwd — stands for "print working
directory", and this command will display the directory
(equivalent to a folder) that you are currently working in.
ls — stands for "list", and this
command will list all of the files in your current
directory. This is the command line equivalent of simply opening
a folder in Finder (or Explorer) and viewing its contents.
The command line allows you to type the name of any executable program on your system, press enter, and the command line will then try to run that program.
(jump back up to table of contents)III. Interactive programming in the Python shell
Let's see how to run Python in a command line context. The name
of the Python command on your system may be different, depending
on whether you are running Mac, Windows, or which version of
Python is installed. I think it should most likely
be python3. The thing to make sure of
is that when you run the command, it displays output indicating
that you are running version 3.x of Python.
$ python3 Python 3.8.3 (v3.8.3:6f8c8320e9, May 13 2020, 16:29:34) [Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>>
Notice that now the punctuation indicating my command prompt has
changed from a $
to >>>, which means that we are in
the python shell. This is a place where you can
type any valid Python code, and it will be interpretted and run.
To exit out of the Python shell you can
type exit() (or on Mac you can type
CONTROL-D — someone please remind me the shortcut on
Windows?). If you inadvertently run some Python commands that
won't stop executing, you can type CONTROL-C to stop them.
🚨NOTE:🚨
regular command line instructions will not work inside the
Python shell, and Python syntax will not work in the command
line shell. For example, if you
type pwd and get an error, check the
command prompt to see if it
is >>>. If you are trying to
type a command line instruction in the Python shell, first exit
out of Python with exit() or
CONTROL-D. Conversely, if you are trying to enter Python code in
the command line shell, first
type python3 to run the Python
shell. I've learned that this is a super common mistake
for students, so please be careful.
a. Variables. You can create variables in Python just as in Processing:
>>> x = 250 >>> length = 50 >>> print(x) 250 >>> x 250 >>> x + length 300
Notice that to examine the value of a variable I can
use print() to display it's value. When I'm in the
interactive Python shell, I can also simply type the name of the
variable and press ENTER to see its value. I can also do
arithmetic with variables as before.
And I can also use comparison
operators, Boolean values, and
conditionals (a.k.a. if statements) as before:
>>> x < 50
False
>>> x > 100
True
>>> if x < 300:
... print("Less than")
...
Less than
Note that the colon (:) still starts a
new block, and that a block
must always be indented. To exit out of a block, you type an
empty line, at which point that block will be evaluated. In
Processing we have been using four spaces for indentation (and I
will continue to do that in VS Code) but in an interactive Python
shell I usually only type two spaces just out of convenience.
b. Loops. As before, I can
create loops with the while
statement, and use variables to control them in the same way:
>>> i = 0
>>> while i < 5:
... print("This is a loop")
... i = i + 1
...
This is a loop
This is a loop
This is a loop
This is a loop
This is a loop
c. Stopping an infinite loop in the shell: CONTROL-C. As before, if you forget to include your increment in your loop block, you will get an infinite loop that repeats forever and never stops. In the Python shell, you can stop an infinite loop by typing CONTROL-c to interrupt it:
>>> i = 0
>>> while i < 10:
... print("This is a loop")
...
This is a loop
This is a loop
^CThis is a loop
This is a loop
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
Sometimes infinite loops can be useful in this context, for example when working with user input.
d. User input. In Processing we used things
like keyPressed() and mousePressed()
for user input. In a command-line context obviously we can't use
commands like that since our interface is text-based. Instead,
we can access user input with the input() command
which asks the user for textual input, like so:
>>> input()
Hello
'Hello'
>>> s = input()
Hello
>>> print(s)
Hello
>>> s = input("Type something: ")
Type something: Hello
>>> print(" You typed: " + s)
You typed: Hello
With the above code snippet I'm showing that you can set a
variable equal to whatever text the user typed, and then use
this variable later. That snippet also illustrates how
the input() command can optionally take an argument
which gets displayed to the user as a prompt.
The above code only asks the user for input once, but you could put this in a loop to ask the user for input many times:
>>> i = 0
>>> while i < 3:
... s = input("Type something: ")
... print(" You typed: " + s)
... i = i + 1
...
Type something: Hello
You typed: Hello
Type something: How are you?
You typed: How are you?
Type something: Goodbye
You typed: Goodbye
>>>
You could even ask the user for input over and over again
indefinitely. So far we've tried to avoid infinite loops. But
there are cases when you might want to have one, for
example when trying to create an interactive program that
repeatedly waits for user input. If you want an
infinite loop, you can create one by putting True
in the while statement. This will repeat forever
since True will always be, well, true.
>>> while True:
... s = input("Type something: ")
... print(" You typed: " + s)
...
Type something: Hello
You typed: Hello
Type something: How are you?
You typed: How are you?
Type something: Goodbye
You typed: Goodbye
Type something: Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
Note that to exit out of this you type CONTROL-c, as I showed above.
e. Using break with loops. You
can also implement an interaction that asks the user for input
over and over again indefinitely until they specify
some stopping condition. You can do this with the Python
command break, which will cause your code to exit
out of a loop. Like this:
>>> while True:
... s = input("Type something: ")
... if s == "exit":
... print("You will now exit.")
... break
... print(" You typed: " + s)
...
Type something: Hello
You typed: Hello
Type something: How are you
You typed: How are you
Type something: exit
You will now exit.
>>>
Another way to implement this behavior without break
would be to use the while stopping condition, like so:
>>> s = "" >>> while s != "exit": ... s = input("Type something: ") ... print(" You typed: " + s) ... Type something: Hello You typed: Hello Type something: How are you You typed: How are you Type something: exit >>>
Notice how here we have to set the variable s so some
value before starting the while loop. The
value here can be any value as long as it does not
equal "exit". Think of it as a dummy / temporary /
placeholder value. Then each time the user specifies input, it
sets the variable s to what the user entered, and
the while loop checks again. Notice that this code
does not display the helpful exit message as the previous snippet
did. But you could add back an if statement. Maybe
something like this:
if s == "exit":
print("You will now exit.")
else:
print(" You typed: " + s)
(jump back up to table of contents)
IV. Writing and running Python files with VS Code
Working like this can be nice. It can be a quick way to experiment with different Python commands and to get instant feedback without having to run a file. But what about if you want to run some code without having to type it in every time? What if you want to start building up Python code into a program that you can run, or that a different person can run? For this, we'll start writing Python code in a file.
As with Processing, you will write Python code in a text editor, save it, and run it. But this time the text editor will be VS Code (not the PDE), and we'll run code with the command line.
All the Python files that we create and save in VS Code should be
named with a .py extension, for
Python. (How does this compare to our work in Processing?
Back when we were working in Processing, the PDE created files for
us with a .pyde extension. This is
because in the original Processing, for Java, files contained
a .pde extension, named after the PDE
that was used to create them. When the Python mode for Processing
was created, they needed a different extension to differeniate
files, and so added the "y". So it's like a mashup
of .py
and .pde.)
First make a folder structure to work in. Create a folder for
all your work for this class for the rest of the semester if you
have not done so already. Next creatte a folder for this
week, week 10. (How does this
compare to our work in Processing? When we were using
Processing, the PDE created a folder for you for each new
project or exercise you were working on. Now that we are working
on Python files in VS Code, you should manually create a folder
yourself for each new project or exercise. You don't have to put
all of them in one folder for our class, but I highly recommend
it.)
Open VS Code if you don't yet have it open. Close any tabs or welcome screens that are there.
If you still have a Terminal open, you can close it by clicking the little trashcan symbol.
If this is your first time opening VS Code (or if you've used it before for something other than Python), click on the Libraries icon, type "Python" in the search box, and install the Python package of extensions (should have "IntelliSense" in the description) which includes support for things like Python code formatting and other shortcuts.
Drag the week 10 folder into VS
Code. If you get a prompt asking whether you "trust the authors
of the files in this folder", click "Yes".
Now from the menu
click File > New to make a new file, then click File >
Save, name your file main.py, all lower
case, no spaces or other punctuation, and save it into
your week 10 folder. Saving your file
with a .py file extension will tell VS
Code that you are working with Python code, and it will offer
you syntax highlighting similar to the PDE.
Now let's add a line of code to our Python file:
print("Hello, world")
(For some reason programmers love to use this simple program to test new languages and platforms.)
Now click the Play icon in VS Code.
a. An interactive Python file exercise
Let's make a program using the bits of Python that we've been
experimenting with above. First let's create a
simple while loop:
i = 0
while i < 5:
print("Hello, world")
i = i + 1
Run this:
$ python main.py Hello, world Hello, world Hello, world Hello, world Hello, world
Now let's make it interactive:
s = input("Type your name: ") i = 0 while i < 5: print("Hello, " + s) i = i + 1
Run it:
$ python main.py Type your name: Rory Hello, Rory Hello, Rory Hello, Rory Hello, Rory Hello, Rory
What if we wanted to take this one step further and ask the user
how many times they wanted the loop to repeat? We could add one
more input() command, set the user input to a
variable, and use that variable in the while
statement. A first attempt at this might look like this: (Note,
this code has an error.)
s = input("Type your name: ")
num = input("Type a number: ")
i = 0
while i < num:
print("Hello, " + s)
i = i + 1
# Note: this code has an error
If you try to run this you will get an error like the following:
TypeError: '<' not supported between instances of 'int' and 'str'
That error would be caused by the user typing text for their
name, and a number for a second variable, but you cannot use the
less-than operator < to compare a
text string with a number. The solution is to
use int(), which will convert a text string to a
number. Here is a demonstration, flipping back over to the
terminal to work for a moment in the interactive Python shell:
>>> i = 0
>>> n = input("Type a number: ")
Type a number: 10
>>> n
'10'
>>> i < n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'
>>> i < int(n)
True
You could also achieve this same result by wrapping
the input() command inside int() like
this:
n = int( input("Type a number:") )
So the correct version of this code looks like the following:
s = input("Type your name: ")
num = int( input("Type a number: ") )
i = 0
while i < num:
print("Hello, " + s)
i = i + 1
(jump back up to table of contents)
V. Dictionaries: a new data structure
We've talked extensively about variables that
store single values, like numbers, characters, longer bits of
text, and even True/False values. Unlike simple variables,
data structures allow us to store multiple
values together in various ways.
So far we have talked about one kind of data structure: lists (week 7). Lists are good at storing values in a fixed, sequential order.
Brief review. Remember that you create a list with square brackets[and]. You can create an empty list by using brackets with nothing between them (x = []) or you can create a list with values by specifying them in brackets separated by commas (x = [ "a", 1, True, "b" 2, False ]. Whether you have an empty list or one with values, you can add more values to a list by using.append(), and those values will always be stored in the order in which they were added. Then you can reference those values with a numerical index inside square brackets (x[0],x[3], etc.)
During our discussion of lists, I mentioned that Python offers many different data structures. Which data structure to use in a given situation depends on the structure of the data that you are trying to model, and the operations that you will need to do with it. Determining which data structure(s) to use to solve a given problem can often be a question of some subjective debate, and there is often not one clear right answer.
Today we're going to learn about a new kind of data structure called a dictionary.
a. Intro and overview
While lists are sequential (values are stored in order) and accessed by a numerical index, dictionaries are unordered and are accessed by an index of any kind of value (number, string, etc.) A dictionary contains a collection of mappings, also referred to as key-value pairs. Think of a key-value pair as like a pairing of a word and its definition — this is where the dictionary gets its name. Dictionaries do not preserve the order in which items are added to them, and instead are accessed, we might say, randomly, by retrieving the value (the definition) for a given key (the word).
b. Syntax and usage
Let's start learning about dictionary syntax and usage by working interactively in the Python shell. First let's review the list commands:
>>> a = [] >>> a.append(100) >>> a.append(200) >>> a.append(300) >>> print(a) [100, 200, 300] >>> a[0] 100 >>> a[1] 200 >>> len(a) 3
It is also valid Python code to initialize a list by using this notation:
>>> a = [ 100, 200, 300 ] >>> a [100, 200, 300]
Now let's learn some new syntax for dictionaries:
>>> r = {}
>>> r["name"] = "Rory"
>>> r["species"] = "human"
>>> r["hair color"] = "brown"
>>> r["favorite thing"] = "computers"
>>> r
{'hair color': 'brown', 'name': 'Rory',
'favorite thing': 'computers', 'species': 'human'}
>>> r["name"]
'Rory'
Notice that the order in which the key-value pairs are printed is not the same order in which I entered them. This is because dictionaries do not preserve order, as I mentioned above.
You can also use the len() command as with
lists. In this case, len() will return the number
of key-value pairs:
>>> len(r) 4If you try to access a key that is not in your dictionary, you will get a
KeyError. For example:
>>> r["date of birth"] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'date of birth'This very helpful error message is telling you precisely the problem: that the key
"date of birth" does not
exist in this dictionary.
There is a command that you can use to help avoid these
errors: in. This command checks if a given key
is in the dictionary, like so:
>>> "name" in r True >>> "date of birth" in r False
Since this command returns a Boolean
(True/False) value, you can use it
inside an if statement, like so:
>>> if "date of birth" in r: ... r["date of birth"] ... else: ... "Key not in this dictionary" ... 'Key not in this dictionary'
Similar to the new array initialization above, you can also initialize a dictionary with some new syntax:
>>> r = {
... "name": "Rory",
... "species": "human",
... "hair color": "brown",
... "favorite thing": "computers"
}
>>> r["name"]
'Rory'
c. Combining data structures, lists & dictionaries
One last thing, you can even combine data structures in useful and important ways. So for example:
>>> r = {
... "name": "Rory",
... "species": "human",
... "hair color": "brown",
... "favorite thing": "computers"
}
>>> g = {
... "name": "Gritty",
... "species": "monster",
... "hair color": "orange",
... "favorite thing": "hockey"
}
>>> beings = [ r, g ]
What I've done here is create two separate
dictionaries, r and g, and then
created a list called beings, which holds both of
them.
I can access these individual dictionaries by indexing the list just as we already have been:
>>> beings[0]
{'name': 'Rory', 'species': 'human', 'hair color': 'brown',
'favorite thing': 'computers'}
>>> beings[1]
{'name': 'Gritty', 'species': 'monster', 'hair color': 'orange',
'favorite thing': 'hockey'}
And if you want to display this entire data structure comprising two dictionaries in a list, it is represented textually like this:
>>> beings
[{'hair color': 'brown', 'name': 'Rory',
'favorite thing': 'computers', 'species': 'human'},
{'hair color': 'orange', 'name': 'Gritty',
'favorite thing': 'hockey', 'species': 'monster'}]
Data formatted in this way is called JSON, which stands for JavaScript Object Notation, and is what Python uses to display the contents of data structures like these. The syntax of this format comes from JavaScript, but it proved to be very useful and so has been taken up by many programming languages, Python included. Now it is almost a kind of standardized way of exchanging data between different computer programs, even between programs written in different languages. We'll talk about this more next week.
(jump back up to table of contents)VI. Wrap-up and homework
The homework for this week offers two opportunities to experiment with the above techniques that we will review next week.