We are declaring variables using the assignment operator (=). Declaring m = 2 means: create a variable called m that refers to the integer value 2 stored in memory. We can then use the variable m throughout the rest of our program.

Variable names are case sensitive.

No spaces allowed in variable names.

Also can’t start with a number.

The variable declaration syntax is always <variable> = <value> or <variable> = <expression>.

Switching the order (value = variable) doesn’t work!

You can use variables on either side of the assignment operator. Just remember that the right side (the value or expression) is always evaluated first, then assigned to the variable on the left side. That allows something like this (increment a variable) to work:

The second line above says: get the value referred to by counter, add 1 to it to make a new value, then store that new value in memory in the location that the counter variable refers to. So we pull out what is stored there, make a new value, then store the new value back in the same spot.

The main data types in python are: integer (int), string (str), float, list, and boolean (bool). There are others (e.g., tuples and dictionaries), but these are the main basic types.

A data type is defined by it’s possible values and the operations that can be performed on those values. For integers, the possible values are all integers (0, 1, 2, …​, and the negative integers -1, -2, …​), and the operations are addition, subtraction, multiplication, and so on. The boolean data type has just two values: True and False (must be uppercase).

The data type really matters for some things!

The first line above uses floating-point math, and probably does what you were expecting. The second line does integer division (i.e., ignores any remainder).

For the string data type, multiplication by integers is allowed/supported, but multiplication by floats is not.

The same is true for lists:

In python you do not need to declare what type to store in a variable, so you can freely reassign different types to the same variable (not recommended!).

This is a tradeoff! Python code is usually shorter and cleaner than other languages, because we don’t have to write out what type everything is (variables and functions). However, this can often lead to other problems (e.g., if you expect x to be a float, but it’s a string) or slower code (sometimes the computer can optimize your code for you, if it knows the type of every variable and function).

Sometimes it is useful to check if something is an instance of a certain data type:

See also:

A function is just a block of code with a given name. You use the name followed by parentheses to call the function: print("hello"). Calling the function executes the code block. After the function executes, the program that called the function continues running.

Using functions, either built-in or creating your own, is the primary way to manage code complexity. As you start to write larger programs, you will break large tasks into smaller, manageable functions.

In all of the function calls above, an argument is provided inside the parentheses. In print("hello"), the print() function is called with the string argument "hello". The arguments are just data sent to the function. Functions can have zero or more arguments. Here’s a call to print() with 3 arguments:

Sometimes, but not always, a function returns something to the program that called the function. In x = int(5.371) the float 5.371 is sent to the int() function, which converts (truncates) it into an integer (5), and returns the result (the 5). This result is then immediately assigned to the variable x.

Here are some useful built-in python functions:

The input() function is used to get input from the user. It will pause the program, waiting for the user to type something and hit Enter. The argument provided becomes the prompt to the user.

Note the input() function always returns a string, no matter what the user enters (characters, digits, etc).

If you know the user is going to enter a valid integer, you can use the int() function to convert the input string to an integer:

But this won’t work if the user enters something that can’t be converted to an integer:

See later sections (while (indefinite) loops, try/except) for ways to handle invalid input.

The built-in input() function allows the program to prompt the user for input, then wait for a response.

The argument (a string: "Pick a number…​") is displayed to the user. When the user types in a response (the 4) and hits the "Enter" key, the input data is returned to the program. In the above example, the "4" is returned and immediately assigned to the variable number.

The input() function always returns a string, no matter what the user types (letters, digits, punctuation, etc). If you are expecting the user to enters integers or floats, and your program needs integers or floats to work, you will need to convert the user input to the correct data type:

See the try/except section for better ways to check for and convert valid user input.

This code asks for the user’s name, then uses it in the next prompt that asks for when the user was born. The second input is automatically converted to an int and assigned to the year variable. Here’s a sample run of the above code, where the user enters "George" and "1732":

See also:

The print() function can print strings, ints, floats, and other data types. When printing multiple types together, separating them by commas is easiest (useful for debugging!), but doesn’t allow formatting. Using String Formatting is best for complex formatted output.

When printing a large block of text, it is often easier to use a triple-quoted string, which you can format exactly as you want it to display over multiple lines:

