An Introduction to Computer Science and Programming with Python

Think about each of the following, what has changed, and if there is software behind that change.

So why study computer science? Software impacts almost all aspects of our life, it might be good to learn something about it. Marc Andreesen developed Mosaic, one of the original web browsers, wrote a now somewhat dated but important article in the Wall Street Journal, Why Software Is Eating the World.

Python is a popular programming language used widely in industry and academia. It is used for everything from web programming, scientific computing, data science, to developing games. It is a powerful general purpose programming language and is often used in introductory programming courses because it is relatively easy to learn and get started with. So lets get started.

It is almost obligatory that Hello World be the first program one writes in any programming language. Here is our first Python program:

That is it, just the one line. And it does as you might expect, it prints the message Hello, World! on the console. But there is a lot going on in that one line, so lets break it down.

The built-in function print prints, to the console, the values between the parentheses. In this case the value being printed is the string literal "Hello World". A string literal in Python is a sequence of characters between double quotes or single quotes. More on string literals later.

The print function can take multiple values separated by commas.

produces the output

And we can see right here that 1) * is part of Python, 2) that a value is on each side of the * (syntax), and 3) that * must mean multiplication (semantics).

Pictorially we can think of a function as a black box (we may not know how it works) where values come in (represented by the arrow coming in on the left) and the function produces values (the return results represented by the arrow coming out of the box on the right).

Values that are passed to a function are called arguments. The second argument in the call to the print function above is the mathematical expression 3.14159 * 3.14159. In just about every programming language the asterisk character * represents multiplication. A value such as 3.14159 in mathematics is called a real number (a number with a decimal point). For reasons I wont go into now, in computer science and programming we call real numbers floating-point numbers, or floats for short.

There is a big difference between the string literal "3.0" and the floating-point literal 3.0.

Numbers without decimal points are called integers or ints for short.

Valid integer literals include numbers such as 0, 1, 2, …​ and also negative integers -1, -2, -3, …​

Floating-point literals include a decimal place, and include numbers such as 0.3, -0.3, .3, 3., -3.14159.

Python (as do most programming languages) supports specifying numbers using scientific notation. For example, in Chemistry and Physics, Avagadro’s number is \(6.022140857 \times 10^{23}\). Writing this out as 602214085700000000000000 is not very readable. In Python we can instead write Avagadro’s number as 6.022140857e23.

We can also use scientific notation for very small numbers. The mass of an electron is \(9.10938356 \times 10^{-31}\) kg. Again, writing this as 0.000000000000000000000000000000910938356 is not helpful. We should instead write 9.10938356e-31.

The radius of an electron is 0.00000000000000281792 meters. Express this number using Python’s scientific notation.

Let’s return to our simple program …​

It would be convenient to give the value 3.14159 a name. An obvious choice being pi. We do that in Python by defining a variable using an assignment statement.

And we can rewrite our program as

To the left of the = sign is a variable name and we read the assignment statement above as pi gets the value of the value on the right of =, in this case 3.14159.

Variable names in Python should be meaningful. We could have said

but this makes the code less understandable.

Variable names must start with either an alphabetic character (a - z, A - Z) or underscore, and may also contain digits. Variable names are also case sensitive, so pi, Pi, and PI are all different variable names.^[2]

The value on the right of = can also be an expression.

The Python program

would produce an error because the variable x does not have a value.

We can add notes to our program using a comment. In Python a one line comment starts with a hashtag and continues to the end of the line.

You can also use a comment to finish a line.

The arithmetic operators we will be using most are:

Python has many more operators than shown in this table, but this is all we will need for now. You can combine these operations in complicated ways including using parentheses. The normal order of operations you learned in grade school apply.

If there are two operators at the same precedence then they should be evaluated from left to right. For example 4 - 5 + 3 should be evaluated as (4 - 5) + 3 (which is 2) and not 4 - (5 + 3) (which is -4).

Modular arithmetic is important in computer science. Modular arithmetic is just arithmetic that uses the remainder after finding a quotient. For example, 7 // 3 is 2 with a remainder of 1. The remainder operator is %. In this case 7 % 3 is 1.

A couple of important properties to remember. If we are computing n % m and we know that n is less than m and they are both positive, then the result is always n. For example 278 % 455 is 278.

Computing the modulus of a negative number is also important, for example -1 % 12. Think of computing the modulus of a negative number as going counter clockwise around the clock. For example, -1 % 12 is 11, and -5 % 12 is 7.

