Introduction to Programming with Python and EarSketch

Computers are programmable machines that process information by manipulating data. As the data can represent any real world information, and programs can be readily changed, computers are capable of solving many kinds of problems.

Programs are created in a programming language by writing a series of instructions into a text file. The basic unit of a program is called a statement. As the name indicates, a statement is simply a command for the computer. It instructs the computer to do something. For example, the line

instructs the computer to set the tempo of a song to 120 beats per minute, about the tempo of an average pop song. A collection of statements is called a block. A block can be stored and reused as a function.

The files containing the program (source) code are translated into executable applications or software. Most programs are intended to serve as interactive tools for customers referred to as users. Users interact with programs in many ways including:

There are many different programming languages for programmers to choose from. Each language has its own advantages and disadvantages, and new languages gain popularity while older ones slowly lose ground. In this book, we use the Python 2.7 programming language. It is popular in both academia and industry and was designed with education in mind.

There are many different environments where a programmer may write and test Python. We will utilize a few different environments throughout the semester, but we will start with 2 web-based environments: PythonTutor and EarSketch.

PythonTutor is an environment for creating very short and simple Python programs and visualizing their execution. This enables beginners to visually see the data as it gets manipulated by the instructions.

EarSketch is a DAW (Digital Audio Workstation) that allows users to create music using Python. It has built-in sound clips made by professionals in the music industry for users to mix and combine into novel musical compositions. Instead of providing a GUI interface for users (such as Garageband from Apple), Earsketch provides an IDE (integrated development environment) where users can write Python code to create music. EarSketch runs in a web browser without installing any additional software. Earsketch currently supports Firefox, Chrome, and Safari. (Internet Explorer is not supported.)

Each Chapter (except this one) will end with an EarSketch project which will allow you to create your own musical composition from scratch. The program will need to use the relevant concepts from the chapter. Peers will provide feedback both on how the music sounds and how the code looks.