See also:

You can even create strings with this and use them as needed:

In both of these examples, a sting is created by substituting the variables at the end in for the format specifiers (the %s, %d, and the %f). The variables must be in the correct order, so the first variable (year) is substituted for the first format specified (%d).

And here’s what the format specifiers mean:

You can also include width and precision information in the format specifier. For example, the %.3f in the above examples means we want only 3 digits after the decimal in the float.

If I were printing out numbers that I want to all line up (maybe dollar amounts), I could specify the width of each output string. For example:

The %7.2f means I want all floats printed with a width of 7 and with 2 digits after the decimal. Notice that after the dollar sign, all floats have a width of 7 characters (the decimal is one of the 7 characters). If the float doesn’t already have a width of 7, it is padded with spaces on the left side as needed.

There’s also a newer .format way to handle string formatting. Here’s an example of the above using the newer syntax:

See also:

Note: I don’t type the dot dot dots (…​). That’s just the python shell telling me it expects something more — the indented code block of the for loop. On the last line, before the "Hello…​" output, I just hit the Enter key (no indentation).

for loops are great when we want to repeat something, and we know how many times we want to repeat. In the first example above, we want to print a greeting for however many names are in our list of names. In the second example, we want to create and print something limit times.

The for loop syntax is:

The variable is any name you want (but choose good variable names, unlike this next example!):

And the variable takes on all values in the sequence, one at a time. Each time the variable gets a new value from the sequence, the indented code lines (i.e., the code block) are executed.

There must be one (or more) indented code lines in the for loop. The next unindented line ends the code block! So if I had this:

It would print this (see how the dashed line is after or outside the for loop!):

The sequence in a for loop can be many things: a list, a string, or even a file. If the sequence is:

Here’s a string sequence example:

These examples may all seem trivial or a little silly, but for loops are very important! As we learn more python, we’ll see some more useful examples.

See also:

The counter variable is an example of an accumulator. It starts at zero, and we check each data value in the list. Each time we find one that meets a certain condition (here, less than zero), we increment the counter variable. At the end of the for loop we have built-up/accumulated the answer (how many values are less than zero).

This accumulator pattern (initialize to zero, build up solution one item at a time) arises in different situations, and can be reused to solve problems in these different areas.

Here are some examples:

Here’s the "keep a running sum" example mentioned above. In this example we are getting numbers from the user, then calculating and displaying the average of those numbers.

You can also build-up/accumulate strings, starting with an empty string. What do you think this for loop will print to the screen?

Note: the += operator is shorthand for assignment addition. So the output += "*" line above is equivalent to this:

The above code prints a different message, depending on the value stored in the height variable. There are three branches in this if statement:

Each branch is a code block. Just like the for loop, the code block is indented, and can be one or more lines long.

The syntax of the if/elif/else statement is:

The boolean expression can be anything that evaluates to either True or False.

If one of the boolean expressions is True, that code block is executed and no further branches are tried (i.e., the program jumps down to the code that comes after the if/elif/else statement and carries on from there).

You can have a single if statement all by itself:

You can also have just two branches (no elif):

You can have three branches as shown above, or as many branches as you need:

In the last example, if grade has the value 85, the first boolean expression (grade >= 90) is False, so the computer goes on to test the next expression (grade >= 80). Since this one is True, it prints the B and then skips all further tests and would carry on with any code located below/after the if/elif/else statement.

Here are the boolean comparison operators:

Python allows string comparisons (see ord and chr for how):

There is also a membership operator (in) that is really useful:

You can also combine boolean expressions with and, or, and not:

For and: both conditions must be True to execute the code block.
For or: the code block will be executed if either or both are True:

In the above example we define the function called celsius. It has one parameter: a varible named tempF, which presumably holds the temperature in degrees Fahrenheit that we want to convert to degrees Celsius. Given tempF, we calculate the temperature in degrees Celsius and store it in a variable called tempC. Finally, the function returns the data stored in tempC back to whoever called this function.

The next three lines above just show three examples of calling the function. In the first example (celsius(72)) the argument in the function call is the integer 72. This means, in the function, tempF is assigned the value of 72. In the second call, the argument is 32, and the function calculates and returns 32F converted to Celsius.

