Creating Python Turtle Functions: A Beginner's Guide

Python's turtle graphics is a fun and interactive module that lets you create simple drawings and animations using a turtle that moves around the screen. It's a great way to introduce programming concepts to beginners and can be used to create exciting games and visualisations.

To get started with Python turtle, you need to import the turtle module. You can do this by adding the following line to the beginning of your code:

python

import turtle

Once you have imported the turtle module, you can create a new turtle object and control its movement using various functions and methods. Here's an example code snippet that demonstrates how to create a turtle and make it move forward and backward:

python

Create a new turtle object

turtle = turtle.Turtle()

Move the turtle forward by 100 pixels

turtle.forward(100)

Move the turtle backward by 50 pixels

turtle.backward(50)

You can also use functions like `turtle.right()` and `turtle.left()` to change the direction of the turtle.

To make your code more organised and reusable, you can define your own functions that encapsulate specific tasks or behaviours. For example, you can define a function that draws a square using the turtle:

python

def draw_square(turtle, size):

for _ in range(4):

turtle.forward(size)

turtle.left(90)

In this function, we pass in the `turtle` object and the `size` of the square as parameters. Inside the function, we use a `for` loop to repeat the following two steps four times: move the turtle forward by `size` pixels and then turn the turtle left by 90 degrees.

You can then call this function whenever you want to draw a square using your turtle:

python

draw_square(turtle, 50)

This will draw a square with a size of 50 pixels.

By creating your own functions, you can abstract away complex behaviours and make your code more readable and maintainable. You can also easily reuse these functions throughout your program, reducing duplication and improving code quality.

Using the def keyword to define a function

Python functions are defined using the def keyword. The syntax for a function definition is:

Python

Def NAME(PARAMETERS):

STATEMENTS

Python

Def draw_square(t, sz):

"""Make turtle t draw a square of size sz."

For i in range(4):

T.forward(sz)

T.left(90)

In this function, t is the turtle object that we want to move around, and sz is the size of the square we want to draw. We can then call this function and pass in the turtle object and the size of the square we want to draw:

Python

Draw_square(alex, 50)

We can also define functions inside other functions. For example, we can define a function that draws a rectangle:

Python

Def draw_rectangle(t, w, h):

"""Get turtle t to draw a rectangle of width w and height h."

For i in range(2):

T.forward(w)

T.left(90)

T.forward(h)

T.left(90)

And then we can call this function inside our draw_square function to draw a square:

Python

Def draw_square(tx, sz):

Draw_rectangle(tx, sz, sz)

This way, we can reuse the draw_rectangle function to draw both rectangles and squares.

We can also define functions that return values. For example, we can write a function that calculates the final amount of an investment using the compound interest formula:

Python

Def final_amt(p, r, n, t):

"""Apply the compound interest formula to p to produce the final amount."

A = p * (1 + r/n) (n*t)

Return a

We can then call this function and pass in the principal amount, interest rate, number of times per year the interest is compounded, and the number of years:

Python

Final_amt(toInvest, 0.08, 12, 5)

This will return the final amount after investing the principal amount for 5 years with an interest rate of 8% compounded 12 times per year.

When defining functions, it's important to choose descriptive names for the parameters and variables to make the code more readable and understandable. We can also use docstrings to provide documentation for our functions and explain what the function does, what arguments it takes, and what the expected result is.

Overall, functions are a great way to organize our code and make it more reusable and maintainable.

How to use parameters in a function

Functions in Python are a named sequence of statements that work together. They are an excellent way to break up problems into smaller, more manageable pieces. When creating a function, you can give it parameters, also called arguments, which allow the variables in the function to have different values each time it is called.

Python

Def line_without_moving():

Turtle.forward(50)

Turtle.backward(50)

This function, `line_without_moving`, moves the turtle forward and backward by a fixed distance of 50 units. However, if we want to change the distance, we would need to write a new function. This is where parameters come in. We can modify the function to accept a parameter:

Python

Def line_without_moving(length):

Turtle.forward(length)

Turtle.backward(length)

Now, when we call this function, we can specify the value of `length`, allowing us to move the turtle by different distances:

Python

Line_without_moving(50)

Line_without_moving(40)

In the updated function, `length` is a parameter that acts as a variable known only inside the function's definition. Each time we call the function, we can pass a different value for `length`, making our function more flexible and reusable.

We can also add multiple parameters to a function, separating them with commas and giving them distinct names:

Python

Def tilted_line_without_moving(length, angle):

Turtle.left(angle)

Turtle.forward(length)

Turtle.backward(length)

In this example, the function `tilted_line_without_moving` takes two parameters, `length` and `angle`. Now, when we call this function, we need to provide values for both parameters:

Python

Tilted_line_without_moving(75, 30)

By using parameters in functions, we can create versatile and adaptable code, reducing duplication and improving the organization of our programs.

How to use docstrings for documentation

Python docstrings are a built-in feature that allows you to document your code effectively. They are enclosed within triple double quotes ("""")") and are placed directly below the object they describe. For example:

