Code Toolkit: Python, Spring 2023

Week 10 — Wednesday, April 5 — 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'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 library 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.

(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

An interactive Python file exercise

Dictionaries: a new data structure

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 not be one IDE comprised of an integrated bundle of tools, but several separate tools that work well together. One of these is the Visual Studio Code 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 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.

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.

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.

(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 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:🚨 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.

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 VS Code. Close any tabs or welcome screens that are there. 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, search for "Python", and install the Python package of extensions 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:

>>> 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)
4

If 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.

Code Toolkit: Python, Spring 2023

Week 10 — Wednesday, April 5 — Class notes

Python outside of Processing

Table of contents

I. Tools and IDEs

II. The command line

III. Interactive programming in the Python shell

IV. Writing and running Python files with VS Code

a. An interactive Python file exercise

V. Dictionaries: a new data structure

a. Intro and overview

b. Syntax and usage

c. Combining data structures, lists & dictionaries