As you can see, functions are extremely useful if we ever have to perform repeated calculations. They can also make our programs more readable, if we choose good function names. And they greatly reduce complexity for larger programs, making them both easier to read and to design/write.

The syntax of defining a function is:

The name of the function can be almost anything (no spaces, can’t start with a number, similar to variable names). A function can have zero or more parameters. The body of the function can be one or more lines (every indented line is part of the function). A function may or may not return anything to the calling program.

Here’s an example of a function that just prints stuff and doesn’t return anything back to the program that called the function:

Calling the above function as poem("red", "blue") produces this:

And calling the function as poem("black", "pink") produces this:

This function calculates the average of all numbers in the given list, as it says in the triple-quoted comment (the first line under the def statement). All functions should have a comment under the def statement, as it helps the reader to understand what the function does, and is also part of the built-in python help documentation.

See also:

Above we define a short function called main, and then call the function on the very last line. Remember, for functions, anything indented is part of the function, so the first unindented line (in this case, the call to main()) marks the end of the function definition above.

Most programs have a main function that drives the whole program. Reading through main() should give the reader a good overview of what the whole program does (like an outline). And just like other functions, if main() is more than one screen, it’s probably too long (and should be broken up into more functions).

A common practice is to put def main() as the first function defined in the file, with others below. This makes it easy to see/find when you open the program for editing.

As you can probably guess, the above is a main() function from a simple game. Another function (printRules()) is called to display the rules of the game, then the board is displayed and the user takes a turn. This repeats (display, turn, display, turn, …​) until the game is over.

See also:

Each character in a string has a position, also called an index. In python, positions start at 0, so the "h" in the above string is at position 0, and the "o" is at position 4 (note: one less than the length of the string).

You can access individual characters in a string using square-bracket indexing:

Any sequence in python can be used in a for loop. For strings, we can either loop over characters in the string or indices (0 to len(S)-1). Here are a few examples:

Strings are immutable, which means you cannot change individual characters in a string. For example, this doesn’t work:

However, you can create new strings from parts of existing strings. Slicing (using [:] to pick out part of the original string) and concatenation (using the + operator) are useful for doing this:

Here are some more slicing examples:

A list is a sequence of items, where each item could be anything (an integer, a float, a string, etc), even another list!

Like strings, lists have a length: the number of items in the list.

Each item in a list has a position, also called an index. In python, positions start at 0, so the string "pony" in the above list is at position 0, and "zebra" is at position 2.

You can access individual items in a list using square-bracket indexing:

Any sequence in python can be used in a for loop. For lists, we can either loop over items in the list (see names list above) or indices. Here is an example using range() to loop over indicies:

Unlike strings, lists are mutable . This means their contents can be modified, without having to create a new list.

The in (membership) operator also works for lists:

Here’s a list-of-lists example:

See also:

Using square-bracket indexing and the slicing operator (":"), the last[0:6] statement grabs just the first six characters (0 through 5) from the last string.

The slicing syntax is [start:stop], meaning grab all items or characters from index start up to but not including index stop.

In the list example, L[2:5] grabs items from the list from positions 2 through 4 (does not include item at position 5).

Leaving off the start (e.g., L[:2]) defaults to the beginning of the sequence. Leaving off the stop (L[5:]) defaults to the end of the sequence.

It’s also OK if the stop is past the end of the sequence:

See also:

Both python strings and python lists are examples of objects. An object is just some data plus some methods (similar to functions) wrapped up together into one thing.

The string methods used above are:

There are many other str methods. In string objects, the data are the characters in the string.

The list methods used above are:

In list objects, the data are the items in the list.

Methods are always called with the dot syntax: object.method()

Again, methods are similar to functions, except they are tied to the type of object, and are called with this special syntax.

This example uses the Zelle Graphics Library.

Three objects are created: a graphics window, a point, and a circle. The circle is centered at the point’s location (x=10, y=20), and has a radius of 50. The next line calls the Circle’s draw() method to draw the circle in the graphics window. The last line moves the drawn circle 150 pixels in the x direction.

See also:

