The goals this week are to:

• Practice Python syntax and creating functions (collections of code that we may want reuse multiple times).
• Use parameters to allow us to customize what a function does.
• Get accustomed to best practices for code organization. How you write and organize your code makes a big difference in how easy it is re-use later and fix problems (debugging)!

Good code organization saves you time and effort in the long run. It is essential whenever you collaborate with others and write any code professionally.

• Lab 2: Using functions to control shapes
  • Tasks
    • L1. The setup
    • L2. Good code organization
    • L3. Moving the turtle anywhere
      • L3a. Write a function called goto
      • L3b. Test your goto function
      • L3c. Why penup and pendown?
    • L4. Positioning and scaling a simple shape
      • L4a. Drawing a triangle at any position and scale
      • L4b. Testing your triangle2 function
    • L5. Position and scale a compound shape
      • L5a. Draw a hard-coded compound shape (triangleStack)
      • L5b. Convert hard-coded positions to offsets
      • L5c. Scale the compound shape
    • Submit lab code on Google Classroom
      
    • Get started with project
      

---

Tasks

L1. The setup

Create a Lab02 folder on your computer where you store CS151 projects and labs, hopefully somewhere that is backed up (e.g. in Dropbox, Google Drive, Microsoft One Drive, etc.)

Open Sublime. Create a new Python source code file calledlab2.py.

Open up a Terminal and change the directory (cd) to the Lab02 folder.

L2. Good code organization

In lab2.py, write a function that draws a triangle. It should take in one parameter, sideLength, which is the length (in pixels) of each of the sides. Important: Draw your triangle so that the turtle starts out at the lower-left corner. Remember, the turtle initially faces eastward.

Call your triangle function from main code (i.e. code that is not indented at the bottom of your file). Make sure that your code works (draws a triangle starting at the lower-left corner) by telling Python to run it using Terminal (i.e. python3 lab2.py).

Now look over your lab2.py file, including your triangle function, and make sure that it follows good code organization practice. It should have:

