As we shrink down our code and add functions to remove duplication, we are factorizing it. This is a good thing to do. But the functions we have defined so far are not very flexible. The variables are defined inside the function, so if we want to use a different angle or a distance then we need to write a new function. Our hexagon function can only draw one size of hexagon!

That is why we need to be able to give parameters, also called arguments, to the function. This way the variables in the function can have different values each time we call the function:

Remember how we defined the function line_without_moving() in the previous section:

def line_without_moving():
    turtle.forward(50)
    turtle.backward(50)

We can improve it by giving it a parameter:

def line_without_moving(length):
    turtle.forward(length)
    turtle.backward(length)

The parameter acts as a variable 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:

line_without_moving(50)
line_without_moving(40)

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

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

def tilted_line_without_moving(length, angle):
    turtle.left(angle)
    turtle.forward(length)
    turtle.backward(length)

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

.. rst-class:: solution

def hexagon(size):
    for _ in range(6):
        turtle.forward(size)
        turtle.left(60)

Write a function that will draw a shape of any number of sides (let's assume greater than two) of any side length. Get it to draw some different shapes.

Here's an example of drawing shapes with this function:

.. rst-class:: solution

def draw_shape(sides, length):
    for _ in range(sides):
        turtle.forward(length)
        turtle.right(360 / sides)

It might sound crazy, but it's perfectly possible to pass a function as a parameter to another function! Python regards functions as perfectly normal 'things', the same as variables, numbers and strings.

For instance, you could create a shape drawing function which turned one way or another depending on which turtle function you passed to it - turtle.left or turtle.right.

See if you can implement this!