-14 % 12 would be to go counter clockwise one full revolution leaving s with -2 % 12, which is 10.

Strings are an important part of programming. Strings often seem boring but they are part of every piece of software and are often central to applications such web searching, texting, email, DNA sequence analysis, and cryptography.

A string literal is a sequence of characters between double quotes.

Or single quotes.

But what if we want to include a single quote as one of the characters in our string literal? One way to do it is to use double quotes for the string literal.

This works because the outer double quotes demarcate the string literal and the single quote in don't is just a single quote character because it is inside the double quotes.

The following is incorrect.

Python can’t tell that the second single quote in isn't is part of the word but recognizes it as the closing quote matching the open quote.

Things can get pretty crazy. How about if we wanted to print the string He said "Don’t do it!". The issue here is that the string we are printing contains a mix of double and single quotes. The trick is that we need to escape one of the quote characters. For example, if we need a single quote to be the single quote character and not the start or end of a string literal we can put a backslash character in front of it.

The statement

produces the output

Spaces, like in writing, are used to separate words in Python and are often used to make code more legible. For example, in a print statement you can put a space after the comma that is separating values to print.

which might look slightly less cramped than

Spaces can also make code less readable,

is also valid — but ugly.

We will see later that indentation plays an important role in Python. For now just be aware that all Python statements that are at the same level (and we wont really know what that means until we get to more complicated Python) should be indented exactly the same.

Here is an example. The following program is in error because the second statement is indented one space.

We’ve already encountered ways in which we can violate the rules of the language. In computer programming we call these syntax errors.

Find the syntax error in each of the following:

Some syntax errors are just nasty and difficult to find. The following one line program looks like it should have a syntax error. It is nonsensical but shows a common mistake of leaving off the parentheses when calling a function. But the program actually runs.

As you gain practice you will be able to quickly find syntax errors.

Python’s input function allows the user to enter input from the keyboard. It takes a string as an argument and uses it as a prompt to display on the Python console. The input function is a different kind of function than the print function. The print function puts values on the Python console window whereas the input function produces a string value of the characters that the user typed.

It is common to have users enter numbers and then use the values in mathematical expressions. The formula to convert a temperature in Fahrenheit to Celsius is \(5/9(f-32)\)

Unfortunately f contains a string, not a number, and (f - 32) has an error because you can’t subtract 32 from a string. For example, if the user typed 75 it would be like trying to compute "75" - 32, which is as bad as trying to compute "hello" - 32. You need to first convert the value in the variable f to either an integer or a floating-point number using either the int or float function.

The function int takes a string argument and attempts to convert it to an integer and return the resulting integer. For example int("-36") would return the integer -36. The int function is also used to convert a floating-point number to an integer by truncating the decimal point. For example int(3.14159) would return 3. Sometimes int can result in a run-time error. For example int("3.14159") causes an error because the string cannot converted to an integer. What about int('hello')?

Here is our modified program:

Here is a sample run of the Fahrenheit to Celsius conversion program.

The result 28.61111111111111 has an unhelpful number of digits. It looks ridiculous. Python has a built-in function round that rounds a floating-point number to a certain number of decimal places. For example, round(3.157, 2) will round 3.157 to two decimal places, producing the value 3.16. Using this in our temperature conversion program:

Here is a sample run of the Fahrenheit to Celsius conversion program.

Python has many support libraries that we can use. Think of a support library as predefined functions and definitions that you can use. One such support library is called the math module. The math module contains many math related functions and some predefined constants. For example math.sin(x) computes the sin of the argument \(x\) (where \(x\) is in radians).

To use the functions and definitions in the math module your program first needs to tell Python that we need it using an import statement.

One way to compute the square root of a number would be just to raise to the 1/2 power.

Another way would be to use the math module’s square root function.

A constant defined in the math module is math.pi

We have already discussed syntax errors and run-time errors.

Recall that a syntax error is an error in how you put together the words and characters of your program. For example, a missing parentheses, or quote in a string literal. Syntax errors can be detected before you run the program and are often highlighted in whatever IDE.^[3] you are using.

A run-time error is an error that cannot be detected before program execution but only while the program is executing. Common run-time errors include dividing by zero or trying to convert the word hello to an integer. For example, consider the following simple program:

What would happen if the user entered a 0 at the input prompt? There is no way for Python to know what the user is going to type, and if they enter a 0, then the program will crash on line 2. If the user enters the word "hello" then the program will crash on line 1 when Python tries to convert "hello" to an integer.

