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've discussed, Processing provides a set of shortcuts to make certain types of graphical, multimedia, and user interactive programming easy. The Processing project provides these shortcuts for several languages now including Java (the original language of Processing), as well as Javascript and Python. We have been focussed on Processing as a way to learn both Python and programming fundamentals because Processing is a friendly way to learn coding, and it allows programmers to more easilly visualize what these fundamental building blocks of coding do.
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. Nearly every time you will be using a programming language (such as Python) you will be using it along with other libraries and APIs to facilitate your work. Processing is a great one to get started with, and a good one to use in the future if you want to work on an interactive multimedia project. 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.
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 programs which the Processing world calls sketches.
For this next unit, our development environment will not be one IDE comprised of an integrated bundle of tools, but several separate tools that work well together. One of these is the Atom text editor. Another piece is the command line, which we'll use to run Python programs, manage input and output to and from Python programs, and to see error messages like we used to see in the console.
The command line can feel a little less user friendly at first. It is useful to use because it offers a text-based programming paradigm, rather than the graphical mode that we've been working in. Writing programs in this way allows the programmer to experiment with algorithms and data processing without having to spend time developing user-friendly user interfaces.
This mode is also how computer programs operate that run on servers in a networked context. Computer networks generally operate when programs on different computers exchange 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.
Today we will also learn a new data structure called a dictionary.
(The following links jump down to the various topics in these notes.)
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.
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. 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. Lastly, 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.
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.
Open Terminal on Mac. On Windows, you'll need to install Cygwin, or use the the Windows Subsystem for Linux.
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.
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 CONTROL-D,
or exit(). If you inadvertently run
some Python commands that won't stop executing, you can type
CONTROL-C to stop them. Note that regular command line
instructions will not work inside the Python shell, so if you
want to pwd
or ls, you need to exit out of Python.
Variables. You can create variables in Python just as in Processing:
>>> x = 250 >>> length = 50 >>> print(x) 250 >>> x 250 >>> x + length
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 Atom) but in an interactive Python
shell I usually only type two spaces just out of convenience.
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
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 type CONTROL-c to interrupt and stop an infinite loop:
>>> 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, as with user input:
User input. Instead of things
like keyPressed() and mousePressed(),
user input in a command-line context is text-based. You can
access user input with the input() command:
>>> input()
Hello
'Hello'
>>> s = input()
Hello
>>> print(s)
Hello
>>> s = input("Type something: ")
Type something: Hello
>>> print(" You typed: " + s)
You typed: Hello
Note that you can set a variable equal to whatever text the user
typed, and then use this variable
later. The input() command also can optionally take
an argument which gets displayed to the user as a prompt.
You can ask the user for input over and over with an intentional infinite loop:
>>> 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 I typed CONTROL-c to exit out of this loop, just as above.
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 Atom (not the PDE), and we'll run code with the command line.
First make a folder structure to work in. Create a folder for
all your work for this class this semester if you have not done
so already. Next creatte a folder for this
week, week 10.
Open Atom. Close any tabs or welcome screens that are
there. Drag the week 10 folder into
Atom. 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
Atom that you are working with Python code, and it will offer
you syntax highlighting similar to the PDE.
cd — stands for "change
directory". In the command line, this is how you change the
directory that you are currently working in. Terminal programs
these days have some really nice interaction between the command
line and the GUI, so you can type cd
(note the space) and then drag a folder in to the Terminal
window from Finder, press enter, and it will change to that
directory. Type cd , drag in your
new week 10 folder, and press enter.
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 flip back to the command line, and run this program by
typing python3 and the filename:
$ python3 main.py Hello, world
Note the command prompt here: $. I am
in the Unix shell, not the Python shell. The program runs,
exits, and returns me to the Unix shell. So I have just run some
Python code in a file, not in an interactive Python shell. Now I
could write a more complicated program and distribute that to
others to run.
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. If you try this, you might get an error that says:
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:
>>> 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
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. Remember that you create a list with empty square
brackets (x = []), then you add values to it using
the append() command which are then stored in the
order in which they were added, and you 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.
The data structure we'll learn about today is the dictionary. While lists were sequential (added to in order, and accessed by numerical index), dictionaries are unordered, and they 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).
Since at this point in our class we are starting to move out of Processing and into Python itself, I want introduce dictionary syntax to you outside of Processing. But first, we need to take a detour into the command line.
Let's use the interactive Python shell to learn about how to use dictionaries. First let's review some 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'
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"
}
>>> a = [ r, g ]
>>> a
[{'hair color': 'brown', 'name': 'Rory',
'favorite thing': 'computers', 'species': 'human'},
{'hair color': 'orange', 'name': 'Gritty',
'favorite thing': 'hockey', 'species': 'monster'}]
>>> a[0]
{'name': 'Rory', 'species': 'human', 'hair color': 'brown', 'favorite thing': 'computers'}
>>> a[1]
{'name': 'Gritty', 'species': 'monster', 'hair color': 'orange', 'favorite thing': 'hockey'}
What I've done here is create two
dictionaries, r and g, and then
created a list a, which holds both of them.
The format that Python uses to display the contents of data structures in this way is called JSON, which stands for JavaScript Object Notation. This is a text-based way to format data for storage or to exchange between different computer programs. We'll talk about it next week.