Write a ``while`` loop with a condition that is always true to draw a spiral.

So far we have accomplished predefined tasks, but in all honesty we were accomplishing no better achievements than the 18th century automata, or the music boxes following one set of instruction to the end. What makes programming so much more powerful is conditional statements. This is the ability to *test* a variable (or a name) against a value and act in one way if the condition is met by the variable or an other way if not. They are also commonly called by programmers *if statements*.

A logic statement or operation can be evaluated to be *true* or *false*.

**if** *(evaluation of a condition returns true)* **then** *do some operation* **else** *do an other operation*.

And any operation that can be evaluated as *true* or *false* can but put to the test. All comparisons return *true* or *false*: *=,>,<*.

Let's try to make our turtle to stop when it reaches the end

of the window. Let's only take into account horizontal movements.

We want the turtle to go forward for a specified distance (taken as a function parameter) until it reaches this distance, or stop and turn around if it reaches the border of the screen.

* We won't turn, until we reach the boundary our turtle wants to get away as quickly as possible

User-defined funtions

You can access names in functions as well::

.. note:: Python uses *whitespaces to identify blocks of code* belonging together. While other languages use special characters (like curly brackets) in python a block is introduced with a colon at the end of the line and commands within a deeper identation level - ususally 4 spaces. The block ends with the first line with a lesser identation level.

Now we know how to *factorize* this code a little. But functions as we have defined them so far are not flexible. The variables are defined inside the function, and we need to rewrite a whole function to change the value of an angle, or a distance in it.

That is why we need to be able to give parameters, or also called *arguments* so that *names* we use in the function can be used with different values each time we call the function:

The parameter acts as a *name* only known inside the function's definition. We use the newly defined function by calling it with the value we want the parameter to have like this::

We have been using functions with parameters since the beginning of the tutorial with the *forward*, *left*, etc...

And we can put as many arguments (or parameters) as we want, separating them with commas and giving them different names::

Write a function that takes allows you to draw hexagons of any size you want, each time you call the function.

Write a function that draws a honeycomb with a variable number of hexagons, of variable sizes

After installing Python on your system successfully, you can start the interactive Python prompt by typing ``python`` in the command and press <enter>. It will show you some context information about Python similar to this::

press <enter> and see what happens. You will now see the phrase "Hello world" appear and then Python will bring you back to the interactive input, where you could enter another command now::

But you don't want to type everything into the Python shell everytime. Instead

much better. In order to do that you can just pass a file name to the Python

command in your shell and it will execute that file. Let's try that. Just open

the file "hello.py" in this directory in your favourite text editor and paste

the print command from above. Now save that file, go back the command line and

type::

When pressing <enter> now, the file is executed and you see the print as before. But this time, after Python executed all commands from that file, it exited instead of going back to the interactive shell. In some opearting systems (and depending on your setup) you might also be able to just double click on the hello.py file to execute it

names

true or not. But often one condition is not enough.

We may want to take the opposite of your result. Or for instance if we want to

The turtle gives us a useful function to know if it is writing or not: ``turtle.isdown()``.

This function returns *True* if the turtle is writing. As we have seen earlier, the function

Can we write a method that only goes forward if the pen is up?

Create a function that accepts the argument ``angle`` and moves the turtle into

that direction until either the vertical or horizontal distance to the center

exceeds 100.

Execute the ``move_to_square_border()`` function multiple times with different

angles. Use the ``turtle.home()`` function to make the turtle jump to the

center after each line.

take that easy example::

The ``turtle.forward(...)`` function takes the number of pixels which you want

to move forward, ``turtle.left(...)`` takes a number of degrees which you want

put ``turtle.exitonclick()`` at the bottom of your file::

``turtle.width(...)`` and ``turtle.color(...)`` functions. If you cannot

figure out the *signature* of a function (that is the syntax and semantics of

it, say, number of parameters and their meaning) you can use ``help(color)``.

How about a triangle? (A triangle with 120 degrees angles will have all legs