At its most basic level everything about modern computing boils down to, at some base level, ones and zeros, true/false, on/off, yes/no, black/white. All information is binary. All decimal (base-10) numbers are expressed in binary (base-2). Digital images are just numbers, which are binary. Digital music on Spotify or Pandora, are numbers (hence binary) that represent sampled sound waves. Characters, letters, punctuation, all have a numeric equivalent, and are binary. Internet communication - binary, web pages - binary. Even computer programs get converted to binary. All information is binary.

An individual 1 or 0 is called a bit, for binary digit. Eight bits are a byte. We often talk of sizes of data in bytes. A megabyte (MB) is one million bytes. Strictly speaking when we use the term megabyte it usually means \(2^{20}\) bytes rather then \(10^6\) bytes. Below is a table of sizes, kilobytes, megabytes, …​

The CPU, (Central Processing Unit) or processor, carries out basic mathematical operations such as addition and multiplication. The CPU is connected to main memory where it can store numbers (bits). Main memory is fast and volatile. That is, when the power is turned off main memory loses any information that was stored. Also connected to the CPU and memory are other hardware components such as hard drives, graphics card, and network hardware. Hard drives are non-volatile memory. Turn off the power and they remember what was stored, they are also much slower than main memory.

Here is a high level layout of a computer.

The basic operations of the CPU are called instructions, and the binary representation of instructions is called machine code. Many programming languages are compiled languages are translated to machine code by a compiler, C being the most common compiled language, where the program is converted straight to machine code that is then directly executed by the CPU.

Python is a little different, it is not a compiled language but an interpreted language. What that means is that there is another program called the interpreter that reads the Python program and executes it directly. The Python interpreter itself is written in C.

Suppose x and y are variables that have been assigned values. What does the following code fragment do? (Hint: give sample values to x and y and follow the code).

Consider the following code fragment.

Write a program that converts a temperature in Celsius to Fahrenheit. Prompt the user for the temperature and print the conversion rounded to two decimal places. Make the output neat and descriptive.

Write a Python program that calculates the wind chill temperature \(W\) given the current temperature \(t\) (in Fahrenheit) and the wind velocity \(v\) (in MPH). The current temperature and the wind velocity should be entered by the user from the keyboard.
The formula the National Weather Service uses to calculate wind chill temperature is:

\(W = 35.74 + 0.6215t + (0.4275t - 35.75)v^{0.16}\)

Print the result rounded to one decimal place, like the 23.7 above.

The area of a circle with radius \(r\) is \(area = \pi r^2\). Write a program that prompts the user for a radius and computes and prints the area of the circle rounded to 3 decimal places.

The volume of a cone with height \(h\) and radius \(r\) is \(v = \pi r^2h/3\). Write a Python program that will read the radius and the height from the user and computes and prints the volume of the cone.

In the United States there is a birth every 8 seconds, a death every 12 seconds, and a new immigrant (net) every 33 seconds. The current population is roughly 325 million. Write a program that will prompt the user for a number of years and print the estimated population that many years from now.

Assume that \(C\) is an initial amount of an investment, \(r\) is the yearly rate of interest (e.g., \(.02\) is \(2\%\)), \(t\) is the number of years until maturation, \(n\) is the number of times the interest is compounded per year, then the final value of the investment is \(p=c(1+r/n)^{tn}\). Write a program that reads \(C\), \(r\), \(n\), and \(t\) from the user and computes and then prints the final value of the investment to the nearest penny.

Write a program that reads an amount of money that we need to make change for, and dispenses the correct amount of change (in U.S. currency). Assume that the 20 dollar bill is the largest denomination. Here is an example execution of the program …​

The distance \(d\) of a point \((x,y)\) from the origin, by the Pythagorean theorem, is \(d=\sqrt{x^2+y^2}\). Write a program that reads an \(x\) and a \(y\) from the user and computes the distance of the point from the origin.

The distance between two points (x₁,y₁) and (x₂,y₂) is also easily derived using the Pythagorean theorem. It is \(d=\sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}\). Write a program that reads two points from the user and computes and prints the distance between the two points.

Every discipline has its own terminology (or nomenclature). Terminology is what allows us to communicate intelligently with accuracy and precision about a discipline both amongst other programmers and to the lay-person.

We have encountered several functions this chapter.

