CS51A - Fall 2025 - Class 4
Example code in this lecture
turtle-examples.py
Lecture notes
admin
- assignment 1
for loops in Python
- Python has a number of different "loop" structures that allow us to do repetition (computers are really good at doing repetitive tasks!)
- The "for" loop is one way of doing this
- There are a number of ways we can use the for loop, but for now the basic structure we'll use is:
for some_variable in range(num_iterations):
statement1
statement2
...
- Here are a few simple examples. What will each of these do?
# prints out the numbers from 0 to 9
for i in range(10):
print(i)
# sum the numbers from 0 to n-1
def sum(n):
total = 0
for val in range(n):
total = total + val
return total
for loops in turtle
- Back to turtle, how can we use a for loop to draw a square?
- look at the iterative_square function in turtle-examples.py
- What does the simple_star function in turtle-examples.py do?
- draws a 36-sided star (or asterisk)
- What if we wanted to have a star/asterisk with a different number of spokes?
- look at asterisk_star function
- figure out how we have to space the spokes
- do a for loop over the number of spokes
- each iteration in the loop draw a spoke
- need to go backwards into the middle for the next spoke
- rotate right based on the angle we calculated
- what will simple_spiral, spiral and rotating_circles in
turtle-examples.py code
do?
- simple_spiral
- i
- i is just the name of a variable
- for small loops (i.e. just a couple of statements), it's common to just us the variable name i (short for index)
- each time, the length of the edge drawn will be longer by a factor of 5
- 0, 5, 10, 15, 20, ...
- and will be at a 50 degree angle
- if it is < 90 it will spiral out
- > 90, spiral in
- spiral
- similar to simple_spiral, however now we've parameterized the length of the sides and the angle
- rotating_circles
- draws num circles
- each one rotated "angle" degrees from the previous
run the walk function from
turtle-examples.py code
- how is this being accomplished?
- turns a random angle between -90 and 90
- steps forward some step size
random module
- there is another python module called "random"
-
http://docs.python.org/library/random.html
- it generates pseudo-random numbers
- what does this mean?
- the numbers are not technically random, they're generated based on an algorithm
- for most purposes this is pretty good
- if you want truly random numbers, check out:
-
http://www.random.org/
- also there are some programs that try and measure things like time between keystrokes, etc. to get some randomness (but these also aren't quite perfect)
- many useful methods inside random
- random -- random number between 0 and 1.0
- uniform(a, b) -- random floats between a and b
- randint(a, b) -- random integers between a and b
- samples from many other distributions
- beta
- exponential
- gamma
- normal
- for now, we're just going to utilize the randint function
- if you only want to import a single function, you can do that like:
from random import randint
- before the '*' indicated all function and variables. Here, we just said the "randint" function
- You can print out a bunch of random numbers if you're curious:
for i in range(100):
print(randint(0,10))
look at walk function in
turtle-examples.py code
- went through the loop num_steps times/iterations
- uses the randint function to get an angle between -90 and 90
what will the pretty_picture function do?
- draws a line
- at an angle between -90 and 90
- of length between 10 and 60
- then draws a star
- of length between 10 and 60
- with int(spokes) spokes
- remember, if we want an integer, for example to be used in range, you need to turn it into an int
run add_circles function from conditional-turtle.py using setcolor_xy
- picks random x and y coordinates to draw a circle
- uses randint
- How are the colors chosen?
- each quadrant of the xy-axes is a different color
- how can we do this?
- want to ask a question about the x and y
booleans
- We've seen three types so far: int, float and str (string)
- Python has another type called bool (short for boolean)
- bool can only take the value True or False
- bool's generally result from asking T/F question
- What questions might we want to ask on data we've seen so far (e.g. numbers)?
- comparison operators
- == (equal)
- notice that '=' is the assignment operator while '==' asks whether two things are equal
- != (not equal)
- < (less than)
- > (greater than)
- <= (less than or equal to)
- >= (greater than or equal to)
- Using the comparison operators
>>> 10 < 0
False
>>> 11 >= 11
True
>>> 11 > 11.0
False
>>> 11 >= 10.9
True
>>> 10 == 10.1
False
>>> "test" == "test"
True
>>> "test" == "TEST"
False
>>> 10 != 10
False
>>> 10 != 11
True
>>> "banana" < "apple"
False
>>> type(True)
<type 'bool'>
>>> type(0 < 10)
<type 'bool'>
combining booleans
- we can also combine boolean expressions to make more complicated expressions
- what kind of connectors might we want?
- and
<bool expression> and <bool expression>
- only returns True if both expressions are True
- otherwise, it returns false
>>> x = 5
>>> x < 10 and x > 0
True
>>> x = -1
>>> x < 10 and x > 0
False
- Truth table
- a truth table gives you a mapping from input to output for boolean functions
A B | A and B
-------------
T T | T
T F | F
F T | F
F F | F
- or
<bool expression> or <bool expression>
- returns True if either expression is True
- False only if they are both False
>>> x = 5
>>> x < 10 or x > 0
True
>>> x = -1
>>> x < 10 or x > 0
True
- Truth table
A B | A or B
-------------
T T | T
T F | T
F T | T
F F | F
- not
not <bool expression>
- negates the expression
- if it's True returns False
- if it's False returns True
>>> not 5 == 5
False
- Truth table
A | not B
-------------
T | F
F | T