1. Header comments (2 sets of triple quotes: '''Like this'''). Include filename, your name, course, semester, one line description of what the file does.
2. Import statements (don't use from turtle import *, use the new way: import turtle)
3. Function definitions are separated by two empty lines.
4. Every function should have a docstring (''' style comment '''Like this'''). This should be the first line of every function and intended with your function commands.
5. At least one inline comment per function (# style), if your function has more than 3 lines of code.
6. A comment indicating where 'main' code is going to appear (either style ''' or # style).
7. Main code you want your program to execute.

Tip: You may want to speed up the turtle drawing by calling the speed function in main code. If you do, click the link and look at what the one integer parameter means and pick a value that works for you.

Reminders: Use the exitonclick turtle function call at the end of your file and use turtle.<function> to call any turtle function.*

---

L3. Moving the turtle anywhere

Let's make it possible to draw a triangle at any position on the canvas, not just starting at the middle (i.e. position (x, y) = (0, 0)).

L3a. Write a function called goto

Your goto function should take in two parameters: x and y. This will allow the turtle to go position x and y, no matter where it currently is on the canvas.

You can write this function in three steps:

1. Call the turtle penup() function to make the turtle no longer "drag a virtual pen underneath it as it moves". In other words, moving the turtle won't result in drawing anything to the on-screen canvas (i.e. your canvas stays white as the turtle moves).
2. Call the turtle goto(x, y) function to have the turtle jump to the new (x, y) coordinate given by the function parameter values.
3. Call the turtle setheading(angle) function to have the turtle face east.
4. Call the turtle pendown() function so that the turtle will once again draw as it moves around.

Some more things to add to your function:

• To help you understand how your goto function works, make this print statement the first line of code in your goto function: print('goto(): going to', x, y).
• After that print statement, add this one: print('goto(): before move, turtle at', turtle.position()). Recall that the position() turtle function gives us the turtle's CURRENT (x, y) position.
• Make the last line of the function a similar print statement: print('goto(): after move, turtle now at', turtle.position()).

L3b. Test your goto function

In main code at the bottom of your file, call your goto function (move the turtle to a position of your choice), then have the turtle draw a triangle there. Repeat this a few times with different positions. You should end up with a canvas that looks something like this (your drawing will probably look different and that's ok!):

Remember: In main code, you want to call YOUR goto function, NOT the turtle's. So you should write commands like goto(140, 0) rather than turtle.goto(140, 0).

L3c. Why penup and pendown?

Before continuing, comment out both the penup and pendown commands in your goto function then run your program. What happens? Do you see why they are needed in goto?

Remember to uncomment them before continuing on to the next task!

---

L4. Positioning and scaling a simple shape

We will discuss the strategy for drawing your shapes at any size (scale) and position.

L4a. Drawing a triangle at any position and scale

Write a new triangle2 function that has the following signature:

def triangle2(x, y, scale):
    '''Draws a triangle at any (`x`, `y`) position and scale (`scale`)
    By default, the side lengths are 100 (when `scale` = 1)
    '''
    # your code here

Your triangle2 function should "teleport" the turtle to the given location (x, y) position and draw a triangle with a side length equal to 100 pixels when the scale parameter is 1.

Guidelines:

• You should only need to write two lines of code.
• Remember, you can call your functions from within other functions.

L4b. Testing your triangle2 function

Comment out any existing function calls in main code that are not speed or exitonclick. Test triangle2 by calling it 3 times: with scale 1 (natural size), 2 (double natural size), and 3 (triple natural size).

Below is an example output. You do not need to make it look fancy; the important thing is that the triangles appear in different positions at the 3 sizes.

---

L5. Position and scale a compound shape

L5a. Draw a hard-coded compound shape (triangleStack)

Let's assume that you have designed a shape (triangleStack) with hard-coded values that look good to you:

def triangleStack(x, y, scale):
    '''Draws three triangles on top of each other.
    Smaller triangles are placed on top of larger ones
    '''
    # Largest triangle
    triangle2(0, 0, 2)
    # Medium triangle in middle
    triangle2(50, 173.2, 1)
    # Small triangle on top of stack
    triangle2(75, 259.81, 0.5)

• Copy and paste this function into your lab2.py file.
• Comment out existing main code except for speed and exitonclick commands.
• Call triangleStack to see what it looks like from main code. Notice the parameters are not used yet, so you can pick any 3 values right now when calling the function — e.g. triangleStack(0, 0, 1)

L5b. Convert hard-coded positions to offsets

We are going to convert the hard-coded compound shape (stack of three triangles) into a shape that we can move to any position and make any scale that we wish. We will do this in two stages.

First, convert the hard-coded positions to offsets. Make the lower-left corner of the first triangle (where the turtle starts out) "the origin" at (x, y) — i.e. has offset of (0, 0). Compute the offsets relative to (x, y).

When you're done, test it by commenting out existing main code and draw triangleStack at three positions: (x, y) = (-200, 0), (x, y) = (0, 0), and (x, y) = (200, 0). The scale parameter value does not matter right now. You should get this arrangement:

L5c. Scale the compound shape

The second and last step is to make the triangle stack resizable. Do this by multiplying the offsets and scales by scale.

When you're done, test it by modifying your existing main code:

• Draw the 1st stack at scale 1, the 2nd at scale 1/2, and the 3rd at scale 1/3.
• Draw at three positions: (x, y) = (-200, 0), (x, y) = (0, 0), and (x, y) = (100, 0).

You should get this arrangement:

Take a screenshot — this is a Required Image to submit with your Lab submission.

Submit Lab Code on Google Classroom

Upload your screenshot of the 3 trees and your lab2.py file on Google Classroom and submit it. Do NOT zip the file, or include a report.

Get started with project

Once you are done with each of the lab tasks, you may start on the project.

---