Before we talk about drawing shapes on the window we need to know how to represent a color. A common color scheme is called RGB, for Red-Green-Blue. In Pygame a color is a triple of three values where (0,0,0) represents black all the way up to (255,255,255) which is white. There are roughly 16 million different colors we can represent. Red is (255,0,0), green is (0,255,0), and blue is (0,0,255). Yellow is red and green, so that would be (255,255,0).

One common thing many of our Pygame programs will do is to define some colors.

We will soon get tired of retyping color definitions in our Pygame programs. We can place these definitions in their own file and name it color.py. We can then import color.py into our Pygame program with import color and voila! we have created our own Python module named color and we can reuse our color definitions without having to retype them every time.

In this section we learn how to draw basic shapes; a circle, ellipse, rectangle, line, and a single pixel on a surface.

Answer questions about the following code fragment.

So far we have encountered six different kinds of Python values. For example, integers are one. Name the others.

Write a Python/pygame program that reproduces the smiley below.

Lets get a little more formal about calling functions. Consider the statement

We say that we are calling the print function and passing the argument Hello World. Passing an argument means we send the value to the function.

Consider our previous program where we needed to compute \(sin(\sqrt{\pi/4})\) …​

How many function calls are there in the two lines above? Explain all of the arguments and return values.

The real power with functions is that programmers get to define our own. Functions allow us to encapsulate commonly occurring computations. Lets go back to our rather banal example of our formula to convert a Fahrenheit temperature to Celsius. Rather than having to keep remembering the formula we can just define a function.

Lines 2 and 3 constitute the function body, which is indented under the function header.

We now have our own function for converting Fahrenheit to Celsius and we can tuck it away in a file somewhere so we can reuse it later.

We can use f2c in a program by calling it with an argument.

We call this the main program. The main program is any code that exists outside of a function.

Why is the following line incorrect?
f2c(32)

It is a common mistake for students to confuse a function returning a value and a function printing a value. Consider this version of f2c.

This function returns the value None and, as a side effect, prints the value of the variable c on the console. This function is not technically wrong. It does not have a syntax error, nor a run-time error, or even a logic error. But it is in some way inferior to the first version of f2c. Consider the following program.

This program reads a temperature from the user and puts it in the variable t. It then converts t to Celsius and adds 100 degrees Celsius to the result and printing the final value. For the first version of f2c this works fine. But the second version crashes because it tries to add 100 to None.

Functions return values. Some functions, such as print, return None but are used for their side effect.

Recall our complete blockhead program from before.

What if we wanted to draw two or more blockheads on the display surface? One way is to make another copy of the code, and change lots of variable names etc. This is a perfect situation where we can write a function blockhead that we can call more than once.

In keeping with the way drawing rectangle works specifying the Blockhead’s \(x\) and \(y\) coordinate along with its width and height makes sense:

This is just the function header. The Python statement pass is the statement that does nothing. We are using it here as a placeholder for the function body, which we have not yet written.

So what we’ll do now is place all of the code used for the drawing inside the function and make sure that we use the parameters to initialize the

Now we can call the draw_blockhead function as many times as we like without having to duplicate lots of code. The variables head_x, head_y, head_w, head_h are parameters and they can be used anywhere in the function body. That is their scope.

All of the other variables that are defined in the function are local variables. A local variable’s scope is from the point where where it is defined until the end of the function.

The draw_blockhead function still uses the variable win, which is neither passed as a parameter nor is it defined with the function. The function assumes win is defined in the main program. We say that win is a global variable.

Write a function circ_area that that takes the radius of a circle as a parameter and returns the area of the circle. Write a main program that reads the radius from the user (keyboard) and prints the area.

Answer questions about the program below.

What is a built-in function?

Assume that C is an initial amount of an investment, r is the yearly rate of interest (e.g., .02 is 2%), t is the number of years until maturation, n is the number of times the interest is compounded per year, then the final value of the investment is \(p=c(1+r/n)^{tn}\). Write a function investment that takes C, r, n, and t as arguments and returns the final value of the investment to the nearest penny. Test your function with a main program where \(C = 1000, r = .01, n = 1, t = 1\).

One modification is that we can animate the particle moving across the screen smoothly. Rather than redraw the particle two radii, shift the particle by just one pixel. We can also add a delay. Finally before we redraw the particle we can erase the display. This is a standard way of an animating an object in computer graphics:

So far we have only used the less than relational operator < that compares two values. Table Relational Operators lists them all.

Animate moving the particle to the bottom of the screen.