Here’s an example of importing the python math library, to gain access to the sqrt() function:

Running the above code would produce this output:

In python there are two common ways to import libraries:

The example on the left is typically used in our intro courses, as it requires less typing and makes short codes easier to read.

For larger, more complex codes, the example on the right is preferred. Calling the function as math.sqrt() avoids any possibility of two functions from different libraries having the same name (i.e., if they did have the same name, calling them as library.function() would allow us to know which library each was from).

Some useful python libraries include:

To see documentation on any library, simply import the library and then call the help() function:

Use 'q' to quit the help documentation.

Usually all import statements are at the top of the file, before any code or function definitions:

You can also just import one function if you know that’s all you need:

See also:

To use the random library, we first need to import it.

The randrange(start,stop) function picks a random number from start to stop - 1, so the above example is choosing a random number from 1-100.

The choice(sequence) function picks a random item from a sequence (here a python list).

See also:

Sometimes you want to repeat a code block, but you don’t know exactly how many times to repeat. For example, in a game like tic-tac-toe, you might want to get the player’s move, then update board, then get the next player’s move, and so on, until the game is over. The "get move, update board" code might be executed 5 or more times. This is called an indefinite loop.

Here’s an example using random numbers, so we don’t know how many times the code block will run, and each time we run this code the output will be different (because the random numbers chosen will be different):

Here’s one example of running the above code:

The above while loop keeps picking random numbers as long as (while) value is less than limit. Note that in the code block (the indented code below the while value < limit line), it is possible that value will be changed (increased by 2), if the random number chosen is greater than 6.

The while loop syntax is:

This looks just like the if statement, and it is, except that after the code block is run, we go back to the top and re-check the boolean expression. If the boolean expression is still True, we run the code block again. As long as (while) the boolean expression evaluates to True, we’ll keep running the code block. After each run of the code block, we re-check the boolean expression to see if it is True or False. Once it’s False, we skip the code block and continue on with the rest of the program.

Don’t confuse the if statement with the while loop!

Both of those will execute the "do this line" if x is less than 20. The while loop will then go back and re-check if x is still less than 20, where the if code will continue on with the rest of the program.

What do you think this code will do?

This is an infinite loop, that will just print 0 and a dashed line over and over and over. You can use Ctrl-c to kill a program stuck in an infinite loop.

Have you ever used Duolingo, where the owl cheers you on, and notices when you give the correct answer three times in a row?

And here’s one possible run of the above code:

See also:

A variable’s scope refers to where a variable is valid. For example, in this program with two functions, main() and times2(), the variable factor is in scope (i.e., valid) only in times2():

If we added a print(factor) statement in main(), the program would crash, since factor is not defined or valid in main():

Similarly, the variable x is only valid (in scope) in main(). Trying to use x in times2() would also cause a runtime error.

Furthermore, it does not matter what the factor variable in times2() is called! We could name it x, but that would be a different x than the one defined in main().

Here’s the code again, this time with the variable in times2() defined as x:

And here’s the output from running that code:

Notice that the x printed in main(), after the times2() function was called, still has the value 5 (even though the x in times2() was set to 10).

You can easily see a variable’s scope if you view the program’s stack diagram using the python tutor. Here’s an image of the above code (with x in each function) running in the python tutor:

On the right of that image are three stack frames: Global (which we are ignoring), main, and times2. We have used the python tutor "Forward>" button to step through the program, one statement at a time. First main() was called, then main() called times2() on line 3, and we are currently stopped at the end of times2() (line 9), about to return x.

For the stack, each time a function is called, a new stack frame is created and placed "on top" of the stack. All of that function’s variables are defined in that stack frame and have local scope. As you can see, there is an x in main() with value 5, and there is an x in times2() with value 10. Even though we used the same name, there are two different x variables. Each variable is local in scope to that function.

The stack is useful for seeing what variables are in scope, but also for keeping track of where we are in the execution of the program. If main() calls functionA() and functionA() calls functionB(), the stack would look like this:

In the python tutor the stack is always drawn increasing toward the bottom of the window, but it is more useful to think of the stack as a stack of trays or dishes: the one on top is the current tray/dish (the one you would grab). The function on "top" of the stack is the one currently running. When that function finishes and returns, control drops back to the function one "below" on the stack.