Python

Def say_hello(name):

"""A simple function that says hello... Richie style"""

Print(f"Hello {name}, is it me you're looking for?")

In this example, the docstring provides a brief description of the function's purpose and how it can be used. This information is easily accessible to users through the built-in `help()` function:

Python

>>> help(say_hello)

Help on function say_hello in module __main__:

Say_hello(name)

A simple function that says hello... Richie style

Docstrings are essential for documenting your code and providing a clear understanding of its purpose, usage, and functionality. They serve as a form of documentation for users who want to use the code, while code comments are typically used for developers who want to modify the code.

When writing docstrings, it is important to follow certain conventions and best practices:

• Use triple double quotes ("""") for all docstrings, regardless of their length.
• Keep docstrings concise and focused on providing a clear summary of the object.
• For multi-line docstrings, include a one-line summary, followed by a blank line, and then any additional details.
• Follow the recommendations outlined in PEP 257, such as using a dot to end the docstring and describing the function's purpose.
• Use one of the common docstring formats like NumPy/SciPy, Google, reStructuredText, or Epytext.

Python

Def days_release(date):

"""Return the difference in days between the current date and game release date.

Args:

Date (str): Release date in string format.

Returns:

Int64: Integer difference in days.

"""

Current_date = datetime.now()

Release_date_dt = datetime.strptime(date, "%B %d, %Y")

Return (current_date - release_date_dt).days

In this example, the docstring includes a summary, information about the input parameter, and the return type. This provides users with a clear understanding of how to use the function and what to expect as output.

For larger projects, it is important to document not only functions but also classes, modules, and scripts. Class docstrings should include information about the class's purpose, public methods, class properties, and any other relevant details. Module docstrings should provide a description of the module, a list of exported classes, exceptions, functions, etc. Script docstrings should be well-documented to allow users to understand how to use the script effectively.

Additionally, consider using tools like Sphinx, pydoc, or pdoc to automatically generate documentation based on your docstrings.

Remember, documentation is crucial for any Python project, and docstrings play a vital role in providing clear and accessible information about your code.

How to call a function

To call a function in Python Turtle, you can follow these steps:

Import the Turtle Module: Before using Python Turtle functions, ensure you have imported the Turtle module. You can do this by adding the following line to the beginning of your code:

Python

From turtle import *

Or:

Python

Import turtle

Create a Turtle Object: Next, create a new Turtle object that you can control and draw with. You can name the Turtle object whatever you like, for example:

Python

Skk = turtle.Turtle()

Define Your Function: You can then define your function using the def keyword, followed by the function name and any parameters you want to include. For example, let's create a function called `draw_square` that takes in a Turtle object `t` and a size `sz` as parameters:

Python

Def draw_square(t, sz):

"""Make turtle t draw a square of size sz.""""

For i in range(4):

T.forward(sz)

T.left(90)

Call the Function: Now you can call the function by writing its name followed by parentheses and providing any required arguments. For example, let's call our `draw_square` function with our Turtle object `skk` and a size of `50`:

Python

Draw_square(skk, 50)

Execute the Code: Finally, execute your code to see the Turtle in action!

You can create more complex functions and combine them to draw different shapes and patterns. Python Turtle uses indentation to identify blocks of code that belong together, so make sure to indent your code consistently.

How to use fruitful vs void functions

Python functions can be broadly classified into two types: fruitful functions and void functions.

Fruitful functions are functions that return a value. They are executed to obtain a computation or calculation. For example, the built-in functions `abs`, `pow`, `int`, `max`, and `range` are fruitful functions. When calling these functions, the returned value is usually assigned to a variable or used as part of an expression.

Python

Def final_amt(p, r, n, t):

""" Apply the compound interest formula to p to produce the final amount. """

A = p * (1 + r/n) (n*t)

Return a

In this function, the return statement includes an expression that will be evaluated and returned to the caller as the result of calling the function.

Void functions, on the other hand, do not return a value. They are executed because they perform a useful action or operation. Void functions are used when the focus is on the action performed by the function rather than the value it returns. For example, a function that makes a turtle draw a rectangle is a void function.

Python

Def draw_square(t, sz):

"""Get turtle t to draw a square with sz side"""

For i in range(4):

T.forward(sz)

T.left(90)

In this function, there is no return statement, so the function automatically returns `None when it is called.

When using fruitful functions, it is important to assign the returned value to a variable or use it in an expression to avoid losing the result. On the other hand, when using void functions, there is no need to assign the result to a variable since there is no return value.

By using functions, we can break down complex problems into smaller, discrete pieces, making our code more organized, reusable, and easier to understand.

Frequently asked questions