Integers are the whole numbers that you learned about in math class. We can do a lot with Python just using integers. For starters, we can use the Python interpreter we started a few moments ago as a calculator. Notice that Python displays >>>. These three characters, which are called the Python prompt, indicate that the Python interpreter is ready for you to type an expression. Let’s try a few mathematical expressions. Type in the following examples using the Python interpreter. After you have typed in an expression, press the enter or return key to see the result.

The examples in SESSION 1.1 illustrate some very important Python concepts that you should become familiar with as soon as possible. The first concept is Python’s read–eval–print loop.

At a high level, the Python interpreter is really very simple. It does three things over and over again: (1) read, (2) evaluate, and (3) print. These are illustrated in FIGURE 1.4.

First, Python reads one line of input. In the first example, Python reads 2 + 2, then it evaluates the expression 2 + 2 and determines that the answer is 4. Finally, Python prints the resulting value of 4. After displaying the result, Python prints the characters >>> to show you that it is waiting to read another expression.

In general, a Python expression is a combination of operators and operands. TABLE 1.1 shows Python’s arithmetic operators.

When we evaluate an expression, we get a result. In the examples in our Python session, some of the operators are familiar mathematical operators: ‘+’ and ‘−’. Although you may be more used to × and ÷ for multiplication and division, you will not find those symbols on a standard keyboard, so Python, like almost all programming languages, uses “*” for multiplication and “/” or “//” for division.

One thing that may surprise you in the example is the result of the expression 15 // 2. Of course, we all know that 15 divided by 2 is really 7.5. However, because both operands are integer objects and // is the integer division operator, Python produces an integer object as a result. Integer division works like the division you learned when you were young: 15 divided by 2 equals 7, remainder 1. You can find the remainder part of the result by using the modulo operator (%). For example, 15 % 2 evaluates to the remainder value of 1.

Let’s try some more calculations. Type the expressions in SESSION 1.2 into the Python interpreter.

Here we are mixing multiplication and addition. As shown in the first two calculations, the order in which we type the expressions does not make a difference in the result. The reason for this is that Python performs all multiplications and divisions before performing any additions and subtractions. We can override those rules by putting parentheses around any calculation we want to perform first, as shown in the third and fourth expressions.

Finally, we introduce the exponentiation operator (**) for raising a number to a power. In this case, we raise 2 to the third power, yielding 8.

TABLE 1.2 summarizes the order in which Python performs calculations. Operators are evaluated in order from top to bottom; operators at the same level are evaluated from left to right as they occur in the expression, except for exponentiation, which is evaluated from right to left.

Integer division is useful in some cases, but it can also trip you up. What if you want to divide 15 by 2 and get 7.5 as the answer? To get the result as a floating-point number, you must use the floating-point division operator ‘/’.

In Python, you can tell the difference between a floating-point number and an integer because a floating-point number has a decimal point. Floating-point numbers are Python’s approximation of what you called real numbers in math class. We say that floating-point numbers are an approximation because, unlike real numbers, floating-point numbers cannot have an infinite number of digits following the decimal point. This is because of the way floating-point numbers are stored in the computer’s memory. SESSION 1.3 presents some examples of calculations using floating-point numbers.

Notice that when the operands are floating-point numbers, the result is a floating-point number including the remainder as a fractional part. You should also notice that when the result of a floating-point operation gets really big, Python uses scientific notation to express the results. Finally, notice that you can use scientific notation for a floating-point number in a Python expression.

Although 3.273e + 150 is a good approximation, we know that there are not really 147 zeros in the result. One of the disadvantages of using scientific notation is that you lose some precision in your result. If you want to get very exact results, integers allow us to perform calculations to virtually unlimited precision. SESSION 1.4 shows the real value of 2**500 using integers.

When typing large integers, you might be tempted to insert commas between groups of 3 numbers—for example, 100,000,000. Unfortunately, Python does not allow commas to be inserted into integers. Session 1.4 shows that Python does allow an underscore (_) to act as a visual separator for typing large numbers. The underscore is not considered part of the integer, but simply acts as an aid in typing large numbers.

The final primitive numeric type in Python is the complex number. As you may remember, complex numbers have two parts to them: a real part and an imaginary part. In Python, a complex number is displayed as real + imaginary j. For example, 5.0 + 3j has a real part of 5.0 and an imaginary part of 3. Although we mention complex numbers here to give you a complete list of the numeric primitives, we will not go into any additional details at this point.

What happens when we mix numbers of different types in one calculation? Let’s look at the examples shown in SESSION 1.5 to find out.