This is how the "Back" button on your browser works, or the "Undo" option in an editor works. All visited web pages (or editor changes) are kept in a stack. The item on "top" of the stack is the current item. For the browser, if you hit the "Back" button, the page on top of the stack is removed and the browser goes back to the previous page (the next page down in the stack).

In python, mutable objects are not copied to local variables in functions. Instead, they are passed to functions by reference. This means, for example, if you send a python list to a function, and in that function you change an item in the list, that change will be visible back in main():

Here’s the result of running that program:

You can again easily see this in the python tutor:

See how both L in main() and mylist in change2() both point to the same list data! Both variables refer back to the same list stored in the memory of the computer. Assigning mylist[2] in change2() to some other value ("pony") has the side-effect of also changing L in main(), since they both refer back to the same list.

This feature is useful, but often confusing to first-time programmers.

It is useful, say, if you pass a 1-million-element list to a function. If python made a copy of that list, it would take time and be inefficient.

It is confusing because the function can change items in a list (or any items in a mutable python object), and those changes are seen outside of the function, and the function doesn’t have to return anything. This is exactly the opposite of what we talked about above, with variables in functions and local scope.

Here’s a simple example of using a function that modifies a list without returning anything from the function:

See also:

The variable infile stores the file object returned by the open() function. We have opened the file named "poem.txt" for reading (using the "r" argument). The readlines() method reads in all lines from the file and returns them as a list of strings. We assign this list of strings to the lines variable. Note how each line from the file ends with a newline character (the '\n').

For file objects, here are the frequently-used methods:

Files are another example of a sequence in python (like strings and lists). We can use sequences in for loops, so we could also read in all lines from a file like this:

This does exactly the same thing as the previous example. It’s just shown here as an example of iterating over each line in the file. Sometimes you want to process the data line-by-line, as you read each line in (instead of reading them all in at once with readlines()).

Imagine you are a teacher, and you want to keep track of your students and their grades for the semester! :)

Here is a Student object (in a file called student.py), where all students have a name, class year, username, quiz grades, and lab grades:

The code in the def main() part at the bottom is solely for testing purposes (for the person writing the class), and it is not part of the class definition. It is run only if the file is run: python3 student.py, and not if the file is imported (from student import *). This test code is very simple, and just tests some of the methods. It also shows how to use the class.

In the test code you can see two different student objects (s1 and s2) are created by calling the name of the class: Student(…​). Calling the name of the class invokes the constructor method: __init__(…​). This creates the object with the given data (name, year, username). In this particular case, it also creates the empty lists that will hold the student’s quiz and lab grades.

All of the self.xxxxx variables in the constructor are data stored in each object. The self part refers back to which object (e.g., s1 or s2). So the class year 2020 is stored in the first object’s self.year variable, and the username "lwagner2" is stored in the second object’s self.username variable. If you want data stored in an object, create a self.xxxxx variable in the class constructor (the __init__() function). These self.xxxxx variables are sometimes called instance variables, because they exist for every instance of the class (i.e., all Student objects).

Note how the self.xxxxx variables are used in the other methods (like currentGrade()), and they don’t have to be passed around as arguments and parameters. Any self.xxxxx variable defined in the constructor (__init__()) can be used in any other method in the given class.

After the objects are created, we can modify or access the data stored in the objects using the other methods in the class. For example, the teacher might want to add grades to each student object:

These two methods add data to the self.quizzes and self.labs variables. Methods are just like functions, but they belong to a specific class, and are called using the object.method() syntax.

The str method is automatically invoked anytime an object is printed (e.g., print(s1)). You can control how you want your object’s data to appear by changing the string that __str__ returns. This method is often very helpful when debugging a class, as you can print your objects and see what data they contain.

In OOP, it is often useful to keep in mind these two roles: the person writing the class, and the person using the class. Sometimes you’re doing both, but other times you may just be using a class someone else wrote.

The methods in the class definition provide the class user with ways to interact with the object and it’s data. If you are writing a class, you need to think about how people will use the class, and provide methods for all that they might want to do. If you are using a class, you’ll need to study the methods for how best to use the objects, and what operations are possible.