Program files can contain source code and comments. Comments are not instructions for the computer to follow, but instead notes for programmers to read. Comments in Python start with a pound sign (#). Anything following the pound sign, on the same line, will not be executed. Often, at the very beginning of a program, comments are used to indicate the author and other information. Comments are also used to explain tricky sections of code or disable code from executing.

At the beginning of many Python programs, there will be statements which use the import keyword. These statements enable the program to use specific functions contained in a module. For example, all EarSketch programs begin with the line of code below.

Once this line is executed, the entire application programming interface (API) of EarSketch is enabled. This allows the program to use functions like init(), setTempo(), and insertMedia(). Function calls are covered in more detail in Chapter 3.

Video: Data Types

Programming is all about information processing. Information is categorized by data types. Three basic data types are int (integer), float, and string. Integers are whole numbers (without a decimal point). Floats are numbers that include decimal places. Strings are text (sequences of characters) including punctuation, symbols, and whitespace. Every value in Python has a corresponding data type. The table below shows examples of ints, floats, and strings.

Variables are (virtual) boxes that store values for reuse later. A variable has a name and a current value. Each variable can only hold one value at a time. Variables are assigned a value using the single equal sign (=). As Python executes one line at a time, variables come into existence on the line where they are first assigned.

Video: Operators and Expressions

Python supports many operators including the standard numeric operators (+ - * /), the remainder operator (%) for integer division, and others. Different operators do different things depending on the data types used. For example, + does addition for ints, but concatenation for strings. Operators, values, and existing variables combine to form expressions. Play with the program below and learn how to predict the return value of expressions. Can you explain how Python divides floats versus integers?

Video: Modifying Variables

As you might expect, variables can have their values changed. As a variable can only hold 1 value at a time, the previous value of the variable gets erased when a new value is stored. The single equal sign (=) stores a new value in a variable. The += increments a variable by doing a + operation on the previously stored value.

Some Python modules come with pre-defined variables that can be used at anytime. These are referred to as constants and should never be modified.

To find sound clips that work well together in your music, choose them from the same folder. For example, pick all your sounds from DUBSTEP_140_BPM or all of them from Y30_68_BPM_B_MINOR.

To hear a sound clip, click the play button next to its name. To use a sound clip in EarSketch, click the paste button to paste the sound’s constant into your script at the current cursor position. To help you find sound clips, you can search by keyword and you can filter by artist, genre, and instrument.

As you get more comfortable creating music with EarSketch, you may want to experiment some more by combining sound clips from several different folders in the same song and by trying out different tempos. When experimenting, use your musical ear to help you decide what sounds good and what doesn’t, and try a bunch of different possibilities to figure out what you like best.

Video: Function Calls

In the last chapter, we introduced the basic mathematical operators (+ - * /). There are many other operations we might want to perform on data but there are not enough symbols for all of them. Instead, programmers use functions, which have a name and perform some complex operation given the appropriate inputs. Like the addition operation, they take input values, called parameters, and can result in a return value. The following program has two example function calls to the len() function. The len() function calculates the length of a string. On the first line, the input parameter value is the string "Mississippi" and the return value is the integer 11. On the second line, the input is "Hi there!" and the return value is 9.

EarSketch includes a special set of functions for making music in Python. To use the EarSketch functions, always import the EarSketch application programming interface (API) at the top of your Python script:

from earsketch import *

We have already used several EarSketch functions, including init(), setTempo(), insertMedia(), and finish().

Video: Data Type Functions

In the last chapter, we introduced the basic data types int, float, _and _string. As you know, different operations (such as +) work different ways on different data types. Therefore, it is very useful to convert data from one type to another. Learn the functions below:

In the following code example, pay special attention to the types of data stored in each variable. Remember, all strings are surrounded in quotes "".

In the last chapter, we introduced expressions. Generally, an expression is any code that returns a value. Furthermore, anywhere it is legal syntax to use a value, it is legal syntax to use an expression instead. This gives rise to function chaining and complex expressions.

The random() function takes no input parameters and returns a random float greater or equal to 0 and less than 1.

The randint() function takes 2 integer input parameters and returns a random int somewhere betweeen them (inclusive).

Video: Console User Interaction

A console, also known as a shell or terminal, is a user interface which allows programs to interact with humans through text. Unlike graphical user interfaces, a console does not allow for images, sound, video, or even mouse input.

The print() function displays a value to the console user. It does not return a value, so it can not be part of an expression.

The input() function returns a string typed by a user in the console. It takes 1 input string parameter to display as a question prompt for the user. As input() always returns a string, we frequently use the data type conversion functions to change the value to an integer or a float.

Computers make decisions that give the illusion of "thinking". For example, a digital thermostat turns on or off the heater depending on the current temperature in the room. IBM’s Big Blue computer decides what chess piece to move next when beating world chess champions. Google’s self-driving car decides when to apply the brakes depending on what is in front of it. All computer decisions are based on conditions built out of a simple logic called Boolean logic.

Video: Boolean Values

The boolean data type has just 2 possible values; True and False. This contrasts with the other data types (int, float, string) that have near-infinite possible values. The True and False values always start with a capital letter. The following example assigns the boolean value of False to the variable a.

Video: Boolean Operators

Just like ints have numeric operators (+ - * /), booleans have their own operators. The 3 boolean operators are and, or, and not.

The and operator takes 2 boolean inputs and returns True only when both inputs are True, False otherwise.

The or operator takes 2 boolean inputs and returns True when at least 1 input is True, False otherwise.

The not operator takes 1 boolean input and returns the opposite (negated) boolean.

Video: If Statements

Boolean logic allows a program to make a decision based on a condition. The if statement executes specific lines of code only when the condition is True. If the condition is False, the lines are skipped. The lines of code to be executed are grouped with indentation (tabs or spaces) into a block. Code blocks are always preceded by a colon (:).

As we learned above, if statements will either execute or skip 1 block of code depending on the condition. In some situations, we want to choose between 2 blocks of code depending on the condition. This can be done with the if …​else…​ statement.

Video: While Loops

As we learned above, the if statement allows us to execute a code block one time if a condition is True. The while statement, on the other hand, allows us to execute a code block repeatedly while a condition is True. This allows our code to loop potentially infinite times. To prevent infinite looping, the code block typically modifies the variable used in the condition. For example, the value of x is increased with every loop in the code snippet below.

While loops are often used to validate user input. Users will often enter incorrect data repeatedly (invalid birth month for example). We can use a while loop, along with a condition for invalid data, to repeatedly ask the user for valid input. Notice what happens in the example below when the user inputs numbers like 14, and 112, before entering a valid month.

In this chapter, we will use two new EarSketch functions which will be very useful for the rest of the course, fitMedia() and makeBeat().

At the end of the last chapter, we used while loops with insertMedia() to repeat clips many times in a row. This is such a useful feature for making music that EarSketch provides a built in function to do this without a loop, the fitMedia() function.

fitMedia() takes four arguments:

The ability to specify the end location gives the freedom to play only a short segment of a clip or to automatically repeat it as much as needed such as in the example below.

Strings in Python can vary in length from 0 characters to millions of characters (limited by the computer’s memory). As such, we often need to break down strings into shorter fragments or individual characters in order to process them. String processing starts with the concept that each character in a string has a unique index which represents its position in the string. Indexes start with the first chracter at position 0, and end with the last character at position length - 1. The indexes for the string "Hi There" are below. Note that the string is of length 8, and thus has indexes from 0 to 7.

Individual characters can also be identified with reverse indexes starting with the last character at position -1, and ending with the first character at position -length. The reverse indexes for the string "Mr. Bob" are below. Note that the string is of length 7, and thus has reverse indexes from -1 to -7 right to left.

Video: Accessing Characters and Slicing

We can access individual characters of a string by using the square bracket ([]) notation along with an index. The code snippet below shows how square bracket notation relates to the characters in a string.

Video: Accessing Characters and Slicing

We can access slices or substrings of a larger string by using the bracket notation and two indexes separated by a colon (:). The first index specifies the starting point of the slice, while the second index specifies the stopping point of the slice + 1. This is known as incluse:exclusive notation.

Video: String For Loops

In many situations, we want to access every character of a string one at a time. Although this could be accomplished by using each index from 0..length - 1, it is much more convenient to use the for loop. The for loop creates a new variable, stores the first character of the string in it, and repeatedly executes the attached block. Each time the block is executed, the next character is stored in the new variable.

Lists are collections of values combined into a single entity. They enable a single variable to store multiple values, like a cubbyhole holding different items in each space. Lists can be created manually with brackets ([]), or by using functions like range() or string.split().

The range(a, b) function returns a list of integers from a up to, but not including b. Thus range(2, 5) returns [2, 3, 4].

The indexes of each value in a list are identical to the indexes for each character in a string. They start with the first value at position 0 and end with the last value at position length - 1. The indexes for the list ["Apple", "Plum", "Kiwi"] are below. Note that the list is of length 3 and thus has indexes from 0 to 2. Reverse indexes are also supported.

Video: Accessing and Modifying List Values

We can access individual values of a list by using the square bracket ([]) notation along with an index. Furthermore, we can modify any value in a list with the same bracket notation and the storage (=) operator.

Video: List Appending and Slicing

We can append to lists with the concatenation operator (+). We can also slice a list using the bracket notation and two indexes separated by a colon (:). The first index specifies the starting point of the slice while the second index specifies the stopping point of the slice + 1.

Video: For Loops with Lists

Much like when using strings, we often want to access every element of a list one by one. We can use a for loop to repeatedly execute the attached block; once for each value of the list.

Video: For Loops with Indexes

Loops over a list of indexes created by the range() function allow us to do more complex processing like running through two lists at the same time, modifying lists, searching for the index of certain elements, using multiple indexes in the same list, and more. Follow the code below closely.

In Chapter 3, we introduced functions like len(), print(), input(), str(), int(), randint(), range(), and more. Calling these functions has been fundamental to most of the examples in the book. A function call typically takes 1 or more input parameters. For example, to call the print() function, we specify 1 string input parameter. This function then displays the string to the console user.

In this chapter, we will use a new version of the setEffect() EarSketch function which will be very useful for the rest of the course.

Video: Defining Functions

Before a function can be called, it must be defined. Every function we have used this semester has been pre-defined for you by other programmers. Here, we introduce how to define your own custom functions. Once defined, you and other programmers will be able to use them like any other function. Thus, by defining your own functions, you are adding new functionality to Python. The fundamental approach to solving large programming problems is breaking them down into small function definitions, and then calling those functions to solve the original complex problem.

As an example, if we are writing a game that needs to print out player names surrounded by star (*) characters, we might want to define our own function called star_print. The function will need an input parameter for the players’s name, and will then print out the name surrounded by * characters. Once defined, the function can be called as many times as needed.

Video: Return Statements

Many functions return a value. The return value can then be stored in a variable, or used as part of a complex expression. To make a function return a value, use the return statement.

As an example, we might want to define a function, called repeat_string, that returns a new string by repeating a simple string multiple times. The function will need two input parameters; one for the string to repeat, and another for the number of times to repeat it. The function will then return the newly created string.

Video: Combining Functions

Once defined, a function can be called from anywhere, including other function definitions. This allows us to take a complex problem and break it down into smaller problems.

For example, if we want our original star_print() function to print out more stars for longer names, we can call our repeat_string() function from inside the star_print() definition.

In this book, we have covered 3 basic ways of getting data into programs:

In this chapter, we introduce a fourth way of getting data into programs: text file input. This is a common technique for programs which analyze data intensive systems like stock markets, social media websites, science experiments, etc.

In chapter 6, we introduced the string.split() function, which takes one big string and breaks it up into a list of smaller strings. The function uses a character (specified by the input parameter) to determine how to split the big string. Data text files are typically composed of lines of text separated by the new line character, that like the space character, is invisible white space but important. In Python the newline character is written "\n". Follow the example below to get a refresher on split() and the "\n" character.

Video: Reading and Splitting Text Files

Python can open and read the entire contents of a text file with two simple functions: open() and read(). The open() function finds the file on the file system (hard drive). The read() function loads all of the contents of the file into one string value.

Once a file has been read, we can use the split() function with the newline ("\n") character to create a list of lines. We can then split any individual line to get a specific item on that line.

Assume you have a text file called mary.txt with the 4 lines below. Notice how there are newline characters between each sentence and space characters between each word.

The following code would read the entire file, grab specific words out of the file, and print them out.

The most common data file format is called the CSV file. It is composed of lines of comma separated values. Look at the example file for daily high temperatures in US cities. Notice how each line is composed of a city name, a date, and a temperature all separated by commas.

The following example assumes the file has 2 lines and has been read into the variable big_str. It loops through all contents of the file grabbing each value in a separate variable and converting data types when necessary.

When working with large data sets, users usually want traditional visualizations such as charts and graphs. There are situations, however, where data can be turned into a more artistic perceptions such as digital paintings or sounds. This section explores how we can use sonification in EarSketch to create auditory perceptions of data.