Python Foundations with Turtle: recap

A program is a list of commands the computer follows in order, from the top down. forward(100) moves the turtle 100 steps and draws a line. right(90) turns it on the spot, a quarter of a full turn clockwise; it does not move or draw. left(90) turns the other way.

Because each turn changes the way the turtle faces, the order of the commands is the picture. Swapping two lines gives a different drawing.

The first line, from turtle import *, gives a program the turtle commands. Students copy it for now; Functions and Modules explain how it works.

A loop repeats the lines indented under it. for i in range(4): means "do the indented lines 4 times". Instead of writing the same two lines four times, you write them once and say how often. The name i is a counter that takes the values 0, 1, 2, 3 on the four passes. A square does not use it, but later programs do.

forward(100) moves the turtle 100 steps and draws a line. right(90) turns it on the spot, a quarter of a full turn.

To close any shape, the turtle turns all the way round once in total: 360 degrees. Split that between the corners: 360 ÷ 4 = 90 for a square, 360 ÷ 3 = 120 for a triangle.

A variable is a name for a value. sides = 5 means "store 5 in a box called sides". After that, every time the program sees sides, it uses 5.

Variables can hold the result of a calculation: angle = 360 / sides works out the turn for you. Change sides and the turn updates by itself.

A line uses the value a name holds at the moment it runs. Storing a new value changes the lines that come after it, not the ones already run.

A loop made with for i in range(30): keeps a counter called i. It is 0 on the first pass, 1 on the second, 2 on the third, and so on up to 29.

Any line inside the loop can use i. forward(i * 5) draws a line that is 0, then 5, then 10 steps long, so each one is longer than the last and the path spirals outward.

size = size + 5 looks odd, but read it right to left: work out size + 5, then store the answer back in size. That is how a value grows each time round a loop.

Put the update inside the loop and it happens on every pass. Put it after the loop and it happens once.

Last lesson the counter i made the lines grow. A variable that updates itself does the same job without the counter.

A longer program is made of parts, each with one job. Here: name the numbers, move to the start, then a loop that repeats one house (walls, roof, step along), and a last line that works out the street's length.

The house loop has a loop inside it: the inner loop draws the four walls, the outer loop repeats the whole house. Everything indented under for house in range(houses): happens once per house.

The parts are joined by variables. width is used by the walls, the roof and the length, so changing it changes all three. That is why reading a program means asking, for each variable, "where else is this used?"

An if lets your program choose. if i < 3: asks a question. If the answer is yes (True), the indented lines under it run. If not (False), the lines under else run instead. Only one of the two paths runs on each pass.

< means "less than". Careful: one = stores a value, two == ask whether two things are equal.

% gives the remainder after dividing. Even numbers divided by 2 leave nothing over (remainder 0), so i % 2 == 0 is true for 0, 2, 4, 6: every second pass. i % 3 == 0 is true for 0, 3, 6, 9: every third pass.

elif adds another question, asked only when the earlier ones were no. Python asks the questions in order and stops at the first true one.

A list keeps many values in order under one name: colours = ["red", "blue", "green"].

Each item has a place, counted from 0. colours[0] is the first item, colours[2] the third. A list of 3 items has places 0, 1 and 2, and asking for place 3 is an error.

len(colours) counts the items. for i in range(len(colours)): runs once for each item, with i as its place.

for c in colours: takes the items of a list one at a time. Each time round the loop, c holds the next item itself, so the loop runs once for every item. You don't count places.

Use the place (colours[i]) when the position matters. Use for-each when only the item matters.

A loop inside a loop draws a grid: the outer loop makes the rows and the inner loop makes the squares in each row. The remainder of row + col divided by the length of the list gives a colour place that repeats in a pattern.

Predict first, then run. When the result differs from your prediction, work out which part you misread.