As you can see from Session 1.5, when you mix floating-point numbers with integers with the arithmetic operators other than division, the result will be a floating-point number.

For division, however, the result depends on which division operator you use. When you use the floating-point division operator (/), regardless whether the operands are integers or floating-point numbers, the result will be a floating-point number. When you use one or more floating-point numbers with the integer division operator (//), the result is also a floating-point number, but with the fractional part truncated.

As shown in SESSION 1.6, you can also tell Python to explicitly convert a number to either an integer or a floating-point number by using the int or float functions. These functions are built-in Python code that operate on a value you put into parentheses after the function name. For example, float(5) will convert the integer 5 to the floating-point number 5.0. Conversely, int(3.99999) will convert the floating-point number 3.99999 to the integer 3. When converting floating-point numbers to integers, Python always truncates the fractional part of the number. If you want to convert a floating-point number to the nearest integer, you can use the built-in round function. For example, round(3.99999) will round the floating-point number 3.9999 to 4.

These numeric type conversion functions are summarized in TABLE 1.3.

In summary, we have seen that Python supports several types of primitive objects in the number family: integers, for ordinary simple math, when precision is required, or when dealing with very large numbers; and floating-point numbers, for working with scientific applications or accounting applications where we need to keep track of dollars and cents. At this point, however, Python is nothing more than a calculator. In the next section, we add some Python primitives that will give us a lot more power.

Many of the additional parts of Python functionality are found in modules—prewritten Python code that implements an abstraction designed to make programming easier. To apply the power of a module, you have to tell Python to load the module you want. The statement you need to use to load a module is import modulename.

When you import a module, an object is created inside Python. That object has the type module and has a name attached to it that matches the name you used on the import line. Every object in Python has three important characteristics: (1) an identity, (2) a type, and (3) a value. In addition, some Python objects have special values called attributes, and some Python objects also have methods, which are bits of Python code that allow us to ask the object to do something interesting. Let’s look at a simple example before we go any further.

The example we will use is the turtle module, which provides us with a simple graphics programming tool known as a turtle. Very simply, a turtle is an object that we can control. A turtle can move forward or backward, and it can turn in any direction. When a turtle moves, it draws a line if its tail is down. A turtle is a Python object that has both attributes and methods. Some of the attributes of a turtle are shown in TABLE 1.5.

The methods of the turtle are summarized in TABLE 1.6. The second column is titled “Parameter(s).” Functions and methods are abstractions of generalized behaviors. Just as mathematical functions like cos(20) or take parameters, Python functions and methods may also accept parameters. Parameters are the way we tell the function specifically what it should do. If you see the Python keyword None in the Parameter column, that means that the method does not need any parameters to do its job.

To start, we will just concern ourselves with a few of the turtle methods. For example, we can tell the turtle to go forward, go backward, turn left, turn right, or tell us its position. The turtle has a tail that can be up or down. When the tail is down and the turtle moves, it draws a line. If the tail is up and the turtle moves, nothing is drawn. SESSION 1.9 shows a Python session in which we create a turtle object and try out some of the turtle’s capabilities.

Let’s look at this example line by line. In line 1, we use an import statement to load the turtle module. In line 2, we ask Python to evaluate the name turtle. Python rewards us by telling us the identity of the object to which turtle is assigned. That identity indicates the location of the Python code for the module. This location will vary according to the kind of computer you are using and where you installed Python. If we were really adventurous, we could go there and look at the turtle methods that are stored in the turtle.py file.

Once we have the turtle module loaded, we can start to use the methods in the module to do something interesting. In the fifth line we have an assignment statement, through which we make a new Turtle object and give it the name gertrude.

If you are typing this session interactively as you are reading, you will see that when a turtle is created, a new window, shown in FIGURE 1.9a, appears on the screen. The arrow in the middle of the screen represents the turtle. When a turtle is first created, it is at position (0.0, 0.0) in the middle of the window. The turtle’s initial heading is 0.0 degrees, or straight to the right. The color attribute for the new turtle is black, and the tail is down. As you move the turtle around, it remembers its latest position, the direction in which it is facing, and the status of its tail (up or down).

Before we go any further with this example, we need to explain the fifth line in more detail. Notice that the expression turtle.Turtle() contains a new operator—the dot (.). The dot operator tells Python to look up the name right in front of the dot and return the object it names, a process referred to as dereferencing. In this case, the dereferencing operation allows Python to find the turtle module. Once we have the module, Python looks within the module for the name to the right of the dot. In this case, Python looks for the Turtle method. A good way to think of this is that Turtle is Python code “inside” the turtle module. So the dot operator gets us to the turtle module, and then inside the turtle module we find the object named Turtle.

As we can see, turtle.Turtle() is a method that creates a new object. Note that the Turtle method does not take any parameters; nevertheless, we need to include the parentheses when calling a method, even if they are empty. The type of the new object created is Turtle. A method that creates a new object is called a constructor. New turtle objects that we construct are called instances of the type Turtle.

The next two lines simply demonstrate that when you evaluate a name that corresponds to a more complicated object, Python returns its representation of that object. Unlike for a number, where the representation is self-evident, a turtle’s representation gives you a unique identification for the object. In this case, we see that gertrude is <turtle.Turtle object at 0x000001F5196D3080>. To be even more specific, the result tells us that the type of gertrude is turtle.Turtle. Furthermore, our turtle can be found at location 0x000001F5196D3080 in the computer’s memory.

Now that we have our new turtle object named gertrude, the next three lines instruct gertrude to do some drawing. As you might guess, the line gertrude.forward(100) causes the turtle to move forward 100 units. Once again, the dot notation is very important to understanding how Python interprets the statement. First, the dot tells Python to dereference the name gertrude. When Python finds the object, it evaluates the method forward that is “inside” the turtle. The forward method knows that it needs to move forward 100 units because we pass it a parameter of 100. In this case, we want gertrude to move forward 100 units; then turn right 90 degrees; and then move forward again, but this time by only 50 units. If you run this example on your own, your window should look like FIGURE 1.9b.

The last four lines of Session 1.9 show that we can also use methods to ask the turtle for information about itself. First, we ask gertrude to tell us its location with the method call gertrude.position(). gertrude replies that the turtle is at (100.0, −50.0). What is actually happening is that the position() method returns the value (100.0, −50.0), and the print part of the read–eval–print loop prints out that value. All functions can return values, and those values can then be included in Python expressions. The fact that the position method returns a value is no different than the cosine function returning a value. Similarly, the heading() method tells us that gertrude is currently facing 270.0 degrees.

In the world of our turtle, the coordinates (0.0, 0.0) are in the center of the window. The x coordinate grows in a positive direction as the turtle moves toward the right. If the turtle moves toward the left side of the window, the x coordinate gets smaller and becomes negative to the left of the middle of the window. Similarly, the y coordinate grows as the turtle moves toward the top of the window, but gets smaller as the turtle moves toward the bottom and becomes negative below the middle of the window. One pixel on your computer screen corresponds to 1 unit of turtle movement. The turtle’s heading varies from 0 to 359, moving counterclockwise around the window. If the turtle’s heading is 0.0 degrees, it is facing to the right; 90.0 degrees is up, 180.0 degrees is to the left, and 270.0 degrees is down.

The turtle module has many other methods. Table 1.6 shows just a few of them. We’ll introduce additional methods as we have need for them in future examples.

We are not limited to the functions that the authors of Python have given us. We, too, can write our own functions to add our own abstractions to the Python language. In fact, functions are just another kind of Python object with several special capabilities. We define a function in Python using the def statement. Here, we show a general template for using the def statement to define a function.

The def statement begins by giving the function a name. Next, we specify any parameters we want our function to accept. In Python, we can have zero or more parameters for any function we write. All the parameters must be listed inside the parentheses that follow the function name. Next, we have a colon character, which tells the Python interpreter that the sequence of indented statements that follow is part of the function. Python knows to stop reading lines for the def statement when it encounters a line that is not indented. A group of Python statements that are indented at the same level are called a block.

Now let’s try to write a real function. Suppose that we are working on a graphics program that requires us to draw a lot of squares. Telling the turtle how to draw a square each time we need one is tiresome and repetitious. In fact, a square is an example of an abstraction. We know that a square is a geometric shape that has four sides of equal length, and four 90-degree corners. What we don’t know is how long the sides are for any particular square.

Our goal is to write a function that can use any turtle to draw a square of any size. To solve this problem, then, we need two pieces of information—namely, the turtle that will draw the square and the size of the square. These pieces of information will become the parameters to our function.

The next step is to use the parameters along with the built-in methods of a turtle. We can draw a square by moving the turtle forward and turning right by 90 degrees four times in a row. LISTING 1.1 shows a complete Python function for drawing a square with a turtle.

Notice that the statements in the function are the same turtle commands that we typed in interactively when we first started using the turtle. Placing the commands inside the function groups them together so that we can have the whole set of commands run as if we had typed them one after another. This is one of the great powers of writing a function. It is also important to remember that Python will execute the commands in exactly the order they are typed in the function.

One new element to note in Listing 1.1 is the hash character (#) that appears on lines 2, 4, 6, and 8. This hash character starts a comment. The Python interpreter ignores any text following the hash character until the end of the line. Thus, comments allow the programmer to place descriptive documentation into Python code that will not impact the execution of the program. You will see comments in many of our sessions.

Type the drawSquare function into a text file using Notepad or TextEdit exactly as shown in Listing 1.1, including the indentation of the function block. After you type in the function, save it to a file called ds.py. To make it easy to find this file, set IDLE’s “Start in” property to the folder where you saved the file. You have just created your first module! In the same way that turtle is a module created by other Python programmers, you have created a module called ds.

We can now use the drawSquare function, as shown in SESSION 1.10. After running the commands in this session, you should have an image that looks like FIGURE 1.10.

There is a lot going on in this simple example, but there are only a few new things that you have not seen before. First, we import the turtle and ds modules. When we execute the statement import turtle, any functions inside the turtle module are “hidden” from us unless we use the turtle prefix. However, if we use the statement from ds import *, all the functions defined in the file ds.py are visible to us without the ds prefix.

We then make a new turtle object named t, and next we call drawSquare. Python knows that it should treat the object drawSquare like a function call because of the parentheses that follow its name. You can even prove to yourself that drawSquare is a plain old object by typing drawSquare without the parentheses after the name. If you do so, Python will tell you something like <function drawSquare at 0x000001C3863E01E0>.

When we call the function drawSquare, we pass it two objects, t and 150. When a function is called, the objects are matched up with the parameter names they were given when we defined the function. The first parameter in the list names the first object, the second parameter in the list names the second object, and so on. In this case, t goes by the name myTurtle inside the drawSquare function. The turtle object now has two names. Similarly, inside the drawSquare function, 150 now has the name sideLength.

The reference diagram in FIGURE 1.11 indicates how all the names and objects are matched up. This diagram is simplified somewhat, but we will add more details to such diagrams in later chapters. The important thing to notice is the relationship between the names of the parameters of a function and the objects that are passed to the function when it is called.

Figure 1.11 shows three names: (1) turtle, which references the turtle module we imported previously; (2) t, which references the turtle object we created with the call to the turtle constructor (turtle.Turtle()), shown inside the turtle module; and (3) drawSquare, which references the function object we defined for drawing squares. In the function object named drawSquare, you can see two additional names: (1) myTurtle, which references the turtle object named t, and (2) sideLength, which references the integer object 150 that has no other name.

Our goal for this section is to understand how we can use the for loop to have the turtle create a more complicated square spiral pattern. To create a spiral pattern, the sides of our square need to grow each time the turtle moves forward. We can make that happen easily when we understand the two components of the for statement that we ignored a moment ago.

First, let’s look at the range function. If you ask Python to evaluate the expression range(5), you will get back a sequence object representing the numbers [0, 1, 2, 3, 4].

The range function is very versatile: It can create all kinds of sequences depending on the parameters that we supply. We can call range in three ways:

• ▶   range(stop): Creates a sequence of numbers beginning at 0 and going up to stop-1, incrementing by 1.

• ▶   range(start, stop): Creates a sequence of numbers beginning at start and going up to stop-1, incrementing by 1.

• ▶   range(start, stop, step): Creates a sequence of numbers beginning at start and going up to stop-1, incrementing by step.

Now that you have a better understanding of the range function, let’s look at the loop variable—the variable that always follows the keyword for. In LISTING 1.3, the loop variable is named sideLength. In Python, this loop variable starts with the name for the first item in the sequence produced by the range function the first time through the loop. The second time through the loop, the loop variable is the name for the second item in the sequence, and so on until there are no more items in the sequence. We can use any valid Python name for the loop variable.

FIGURE 1.12 shows the sequence produced by the call to range and the item in the list named by item during the fourth repetition of the loop. Note that 55 is the last item in the sequence because the upper bound, 60, is not included in the result of the range function.

Loop variables can be used in expressions and function calls like any other Python names. To solve the spiral problem, Listing 1.3 uses a loop variable in a function named drawSpiral that draws a spiral. The parameters to this function are the turtle and a bound for the longest side on the spiral. We start with the first side having length 1; each time through the loop, we increase the length of the next side of the spiral by 5.

FIGURE 1.13 illustrates the first four iterations of the for loop in Listing 1.3. In the first iteration, the turtle draws a line that is 1 unit long because sideLength refers to the first item in the sequence produced by range(1, maxSide + 1, 5), which is 1. In the second iteration, sideLength refers to the number 6, so the turtle draws a line that is 6 units long. In the third iteration, sideLength refers to 11; in the fourth iteration, sideLength refers to the fourth number in the sequence, which is 16.

Our final problem for this chapter is to write a function that uses a turtle to draw a circle of a given radius. Although this may seem like a daunting task, we will help ourselves by solving a simpler problem first and then using what we learn to solve the more general problem. The first challenge is that the turtle’s functionality allows us to draw only straight lines. But by drawing many short straight lines, we can approximate a curved line.

Suppose that our problem was to draw a triangle rather than a circle. Starting from the drawSquare function, it is not too hard to imagine how we would modify drawSquare to write drawTriangle. We would change the call to range(4) to be range(3), as we now need only three sides. We would also change the number of degrees we pass as the parameter for our right turn function.

How many degrees do we need to turn each time to draw an equilateral triangle? When the triangle is complete, we want our turtle to be pointed in the same direction it was when we started. So, as we draw the three sides of our triangle, the turtle will turn through 360 degrees. That matches our drawSquare function, where we made four 90-degree turns (4 × 90 = 360). So, to draw a triangle, we will use 360 ÷ 3 = 120 for our turning angle. LISTING 1.4 shows the small changes made to the drawSquare function to create the drawTriangle function.

We now have two simple examples of polygons—the equilateral triangle and the square. It is relatively easy to imagine how we would write a function to draw a pentagon or an octagon by following the pattern we have established with the triangle and square. In fact, TABLE 1.7 illustrates the values we would supply to the range and right functions for several different polygons.

TABLE 1.7 Number of Sides and Turning Angle for Several Polygons

Table 1.7 suggests that we can write a function that is more abstract than drawSquare, drawTriangle, or even drawOctagon. The abstraction we are using in this case is a regular polygon. Creating one function that can replace many simpler functions at a higher level of abstraction is a common and important problem-solving technique in computer science.

For example, we can write a function that draws any regular polygon if we pass the function a third parameter. The third parameter tells the function how many sides we want. Once we know how many sides are required, we can easily calculate the turning angle by using the formula turnAngle = 360 / numSides. You can see the new drawPolygon function in LISTING 1.5.

SESSION 1.11 and FIGURE 1.14 illustrate several calls to the drawPolygon function, assuming we have saved the code into a file named dp.py. Before we call the drawPolygon function, however, we want to move the turtle to the left and make it face upward. To do so, we lift the turtle’s tail so that the turtle will not leave a path when it moves: We move the turtle backward 200 pixels, turn the turtle 90 degrees to the left, and then put the tail down.

Note that the call drawPolygon(t,20,20) makes a pretty good approximation of a circle.

So far, we have worked our way through the problem of drawing a circle by using a large-degree polygon as an approximation. Now let’s return to the original problem statement, which asks us to draw a circle of a given radius. Our last trick is to figure out how to use the radius to compute the number of sides and the side length.

Suppose that to get the smoothest circle possible, even when we are drawing a very large circle, we choose to always have 360 sides to our polygon. With this specification, the turtle will always turn 1 degree and should give us a smooth circle even for a large radius.

Only one question remains: How do we decide what side length to use for a given radius? One good approximation is to use the relationship of the radius of a circle to the circumference. If we are doing a good job of approximating a circle, then the circumference of the circle should be very close to the sum of the individual sides of the polygon. Recall that the circumference of a circle can be calculated from the radius using the formula circumference = 2 × π × radius. Once we have the circumference, we can calculate an individual side length by dividing the circumference by the number of sides, which we have decided will be 360. LISTING 1.6 shows the drawCircle function, which makes use of our drawPolygon function to draw a circle with a given radius.

The drawCircle function is extremely simple because we have reduced the problem of drawing a circle to that of drawing a polygon with a particular number of sides and side lengths. First, we calculate the circumference; then, we calculate the side length given the circumference and number of sides. Because we already know how to draw a polygon, we do not have to redo that work. We can build on what we have already accomplished and use the drawPolygon function to perform this tedious work. SESSION 1.12 and FIGURE 1.15 illustrate the use of the drawCircle function to draw both a large circle and a small circle. We assume that you have added the drawCircle function to the file dp.py.