Suppose I want to write a stats program to keep track of data on all NBA players. I could make a python list for each player, where in the list I store the player’s name, team, total points scored, etc. But then my whole program would involve lists and indexing, and be much harder to read (e.g., player[0] would be the player’s name, player[1] would be the player’s team, etc).

Instead, let’s make an NBAPlayer object and store all data for a player in the object:

Now the user of this class could write code like this to keep data on a particular player:

Running the above code produces the following output:

See also:

Suppose you wanted to convert letters into their equivalent Morse Code dots and dashes:

Here the letters ('a','b', and 'c') are the keys, and the dot/dash strings are the values. The first line creates an empty dictionary (using curly-braces). The next three lines add key-value pairs into the dictionary.

If we had the full Morse Code dictionary defined:

then we could use it to lookup values, given letters. Here’s a quick example:

This would print three dots for the 's', then three dashes for the 'o', and then another three dots for the last 's'.

Dictionaries are useful for any kind of key-value lookup system. For example, usernames and passwords:

Given a username (e.g., 'jake'), we can lookup the password in the dictionary (passwords['jake']).

There are a variety of useful methods for dictionary objects:

The last example shows dictionaries can be used in a for loop, with the loop variable becoming each key in the dictionary.

See also:

Tuples are useful if you want a list-like data structure, but you want to make sure it can’t be changed later in the program. They can also be used as keys in Dictionaries.

We don’t use tuples much in CS21, but they are included here so you know what they are. Sometimes they are mentioned in error messages. Here’s the most-common error involving tuples in CS21 (forgot to use 'Point' when defining a graphics point object):

This is also not used much, and somewhat discouraged in CS21, but returning multiple items from a function will automatically put them in a tuple:

Here’s the output from running the above function:

See also:

Sometimes it is useful to compare letters and strings, or to do "math" on letters (e.g., if I have a letter, give me the 5th letter after the one I have).

The computer is able to compare letters and strings because, underneath, the computer just sees letters as numbers. This is called an encoding, and one of the most-famous encodings is the ASCII encoding:

So the computer sees the letter 'a' as 97, 'b' as 98, and 'c' as 99. That’s why these work:

ord() and chr() allow you to convert back and forth between letters (or punctuation and other characters) and their ASCII encoding numbers.

In the above example we use ord(letter) to turn the letter into a number, add 3 to it, then use chr(newnumber) to get the letter for that new number. If the letter were an 'a', the newletter would be a 'd'. This is often used in simple cipher programs to shift letters in a string by some amount. The above example would print "dog grj".

Note: if the word was "xyz", what would the new "word" be? To be a "rotation cipher" the above code would have to test if the new number was past the end of the alphabetic characters ('z' or 122), and if so, subtract 26 from the new number.

Also, note that all of the capital letters ('A' - 'Z') are before the lowercase letters, so when comparing strings, make sure the case is the same!

See also:

And here’s what happens when we run that:

In the above example we try to convert the input stored in age to a float. If that succeeds, great, and the program continues with any code below the try/except block. If that fails with the ValueError exception, the except block is executed (the print statement).

If we combine the above with a while loop, our input statment now repeats until we get valid input:

Here we are using a boolean flag variable (VALIDINPUT) to control the while loop. The loop continues as long as VALIDINPUT is False. The only way VALIDINPUT changes to True is if the age=float(age) statement succeeds. Here’s how it looks to the user:

There are many different exceptions in python. You can use any of them in a try/except statement. Here’s another example, trying to open a file, using the FileNotFoundError exception:

See also:

In the above examples, only the fourth test fails (1+1==3) and crashes with an AssertionError. If tests that pass produce no output, you can add these statements to a test function in your code and periodically run the test function to make sure everything is still working (no news is good news).

Suppose I wrote a binarySearch(x,L) function that looks for x in the list L, using a binary search. Here’s an example of a function I might add, to test all possible cases I can think of:

If I run the testcode() function and see the "All tests passed!" message at the bottom, I feel confident that my search function is working. And if I ever make changes to my search function, I can just run the test code again to make sure I didn’t break anything.