Animate moving the particle from right to left.

Animate moving the particle to the top of the screen.

A common loop pattern is to repeat a body of code an exact number of times.

Lets print a table of powers of two up to 2¹⁰.

Lets be careful how we interpret the statement i = i + 1. This is an assignment statement, not a statement in mathematics (which would be nonsense). The way to read this is the new value of i gets the old value of i plus one.

What would happen if we forgot the line i = i + 1?

Write a while-loop that prints the integers from 1 to 10, one integer per line.

Print the integers counting down from 10 to 0. When you are done print "Blast off!". Add a one second delay in between integers. Hint: use the pygame.time.delay(n) function where n is the number of milliseconds to delay.

Another common loop pattern is to keep a running total. For example, lets compute the sum of the integers from \(1\) to \(n\). That is, \(1 + 2 + 3 + \cdots + n\) where \(n\) is entered by the user.^[9]

Write a program that computes the average of non-negative numbers (for example quiz grades) entered by the user. Quit reading numbers when the user has entered a negative number. Be careful, make sure you don’t include the negative number in the average. Here is an example run of the program.

Why are longer passwords better than shorter passwords? It is obvious, longer passwords are harder to guess. But how much harder? Lets say we allowed passwords to contain 26 upper or lower case characters (that is 52 possible alphabetic characters, in the English alphabet), ten digits 0 through 9, and 32 symbol characters ~!@#$%^&*()_-+={[}]"':;>.<,?/|\. That is 94 possible distinct characters that can be used in a password.^[12]

There are \(94\) one character passwords, \(94^2 = 8836\) two character passwords, \(94^3 = 830584\) three character passwords, and so on, so that if a password was ten characters long there are \(94^{10} = 53861511409489970176\) possible passwords or approximately \(5 \times 10^{19}\).

Plotting \(94^i\), where \(i\) is the number of characters in the password, gives us the graph:

This is an example of exponential growth in the number of characters in the password. Notice how the graph explodes at between 8 and 10 characters (was it ever suggested that you make your passwords more than 8 characters long?) What is the total number of passwords up to 10 characters long? We would have to include all of the nine character passwords, and the eight character passwords, etc. and compute the sum \(94^1 + 94^2 + 94^3 + \cdots + 94^{10}\).

which would print 54440667446151152650, which is also just bigger than \(5.4 \times 10^{19}\).

To emphasize the difference between a six character password and a ten character password, let’s assume a malicious hacker was trying to break into a system by trying all possible passwords. How long might it take? Lets say we had a powerful computer that could attempt 1 billion passwords per second.

For a six character password that’s \(94^6/10^9/60 \approx 11.5\) minutes to try all possibilities. On average we will search about half the passwords, so on average it would take about \(6\) minutes.

For a ten character password, we have \(94^{10}/10^9\) seconds. Dividing by \(60\) to get minutes then another \(60\) for hours, then \(24\) to get days, then \(365.25\) to get years, we have \(94^{10}/10^9/60/60/24/365.25 = 1706\) years! Again, this is to try them all, so on average we would find it after looking at half of the passwords, so it would only take about \(850\) years.

Exponential growth arises in more subtle ways. In the previous example we were raising the base of the exponent, 94, to a fairly large power. What if the base were small, but still greater than one? Lets use an example of world population growth rate, which is currently estimated to be 1.11% (or .011) per year in 2017.^[13]

Let \(t\) be the current year and \(P_t\) be the current population at the beginning of year \(t\). So \(P_{t+1} = P_t + 0.011P_t\) or, factoring out the \(P_t\) then \(P_{t+1} = P_t(1.011)\).

One way of interpreting the formula \(P_{t+1} = P_t(1.011)\) is to see that the new value of \(P\) is the old value of \(P\) times 1.011. We have seen this pattern before in code. It is just an assignment statement:

We can just keep iterating this statement after we give it an initial population.

Of course if we want to compute the population P after \(n\) years we should use a loop.

Assume we have current population of roughly 7.5 billion.^[14] If we look at plots over a 10 year (top left), 100 year (top right), 1000 year (bottom left), and 5000 year (bottom right) time horizon then the year plot looks nearly linear. But as we progress up to 5000 years we see that this seemingly linear growth is a mirage and we have a curve that is definitely exponential.

When using a loop like this we can easily ask alternative questions such as how many years will it take to reach a population of 10 billion? This is just a simple matter of rephrasing the loop condition.