turtle — Gráficos con Turtle

Código fuente: Lib/turtle.py


Turtle graphics is an implementation of the popular geometric drawing tools introduced in Logo, developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

Get started

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.

In Python, turtle graphics provides a representation of a physical «turtle» (a little robot with a pen) that draws on a sheet of paper on the floor.

It’s an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback. It also provides convenient access to graphical output in general.

Turtle drawing was originally created as an educational tool, to be used by teachers in the classroom. For the programmer who needs to produce some graphical output it can be a way to do that without the overhead of introducing more complex or external libraries into their work.


New users should start here. In this tutorial we’ll explore some of the basics of turtle drawing.

Starting a turtle environment

In a Python shell, import all the objects of the turtle module:

from turtle import *

If you run into a No module named '_tkinter' error, you’ll have to install the Tk interface package on your system.

Basic drawing

Send the turtle forward 100 steps:


You should see (most likely, in a new window on your display) a line drawn by the turtle, heading East. Change the direction of the turtle, so that it turns 120 degrees left (anti-clockwise):


Let’s continue by drawing a triangle:


Notice how the turtle, represented by an arrow, points in different directions as you steer it.

Experiment with those commands, and also with backward() and right().

Control del lápiz

Try changing the color - for example, color('blue') - and width of the line - for example, width(3) - and then drawing again.

You can also move the turtle around without drawing, by lifting up the pen: up() before moving. To start drawing again, use down().

The turtle’s position

Send your turtle back to its starting-point (useful if it has disappeared off-screen):


The home position is at the center of the turtle’s screen. If you ever need to know them, get the turtle’s x-y co-ordinates with:


Home is at (0, 0).

And after a while, it will probably help to clear the window so we can start anew:


Making algorithmic patterns

Using loops, it’s possible to build up geometric patterns:

for steps in range(100):
    for c in ('blue', 'red', 'green'):

- which of course, are limited only by the imagination!

Let’s draw the star shape at the top of this page. We want red lines, filled in with yellow:


Just as up() and down() determine whether lines will be drawn, filling can be turned on and off:


Next we’ll create a loop:

while True:
    if abs(pos()) < 1:

abs(pos()) < 1 is a good way to know when the turtle is back at its home position.

Finally, complete the filling:


(Note that filling only actually takes place when you give the end_fill() command.)

How to…

This section covers some typical turtle use-cases and approaches.

Get started as quickly as possible

One of the joys of turtle graphics is the immediate, visual feedback that’s available from simple commands - it’s an excellent way to introduce children to programming ideas, with a minimum of overhead (not just children, of course).

The turtle module makes this possible by exposing all its basic functionality as functions, available with from turtle import *. The turtle graphics tutorial covers this approach.

It’s worth noting that many of the turtle commands also have even more terse equivalents, such as fd() for forward(). These are especially useful when working with learners for whom typing is not a skill.

You’ll need to have the Tk interface package installed on your system for turtle graphics to work. Be warned that this is not always straightforward, so check this in advance if you’re planning to use turtle graphics with a learner.

Use the turtle module namespace

Using from turtle import * is convenient - but be warned that it imports a rather large collection of objects, and if you’re doing anything but turtle graphics you run the risk of a name conflict (this becomes even more an issue if you’re using turtle graphics in a script where other modules might be imported).

The solution is to use import turtle - fd() becomes turtle.fd(), width() becomes turtle.width() and so on. (If typing «turtle» over and over again becomes tedious, use for example import turtle as t instead.)

Use turtle graphics in a script

It’s recommended to use the turtle module namespace as described immediately above, for example:

import turtle as t
from random import random

for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)

Another step is also required though - as soon as the script ends, Python will also close the turtle’s window. Add:


to the end of the script. The script will now wait to be dismissed and will not exit until it is terminated, for example by closing the turtle graphics window.

Use object-oriented turtle graphics

Other than for very basic introductory purposes, or for trying things out as quickly as possible, it’s more usual and much more powerful to use the object-oriented approach to turtle graphics. For example, this allows multiple turtles on screen at once.

In this approach, the various turtle commands are methods of objects (mostly of Turtle objects). You can use the object-oriented approach in the shell, but it would be more typical in a Python script.

The example above then becomes:

from turtle import Turtle
from random import random

t = Turtle()
for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)


Note the last line. t.screen is an instance of the Screen that a Turtle instance exists on; it’s created automatically along with the turtle.

The turtle’s screen can be customised, for example:

t.screen.title('Object-oriented turtle demo')

Turtle graphics reference


En la siguiente documentación se proporciona la listas de argumentos para las funciones. Los métodos, por su puesto, tienen el argumento principal adicional self que se omite aquí.

Métodos Turtle

Movimiento de Turtle
Mover y dibujar
Mostrar el estado de la tortuga
Ajuste y unidades de medida
Control del lápiz
Estado de dibujo
Control del color
Más controles de dibujo
Estado de la Tortuga
Usando eventos
Métodos especiales de Turtle

Métodos de TurtleScreen/Screen

Control de ventana
Control de animación
Usando eventos de pantalla
Configuración y métodos especiales
Métodos de entrada
Métodos específicos para Screen

Métodos de RawTurtle/Turtle Y sus correspondientes funciones

Casi todos los ejemplos de esta sección se refieren a una instancia Turtle llamada turtle.

Movimiento de Turtle


distance – un número (entero o flotante)

Mover hacia adelante la tortuga la ditance especificada, en la dirección en la que la tortuga apunta.

>>> turtle.position()
>>> turtle.forward(25)
>>> turtle.position()
>>> turtle.forward(-75)
>>> turtle.position()

distance – un número

Mover hacia atrás la tortuga la distance especificada, opuesta a la dirección en que la tortuga apunta. No cambia la dirección de la tortuga.

>>> turtle.position()
>>> turtle.backward(30)
>>> turtle.position()

angle – un número (entero o flotante)

Gira la tortuga a la derecha tomando los angle como unidad de medida. (La unidad de medida por defecto son los grado, pero se puede configurar a través de las funciones degrees() y radians().) La orientación de los ángulos depende del modo en que está la tortuga, ver mode().

>>> turtle.heading()
>>> turtle.right(45)
>>> turtle.heading()

angle – un número (entero o flotante)

Gira la tortuga a la izquierda tomando los ángulos como unidad de medida. (La unidad de medida por defecto son los grado, pero se puede configurar a través de las funciones degrees() y radians().) La orientación de los ángulos depende del modo en que está la tortuga, ver mode().

>>> turtle.heading()
>>> turtle.left(45)
>>> turtle.heading()
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
  • x – un número o un par/vector de números

  • y – un número o None

Si y es None, x debe ser un par de coordenadas o un Vec2D (ejemplo: según lo devuelto por pos()).

Mueve la tortuga a una posición absoluta. Si el lápiz está bajo, traza una linea. No cambia la orientación de la tortuga.

>>> tp = turtle.pos()
>>> tp
>>> turtle.setpos(60,30)
>>> turtle.pos()
>>> turtle.setpos((20,80))
>>> turtle.pos()
>>> turtle.setpos(tp)
>>> turtle.pos()
turtle.teleport(x, y=None, *, fill_gap=False)
  • x – un número o None

  • y – un número o None

  • fill_gap – a boolean

Move turtle to an absolute position. Unlike goto(x, y), a line will not be drawn. The turtle’s orientation does not change. If currently filling, the polygon(s) teleported from will be filled after leaving, and filling will begin again after teleporting. This can be disabled with fill_gap=True, which makes the imaginary line traveled during teleporting act as a fill barrier like in goto(x, y).

>>> tp = turtle.pos()
>>> tp
>>> turtle.teleport(60)
>>> turtle.pos()
>>> turtle.teleport(y=10)
>>> turtle.pos()
>>> turtle.teleport(20, 30)
>>> turtle.pos()

Nuevo en la versión 3.12.


x – un número (entero o flotante)

Establece la primera coordenada de la tortuga a x, deja la segunda coordenada sin cambios.

>>> turtle.position()
>>> turtle.setx(10)
>>> turtle.position()

y – un número (entero o flotante)

Establece la segunda coordenada de la tortuga a y, deja la primera coordenada sin cambios.

>>> turtle.position()
>>> turtle.sety(-10)
>>> turtle.position()

to_angle – un número (entero o flotante)

Establece la orientación de la tortuga a to_angle. Aquí hay algunas direcciones comunes en grados:

modo estándar

modo logo

0 - este

0 - norte

90 - norte

90 - este

180 - oeste

180 - sur

270 - sur

270 - oeste

>>> turtle.setheading(90)
>>> turtle.heading()

Mueve la tortuga al origen – coordenadas (0,0) – y establece la orientación a la orientación original (que depende del modo, ver mode()).

>>> turtle.heading()
>>> turtle.position()
>>> turtle.home()
>>> turtle.position()
>>> turtle.heading()
turtle.circle(radius, extent=None, steps=None)
  • radius – un número

  • extent – un número (o None)

  • steps – un entero (o None)

Dibuja un círculo con el radius (radio) dado. El centro es radius unidades a la izquierda de la tortuga; extent – un ángulo – determina que parte del círculo se dibuja. Si no se pasa extent, dibuja el círculo entero. Si extent no es un círculo completo, un punto final del arco es la posición actual de lápiz. Dibuja el arco en dirección antihorario si radius es positivo, si no en dirección horaria. Finalmente la dirección de la tortuga es modificada por el aumento de extent.

Como el círculo se aproxima a un polígono regular inscripto, steps determina el número de pasos a usar. Si no se da, será calculado automáticamente. Puede ser usado para dibujar polígonos regulares.

>>> turtle.home()
>>> turtle.position()
>>> turtle.heading()
>>> turtle.circle(50)
>>> turtle.position()
>>> turtle.heading()
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
>>> turtle.heading()
turtle.dot(size=None, *color)
  • size – un entero >= 1 (si se da)

  • color – un colorstring o una tupla numérica de color

Dibuja un punto circular con diámetro size, usando color. Si size no se da, el máximo de pensize+4 y 2*pensize es usado.

>>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
>>> turtle.heading()

Estampa una copia de la forma de la tortuga en el lienzo en la posición actual. Devuelve un stamp_id por cada estampa, que puede ser usado para borrarlo al llamar clearstamp(stamp_id).

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)

stampid – un entero, debe devolver el valor de la llamada previa de la función stamp() call

Borra la estampa con el stampid dado.

>>> turtle.position()
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.position()
>>> turtle.clearstamp(astamp)
>>> turtle.position()

n – un entero (o None)

Borra todas o las primeros/últimos n estampas de la tortuga. Si n es None , borra todas las estampas, Si n > 0 borra la primera estampa n, sino y n < 0 borra la última estampa n.

>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()

Deshace (repetidamente) la(s) última(s) acción(es) de la tortuga. El número de acciones a deshacer es determinado por el tamaño del undobuffer.

>>> for i in range(4):
...     turtle.fd(50); turtle.lt(80)
>>> for i in range(8):
...     turtle.undo()

speed – un entero en el rango 0..10 o un speedstring (ver abajo)

Establecer la velocidad de la tortuga a un valor entero en el rango 0..10. Si no se pasa ningún argumento, vuelve a la velocidad actual.

Si el parámetro de entrada es un número mayor que 10 o menor que 0.5, la velocidad se establece a 0. La frase acerca de la velocidad es mapeada a valores de velocidad de la siguiente manera:

  • «fastest»: 0

  • «fast»: 10

  • «normal»: 6

  • «slow»: 3

  • «slowest»: 1

Velocidades de 1 a 10 generan una animación cada vez más rápida al dibujar las líneas y en el giro de la tortuga.

Atención: speed = 0 implica que no habrá ninguna animación. Los métodos fordward/back harán que la tortuga salte, de la misma manera que left/right hará que la tortuga gire instantáneamente.

>>> turtle.speed()
>>> turtle.speed('normal')
>>> turtle.speed()
>>> turtle.speed(9)
>>> turtle.speed()

Mostrar el estado de la tortuga


Devuelve la posición actual de la tortuga (x,y) (como un vector Vec2D)

>>> turtle.pos()
turtle.towards(x, y=None)
  • x – un número o par de vectores numéricos o una instancia de la tortuga

  • y – un número si x es un número, si no None

Retorna el ángulo entre la línea en la posición de la tortuga a la posición especificada en (x, y), el vector o la otra tortuga. Esto depende de la posición inicial de la tortuga, que depende del modo - «standard»/»world» o «logo».

>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)

Devuelve la coordinada x de la tortuga.

>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
>>> print(round(turtle.xcor(), 5))

Devuelve la coordenada y de la tortuga.

>>> turtle.home()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print(turtle.pos())
>>> print(round(turtle.ycor(), 5))

Devuelve la orientación actual de la tortuga (el valor depende del modo de la tortuga, ver mode()).

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
turtle.distance(x, y=None)
  • x – un número o par de vectores numéricos o una instancia de la tortuga

  • y – un número si x es un número, si no None

Devuelve la distancia desde la tortuga al vector (x,y) dado, otra instancia de la tortuga, el valor es unidad pasos de tortuga.

>>> turtle.home()
>>> turtle.distance(30,40)
>>> turtle.distance((30,40))
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)

Configuración de las medidas


fullcircle – un número

Establece la unidad de medida del ángulo, por ejemplo establece el número de «grados» para un círculo completo. El valor por defecto es 36 grados.

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()

Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
>>> turtle.degrees(360)
>>> turtle.heading()

Establece la unidad de medida del ángulo a radianes. Equivalente a degrees(2*math.pi).

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
>>> turtle.radians()
>>> turtle.heading()

Control del lápiz

Estado de dibujo


Baja el lápiz – dibuja mientras se mueve.


Levanta el lápiz – no dibuja mientras se mueve.


width – un número positivo

Establece el grosos de la línea a width o lo devuelve. Si resizemode se establece a «auto» y turtleshape es un polígono, ese polígono es dibujado con el mismo grosor de línea. Si no se dan argumentos, devuelve el grosor del lápiz actual.

>>> turtle.pensize()
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
turtle.pen(pen=None, **pendict)
  • pen – un diccionario con algunos o todos las claves listadas debajo

  • pendict – uno o más argumentos-palabras claves con las claves listadas debajo como palabras claves

Devuelve o establece los atributos del lápiz en un «diccionario-lápiz» con el siguiente para de valores/claves:

  • «shown»: True/False

  • «pendown»: True/False

  • «pencolor»: color-string or color-tuple

  • «fillcolor»: color-string or color-tuple

  • «pensize»: número positivo

  • «speed»: número en el rango 0..10

  • «resizemode»: «auto» or «user» or «noresize»

  • «stretchfactor»: (número positivo, número positivo)

  • «outline»: número positivo

  • «tilt»: número

Este diccionario puede usarse como argumento de una llamada subsecuente a la función pen() para restaurar el estado anterior del lápiz. Más aún, uno o más de estos atributos pueden darse como argumentos claves. Esto puede usarse para establecer diferentes atributos del lápiz en una sola definición.

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> sorted(turtle.pen().items())
[('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'),
 ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'),
 ('shearfactor', 0.0), ('shown', True), ('speed', 9),
 ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
>>> penstate=turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', ''), ('outline', 1), ('pencolor', 'yellow')]
>>> turtle.pen(penstate, fillcolor="green")
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', 'green'), ('outline', 1), ('pencolor', 'red')]

Devuelve True si el lápiz está abajo, si está arriba False.

>>> turtle.penup()
>>> turtle.isdown()
>>> turtle.pendown()
>>> turtle.isdown()

Control del color


Devuelve o establece el color del lápiz.

Se permiten cuatro formatos de entrada:


Devuelve el color del lápiz actual como una palabra específica de algún color o como una tupla (ver ejemplo). Puede ser usado como una entrada para otra llamada de color/pencolor/fillcolor.


Establece el color del lápiz a colorstring, que es una palabra que especifica un color Tk, tales como "red", "yellow", o "#33cc8c".

pencolor((r, g, b))

Establece el color del lápiz representado como una tupla de r, g, y b. Cada valor r, g, y b debe ser un valor entero en el rango 0..colormode, donde colormode es 1.0 o 255 (ver colormode()).

pencolor(r, g, b)

Establece el color del lápiz al color RGB representado por r, g, y b. Cada valor r, g, y b debe estar en el rango 0..colormode.

Si turtleshape es un polígono, la línea del polígono es dibujado con el muevo color de lápiz elegido.

>>> colormode()
>>> turtle.pencolor()
>>> turtle.pencolor("brown")
>>> turtle.pencolor()
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
(0.2, 0.8, 0.5490196078431373)
>>> colormode(255)
>>> turtle.pencolor()
(51.0, 204.0, 140.0)
>>> turtle.pencolor('#32c18f')
>>> turtle.pencolor()
(50.0, 193.0, 143.0)

Return or set the fillcolor.

Se permiten cuatro formatos de entrada:


Devuelve el valor actual de fillcolor como una palabra, posiblemente en formato de tupla (ver ejemplo). Puede ser usado como entrada de otra llamada color/pencolor/fillcolor.


Establece fillcolor a colorstring, que es un color TK especificado como una palabra (en inglés), tales como «red», «yellow», o "#33cc8c".

fillcolor((r, g, b))

Establece fillcolor al color RGB representado por la tupla r, g, y b. Cada uno de los valores r, g, y b debe estar en el rango 0..colormode, donde colormode es 1.0 o 255 (ver colormode()).

fillcolor(r, g, b)

Establece fillcolor al color RGB representado por r, g, y b. Cada uno de los valores r, g y b debe ser un valor en el rango 0..colormode.

Si turtleshape es un polígono, el interior de ese polígono es dibujado con el color establecido en fillcolor.

>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)

Retorna o establece pencolor (el color del lápiz) y fillcolor (el color de relleno).

Se permiten varios formatos de entrada. Usan de 0 a 3 argumentos como se muestra a continuación:


Devuelve el valor actual de pencolor y el valor actual de fillcolor como un par de colores especificados como palabras o tuplas, como devuelven las funciones pencolor() y fillcolor().

color(colorstring), color((r,g,b)), color(r,g,b)

Entradas como en pencolor(), establece al valor dado tanto, fillcolor como pencolor.

color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2))

Equivalente a pencolor(colorstring1) y fillcolor(colorstring2) y análogamente si se usa el otro formato de entrada.

Si turtleshape es un polígono, la línea y el interior de ese polígono e dibujado con los nuevos colores que se establecieron.

>>> turtle.color("red", "green")
>>> turtle.color()
('red', 'green')
>>> color("#285078", "#a0c8f0")
>>> color()
((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))

Ver también: Método Screeen colormode().



Devuelve fillstate (True si está lleno, sino False).

>>> turtle.begin_fill()
>>> if turtle.filling():
...    turtle.pensize(5)
... else:
...    turtle.pensize(3)

Para ser llamada justo antes de dibujar una forma a rellenar.


Rellena la forma dibujada después de última llamada a la función begin_fill().

Superponer o no, regiones de polígonos auto-intersectados o múltiples formas, estas son rellenadas dependiendo de los gráficos del sistema operativo, tipo de superposición y número de superposiciones. Por ejemplo, la flecha de la tortuga de arriba, puede ser toda amarilla o tener algunas regiones blancas.

>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()

Más controles de dibujo


Borra el dibujo de la tortuga de la pantalla, centra la tortuga y establece las variables a los valores por defecto.

>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
>>> turtle.heading()
>>> turtle.reset()
>>> turtle.position()
>>> turtle.heading()

Borra el dibujo de la tortuga de la pantalla. No mueve la tortuga. El estado y posición de la tortuga así como los todos los dibujos de las otras tortugas no son afectados.

turtle.write(arg, move=False, align='left', font=('Arial', 8, 'normal'))
  • arg – objeto que se escribirá en TurtleScreen

  • move – True/False

  • align – una de las frases «left», «center» o «right»

  • font – un trio (nombre de fuente, tamaño de fuente, tipo de fuente)

Escribe texto - la representación de cadena de caracteres de arg - en la posición actual de la tortuga de acuerdo con align («izquierda», «centro» o «derecha») y con la fuente dada. Si mov es verdadero, el lápiz se mueve a la esquina inferior derecha del texto. De forma predeterminada, move es False.

>>> turtle.write("Home = ", True, align="center")
>>> turtle.write((0,0), True)

Estado de la Tortuga



Hace invisible a la tortuga, Es una buena idea hacer eso mientras está haciendo dibujos complejos, ya que esconder a la tortuga acelera dibujo de manera observable.

>>> turtle.hideturtle()

Hace visible la tortuga.

>>> turtle.showturtle()

Devuelve True si la tortuga se muestra, False si está oculta.

>>> turtle.hideturtle()
>>> turtle.isvisible()
>>> turtle.showturtle()
>>> turtle.isvisible()



name – una cadena de caracteres que es un nombre de forma válido

Establece la forma de la tortuga al name que se establece o, si no se establece un nombre, devuelve el nombre actual de su forma. La forma name debe existir en el diccionario de formas de TurtleScreen. Inicialmente están las siguientes formas poligonales: «arrow», «turtle», «circle», «square», «triangle», «classic». Para aprender como trabajar con estas formas ver los métodos de Screen register_shape().

>>> turtle.shape()
>>> turtle.shape("turtle")
>>> turtle.shape()

rmode – una de las cadenas «auto», «user», «noresize»

Establece resizemode a alguno de los valores: «auto», «user», «noresize». Si mode no se aporta, devuelve el actual resizemode. Distintos resizemode tienen los siguientes efectos:

  • «auto»: adapta la apariencia de la tortuga al correspondiente valor del lápiz.

  • «user»: adapta la apariencia de la tortuga de acuerdo a los valores de sretchfactor y outlinewidth (contorno), que se establece con la función shapesize().

  • «noresize»: no se adapta la apariencia de la tortuga.

resizemode("user") es llamado por la función shapesize() cuando se usa con argumentos.

>>> turtle.resizemode()
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)
turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)
  • stretch_wid – número positivo

  • stretch_len – número positivo

  • outline – número positivo

Return or set the pen’s attributes x/y-stretchfactors and/or outline. Set resizemode to «user». If and only if resizemode is set to «user», the turtle will be displayed stretched according to its stretchfactors: stretch_wid is stretchfactor perpendicular to its orientation, stretch_len is stretchfactor in direction of its orientation, outline determines the width of the shape’s outline.

>>> turtle.shapesize()
(1.0, 1.0, 1)
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize()
(5, 5, 12)
>>> turtle.shapesize(outline=8)
>>> turtle.shapesize()
(5, 5, 8)

shear – número (opcional)

Establece o devuelve el valor actual del estiramiento. Estira la forma de la tortuga de acuerdo a la inclinación del factor de corte, que es la tangente del ángulo de corte. No cambia el rumbo de la tortuga (dirección del movimiento). Si no de da un valor de inclinación: devuelve el factor actual, por ejemplo la tangente del ángulo de inclinación, por el cual se cortan la líneas paralelas al rumbo de la tortuga.

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()

angle – un número

Rota la forma de la tortuga en ángulo desde su ángulo de inclinación actual, pero no cambia el rumbo de la tortuga (dirección del movimiento).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)

angle – un número (opcional)

Establece o devuelve el ángulo de inclinación actual. Si se otorga un ángulo, rota la forma de la tortuga para apuntar en la dirección del ángulo especificado, independientemente de su actual ángulo de inclinación. No cambia el rumbo de la tortuga (dirección del movimiento). Si no se da el ángulo: devuelve el ángulo de inclinación actual, por ejemplo: el ángulo entre la orientación de la forma de la tortuga y el rumbo de la tortuga (su dirección de movimiento).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)
  • t11 – un número (opcional)

  • t12 – un número (opcional)

  • t21 – un número (opcional)

  • t12 – un número (opcional)

Establece o devuelve la matriz de transformación actual de la forma de la tortuga.

Si no se proporciona ninguno de los elementos de la matriz, retorna la matriz de transformación como una tupla de 4 elementos. De lo contrario, establezca los elementos dados y transforme la forma de tortuga de acuerdo con la matriz que consta de la primera fila t11, t12 y la segunda fila t21, t22. El determinante t11 * t22 - t12 * t21 no debe ser cero, de lo contrario se genera un error. Modifique el factor de estiramiento, el factor de corte y el ángulo de inclinación de acuerdo con la matriz dada.

>>> turtle = Turtle()
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
(4.0, -1.0, -0.0, 2.0)

Devuelve el polígono de la forma actual como tupla de pares de coordenadas. Esto puede ser usado para definir una nueva forma o componentes de una forma compuesta.

>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))

Usando eventos

turtle.onclick(fun, btn=1, add=None)
  • fun – una función con dos argumentos que se invocará con las coordenadas del punto en el que se hizo clic en el lienzo

  • btn – número del botón del mouse, el valor predeterminado es 1 (botón izquierdo del mouse)

  • addTrue o False – si es True, se agrega un nuevo enlace, de lo contrario reemplazará el enlace anterior

Enlaza acciones divertidas a eventos de click en la tortuga. Si la accion es None, las acciones asociadas son borradas. Ejemplo para la tortuga anónima, en la forma procedimental:

>>> def turn(x, y):
...     left(180)
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed
turtle.onrelease(fun, btn=1, add=None)
  • fun – una función con dos argumentos que se invocará con las coordenadas del punto en el que se hizo clic en el lienzo

  • btn – número del botón del mouse, el valor predeterminado es 1 (botón izquierdo del mouse)

  • addTrue o False – si es True, se agrega un nuevo enlace, de lo contrario reemplazará el enlace anterior

Enlaza acciones divertidas a eventos del tipo soltar botón del mouse en la tortuga. SI la acción es None, las acciones asociadas son borradas.

>>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
turtle.ondrag(fun, btn=1, add=None)
  • fun – una función con dos argumentos que se invocará con las coordenadas del punto en el que se hizo clic en el lienzo

  • btn – número del botón del mouse, el valor predeterminado es 1 (botón izquierdo del mouse)

  • addTrue o False – si es True, se agrega un nuevo enlace, de lo contrario reemplazará el enlace anterior

Enlaza acciones divertidas a eventos en los movimientos del mouse. Si la acción es None, las acciones asociadas son borradas.

Observación: cada secuencia de los eventos de movimiento del mouse en una tortuga es precedida por un evento de click del mouse en esa tortuga.

>>> turtle.ondrag(turtle.goto)

Subsecuentemente, clickear y arrastrar la Tortuga la moverá a través de la pantalla produciendo dibujos a mano alzada (si el lápiz está abajo).

Métodos especiales de Turtle


Comienza a grabar los vértices de un polígono. La posición actual de la tortuga es el primer vértice del polígono.


Deja de grabar los vértices de un polígono. La posición actual de la tortuga es el último vértice del polígono. Esto se conectará con el primer vértice.


Devuelve el último polígono grabado.

>>> turtle.home()
>>> turtle.begin_poly()
>>> turtle.fd(100)
>>> turtle.left(20)
>>> turtle.fd(30)
>>> turtle.left(60)
>>> turtle.fd(50)
>>> turtle.end_poly()
>>> p = turtle.get_poly()
>>> register_shape("myFavouriteShape", p)

Crea y devuelve un clon de la tortuga con la misma posición, dirección y propiedades de la tortuga.

>>> mick = Turtle()
>>> joe = mick.clone()

Devuelve el objeto Tortuga en si. El único uso razonable: es como una función para devolver la «tortuga anónima»:

>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>

Devuelve el objeto TurtleScreen sobre el cual la tortuga está dibujando. Los métodos TurtleScreen luego pueden ser llamados para ese objeto.

>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")

size – un entero o None

Establecer o deshabilitar deshacer búfer. Si size es un número entero, se instala un búfer de deshacer vacío de un tamaño determinado. size da el número máximo de acciones de tortuga que se pueden deshacer mediante el método/función undo(). Si size es None, el búfer para deshacer está deshabilitado.

>>> turtle.setundobuffer(42)

Devuelve el número de entradas en el buffer para deshacer acciones.

>>> while undobufferentries():
...     undo()

Formas compuestas

Para usar formas complejas con la tortuga, que consiste en varios polígonos de diferentes colores, deberá usar la clase de ayuda Shape explícitamente como se describe debajo:

  1. Crear una objeto de forma vacía del tipo compound.

  2. Add as many components to this object as desired, using the addcomponent() method.

    Por ejemplo:

    >>> s = Shape("compound")
    >>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
    >>> s.addcomponent(poly1, "red", "blue")
    >>> poly2 = ((0,0),(10,-5),(-10,-5))
    >>> s.addcomponent(poly2, "blue", "red")
  3. Ahora agregar la forma a la lista de formas de la pantalla y úsela:

    >>> register_shape("myshape", s)
    >>> shape("myshape")


La clase Shape es usada internamente por el método register_shape() en maneras diferentes. El programador deberá lidiar con la clase Shape ¡solo cuando use formas compuestas como las que se mostraron arriba!

Métodos de TurtleScreen/Screen y sus correspondientes funciones

La mayoría de los ejemplos en esta sección se refieren a la instancia de TurtleScreen llamada screen.

Control de ventana


args – una cadena de color o tres números en el rango 0..*colormode* o una tupla de 3 de esos números

Establece o devuelve el color de fondo de TurtleScreen.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)

picname – una cadena, nombre o archivo gif o "nopic", o None

Establece la imagen de fondo o devuelve el nombre de la imagen de fondo actual. Si picname es un nombre de archivo, establece la imagen correspondiente como fondo. Si picname es "nopic", borra la imagen de fondo, si hay alguna presente. Si picname es None, devuelve el nombre de archivo de la imagen de fondo actual.

>>> screen.bgpic()
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()


Este método de TurtleScreen está disponible como una función global solo bajo el nombre clearscreen. La función global clear es otra, derivada del método de Turtle clear.


Borra todos los dibujos y todas las tortugas del la pantalla de la tortuga. Reinicia la ahora vacía pantalla de la tortuga a su estado inicial: fondo blanco, sin imagen de fondo, sin enlaces a eventos o seguimientos.



Este método TurtleScreen esta disponible como una función global solo bajo el nombre resetscreen. La función global reset es otra, derivada del método Turtle reset.


Reinicia todas las tortugas de la pantalla a su estado inicial.

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
  • canvwidth – entero positivo, nueva anchura del lienzo en pixeles

  • canvheight – entero positivo, nueva altura del lienzo en pixeles

  • bgcolorstrng o tupla de color, muevo color de fondo

Si no se dan argumentos, devuelve el actual (ancho y alto del lienzo). Sino redimensiona el lienzo en el que la tortuga está dibujando. No altera la ventana de dibujo. Para ver las partes ocultas del lienzo, use la barra de desplazamiento. Con este método, se pueden hacer visibles aquellas partes de un dibujo que antes estaban fuera del lienzo.

>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)

ej. buscar una tortuga que se escapó por error ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)
  • llx – un número, coordenada x de la esquina inferior izquierda del lienzo

  • lly – un número, coordenada y de la esquina inferior izquierda del lienzo

  • urx – un número, coordenada x de la esquina superior derecha del lienzo

  • ury – un número, coordenada z de la esquina superior derecha del lienzo

Configura coordenadas definidas por el usuario y cambia al modo world si es necesario. Esto realiza un screen.reset(). Si el modo world ya está activo, todos los dibujos se re dibujan de acuerdo a las nuevas coordenadas.

ATENCIÓN: en los sistemas de coordenadas definidos por el usuario, los ángulos pueden aparecer distorsionados.

>>> screen.reset()
>>> screen.setworldcoordinates(-50,-7.5,50,7.5)
>>> for _ in range(72):
...     left(10)
>>> for _ in range(8):
...     left(45); fd(2)   # a regular octagon

Control de animación


delay – entero positivo

Establece o retorna el retraso del dibujo en mili segundos. ( Este es aproximadamente, el tiempo de intervalo entre dos actualizaciones consecutivas del lienzo). Mientras más largo sea el retraso, más lenta la animación.

Argumento opcional:

>>> screen.delay()
>>> screen.delay(5)
>>> screen.delay()
turtle.tracer(n=None, delay=None)
  • n – entero no negativo

  • delay – entero no negativo

Activa o desactiva la animación de la tortuga y establece el retraso para la actualización de los dibujos. Si se da n, solo cada enésima actualización regular de pantalla se realiza realmente. (Puede usarse para acelerar los dibujos de gráficos complejos). Cuando es llamada sin argumentos, devuelve el valor de n guardado actualmente. El segundo argumento establece el valor de retraso (ver delay()).

>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2

Realiza una actualización de la pantalla de la tortuga. Para ser usada cuando tracer está deshabilitada.

Ver también el método RawTurtle/Turtle speed().

Usando eventos de pantalla

turtle.listen(xdummy=None, ydummy=None)

Establece el foco en la pantalla de la tortuga (para recoger eventos de teclado). Los argumentos dummy se proveen en orden de ser capaces de pasar listen() a los métodos onclick.

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
  • fun – una función sin argumentos o None

  • key – una cadena de caracteres: tecla (por ejemplo, «a») o una acción del teclado (por ejemplo, «space»)

Vincula fun a un evento de liberación de una tecla. Si fun es None, los eventos vinculados son removidos. Aclaración: para poder registrar eventos de teclado, TurtleScreen tiene que tener el foco. (ver el método listen().)

>>> def f():
...     fd(50)
...     lt(60)
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onkeypress(fun, key=None)
  • fun – una función sin argumentos o None

  • key – una cadena de caracteres: tecla (por ejemplo, «a») o una acción del teclado (por ejemplo, «space»)

Vincula fun a un evento de pulsado de una tecla, o a cualquier evento de pulsado de tecla si no se da una. Aclaración: para poder registrar eventos de teclado, TurtleScreen tiene que tener el foco. (ver el método listen().)

>>> def f():
...     fd(50)
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onclick(fun, btn=1, add=None)
turtle.onscreenclick(fun, btn=1, add=None)
  • fun – una función con dos argumentos que se invocará con las coordenadas del punto en el que se hizo clic en el lienzo

  • btn – número del botón del mouse, el valor predeterminado es 1 (botón izquierdo del mouse)

  • addTrue o False – si es True, se agrega un nuevo enlace, de lo contrario reemplazará el enlace anterior

Vincula fun a eventos de click del mouse en esta pantalla. Si fun es None, los vínculos existentes son removidos.

Ejemplo de una instancia TurtleScreen llamada screen y una instancia Turtle llamada turtle:

>>> screen.onclick(turtle.goto) # Subsequently clicking into the TurtleScreen will
>>>                             # make the turtle move to the clicked point.
>>> screen.onclick(None)        # remove event binding again


Este método TurtleScreen está disponible como una función global solo bajo el nombre onscreenclick. La función global onclick es otra derivada del método Turtle onclick.

turtle.ontimer(fun, t=0)
  • fun – una función sin argumentos

  • t – un número >= 0

Instala un temporizador que llama a fun cada t milisegundos.

>>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()   ### makes the turtle march around
>>> running = False

Comienza un bucle de evento - llamando a la función mainloop del Tkinter. Debe ser la última declaración en un programa gráfico de turtle. No debe ser usado si algún script es corrido dentro del IDLE en modo -n (Sin subproceso) - para uso interactivo de gráficos turtle.:

>>> screen.mainloop()

Métodos de entrada

turtle.textinput(title, prompt)
  • title – cadena de caracteres

  • prompt – cadena de caracteres

Abre una ventana de diálogo para ingresar una cadena de caracteres. El parámetro title es el título de la ventana de diálogo, prompt es un texto que usualmente describe que información se debe ingresar. Devuelve la cadena ingresada. Si el diálogo es cancelado, devuelve None.

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
  • title – cadena de caracteres

  • prompt – cadena de caracteres

  • default – número (opcional)

  • minval – número (opcional)

  • maxval – número (opcional)

Pop up a dialog window for input of a number. title is the title of the dialog window, prompt is a text mostly describing what numerical information to input. default: default value, minval: minimum value for input, maxval: maximum value for input. The number input must be in the range minval .. maxval if these are given. If not, a hint is issued and the dialog remains open for correction. Return the number input. If the dialog is canceled, return None.

>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

Configuración y métodos especiales


mode – una de las cadenas «standard», «logo» o «world»

Establece el mode de la tortuga («standard», «logo» o «world») y realiza un reinicio. Si no se da «mode», retorna el modo actual.

El modo «standard» es compatible con el antiguo turtle. El modo «logo» es compatible con la mayoría de los gráficos de tortuga Logo. El modo «world» usa coordenadas de mundo definidas por el usuario. Atención: en este modo los ángulos aparecen distorsionados si la relación de unidad x/y no es igual a 1.


Rumbo inicial de la tortuga

ángulos positivos


hacia la derecha (este)

sentido antihorario


hacia arriba (norte)

sentido horario

>>> mode("logo")   # resets turtle heading to north
>>> mode()

cmode – uno de los valores 1.0 o 255

Return the colormode or set it to 1.0 or 255. Subsequently r, g, b values of color triples have to be in the range 0..*cmode*.

>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
>>> screen.colormode(255)
>>> screen.colormode()
>>> turtle.pencolor(240,160,80)

Devuelve el lienzo de este TurtleScreen. Útil para conocedores que saben que hace con un TKinter Canvas.

>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>

Devuelve la lista de nombres de todas las formas de la tortuga actualmente disponibles.

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)

Hay tres formas distintas de llamar a esta función:

  1. name es el nombre de un archivo gif y shape es None: instala la imagen correspondiente.

    >>> screen.register_shape("turtle.gif")


    Las imágenes de tipo shapes no rotan cuando la tortuga gira, así que ellas ¡no muestran el rumbo de la tortuga!

  2. name es una cadena de caracteres arbitraria y shape es una tupla de pares de coordenadas: Instala la forma poligonal correspondiente.

    >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
  3. name is an arbitrary string and shape is a (compound) Shape object: Install the corresponding compound shape.

Agregar una forma de tortuga a la lista de formas de TurtleScreen. Solo las formas registradas de esta manera pueden ser usadas invocando el comando shape(shapename).


Devuelve la lista de tortugas en la pantalla.

>>> for turtle in screen.turtles():
...     turtle.color("red")

Devuelve la altura de la ventana de la tortuga.

>>> screen.window_height()

Devuelve el ancho de la ventana de la tortuga.

>>> screen.window_width()

Métodos específicos de Screen, no heredados de TurtleScreen


Apaga la ventana gráfica de la tortuga.


Ata el método bye() al click del ratón sobre la pantalla.

Si el valor «using_IDLE» en la configuración del diccionario es False (valor por defecto), también ingresa mainloop. Observaciones: si se usa la IDLE con el modificador (no subproceso) -n, este valor debe establecerse a True en turtle.cfg. En este caso el propio mainloop de la IDLE está activa también para script cliente.

turtle.setup(width=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

Establece el tamaño y la posición de la ventana principal. Los valores por defecto de los argumentos son guardados en el diccionario de configuración y puede ser cambiado a través del archivo turtle.cfg.

  • width – si es un entero, el tamaño en pixeles, si es un número flotante, una fracción de la pantalla; el valor por defecto es 50% de la pantalla

  • height – si es un entero, la altura en pixeles, si es un número flotante, una fracción de la pantalla; el valor por defecto es 75% de la pantalla

  • startx – si es positivo, punto de inicio en pixeles desde la esquina izquierda de la pantalla, si es negativo desde la esquina derecha de la pantalla, si es None, centra la ventana horizontalmente

  • starty – si es positivo, punto de inicio en pixeles desde la parte superior de la pantalla, si es negativo desde la parte inferior de la pantalla, si es None, centra la ventana verticalmente

>>> screen.setup (width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers

titlestring – una cadena de caracteres que se muestra en la barra de título de la ventana gráfica de la tortuga

Establece el título de la ventana de la tortuga a titlestring.

>>> screen.title("Welcome to the turtle zoo!")

Clases públicas

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)

canvas – a tkinter.Canvas, a ScrolledCanvas or a TurtleScreen

Crea una tortuga. La tortuga tiene todos los métodos descriptos anteriormente como «métodos de «Turtle/RawTurtle».

class turtle.Turtle

Subclase de RawTurtle, tiene la misma interface pero dibuja sobre una objeto por defecto Screen creado automáticamente cuando es necesario por primera vez.

class turtle.TurtleScreen(cv)

cv – a tkinter.Canvas

Provides screen oriented methods like bgcolor() etc. that are described above.

class turtle.Screen

Subclase de TurtleScreen, con cuatro métodos agregados.

class turtle.ScrolledCanvas(master)

master – algunos widgets TKinter para contener el ScrollCanvas, por ejemplo un lienzo Tkinter con barras de desplazamiento agregadas

Usado por la clase Screen, que proporciona automáticamente un ScrolledCanvas como espacio de trabajo para las tortugas.

class turtle.Shape(type_, data)

type_ – una de las cadenas de caracteres «polygon», «image», «compound»

Estructura de datos que modela las formas. El par (type_, data) debe seguir estas especificaciones:




una tupla para el polígono, por ejemplo: una tupla de par de coordenadas


una imagen (en esta forma solo se usa ¡internamente!)


None (una forma compuesta tiene que ser construida usando el método addcomponent())

addcomponent(poly, fill, outline=None)
  • poly – un polígono, por ejemplo una tupla de pares de números

  • fill – un color con el que el polígono será llenado

  • outline – un color con el que se delineará el polígono (se de ingresa)


>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()

Ver Formas compuestas.

class turtle.Vec2D(x, y)

Una clase de vectores bidimensionales, usado como clase de ayuda para implementar gráficos de tortuga. Puede ser útil para los programas de gráficos de tortugas también. Derivado de la tupla, ¡por lo que un vector es una tupla!

Proporciona (para a, b vectores, k números)

  • a + b suma de vectores

  • a - b resta de vectores

  • a * b producto interno

  • k * a y a * k multiplicación con escalar

  • abs(a) valor absoluto de a

  • a.rotate(angle) rotación


A turtle object draws on a screen object, and there a number of key classes in the turtle object-oriented interface that can be used to create them and relate them to each other.

A Turtle instance will automatically create a Screen instance if one is not already present.

Turtle is a subclass of RawTurtle, which doesn’t automatically create a drawing surface - a canvas will need to be provided or created for it. The canvas can be a tkinter.Canvas, ScrolledCanvas or TurtleScreen.

TurtleScreen is the basic drawing surface for a turtle. Screen is a subclass of TurtleScreen, and includes some additional methods for managing its appearance (including size and title) and behaviour. TurtleScreen’s constructor needs a tkinter.Canvas or a ScrolledCanvas as an argument.

The functional interface for turtle graphics uses the various methods of Turtle and TurtleScreen/Screen. Behind the scenes, a screen object is automatically created whenever a function derived from a Screen method is called. Similarly, a turtle object is automatically created whenever any of the functions derived from a Turtle method is called.

To use multiple turtles on a screen, the object-oriented interface must be used.

Ayuda y configuración

Cómo usar la ayuda

Los métodos públicos de las clases Screen y Turtle están ampliamente documentados a través de cadenas de documentación. Por lo tanto, estos se pueden usar como ayuda en línea a través de las instalaciones de ayuda de Python:

  • Cuando se usa IDLE, la información sobre herramientas muestra las firmas y las primeras líneas de las cadenas de documentos de las llamadas de función/método escritas.

  • Llamar a help() en métodos o funciones muestra los docstrings:

    >>> help(Screen.bgcolor)
    Help on method bgcolor in module turtle:
    bgcolor(self, *args) unbound turtle.Screen method
        Set or return backgroundcolor of the TurtleScreen.
        Arguments (if given): a color string or three numbers
        in the range 0..colormode or a 3-tuple of such numbers.
        >>> screen.bgcolor("orange")
        >>> screen.bgcolor()
        >>> screen.bgcolor(0.5,0,0.5)
        >>> screen.bgcolor()
    >>> help(Turtle.penup)
    Help on method penup in module turtle:
    penup(self) unbound turtle.Turtle method
        Pull the pen up -- no drawing when moving.
        Aliases: penup | pu | up
        No argument
        >>> turtle.penup()
  • Los docstrings de las funciones que se derivan de los métodos tienen una forma modificada:

    >>> help(bgcolor)
    Help on function bgcolor in module turtle:
        Set or return backgroundcolor of the TurtleScreen.
        Arguments (if given): a color string or three numbers
        in the range 0..colormode or a 3-tuple of such numbers.
          >>> bgcolor("orange")
          >>> bgcolor()
          >>> bgcolor(0.5,0,0.5)
          >>> bgcolor()
    >>> help(penup)
    Help on function penup in module turtle:
        Pull the pen up -- no drawing when moving.
        Aliases: penup | pu | up
        No argument
        >>> penup()

Estos docstrings modificados se crean automáticamente junto con las definiciones de función que se derivan de los métodos en el momento de la importación.

Traducción de cadenas de documentos a diferentes idiomas

Existe una utilidad para crear un diccionario cuyas claves son los nombres de los métodos y cuyos valores son los docstrings de los métodos públicos de las clases Screen y Turtle.


filename – una cadena de caracteres, utilizada como nombre de archivo

Crea y escribe un diccionario-docstring en un script de Python con el nombre de archivo dado. Esta función tiene que ser llamada explícitamente (no es utilizada por las clases de gráficos de tortugas). El diccionario de docstrings se escribirá en el script de Python filename.py. Está destinado a servir como plantilla para la traducción de las cadenas de documentos a diferentes idiomas.

Si usted (o sus estudiantes) desea utilizar turtle con ayuda en línea en su idioma nativo, debe traducir los docstrings y guardar el archivo resultante como, por ejemplo, turtle_docstringdict_german.py.

Si tiene una entrada adecuada en su archivo turtle.cfg, este diccionario se leerá en el momento de la importación y reemplazará los docstrings originales en inglés.

En el momento de escribir este artículo, existen diccionarios de docstrings en alemán e italiano. (Solicitudes por favor a glingl@aon.at.)

Cómo configurar Screen and Turtles

La configuración predeterminada incorporada imita la apariencia y el comportamiento del antiguo módulo de tortuga para mantener la mejor compatibilidad posible con él.

Si desea utilizar una configuración diferente que refleje mejor las características de este módulo o que se adapte mejor a sus necesidades, por ejemplo, para su uso en un aula, puede preparar un archivo de configuración turtle.cfg que se leerá en el momento de la importación y modificará la configuración de acuerdo con su configuración.

The built in configuration would correspond to the following turtle.cfg:

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 400
canvheight = 300
mode = standard
colormode = 1.0
delay = 10
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = Python Turtle Graphics
using_IDLE = False

Breve explicación de las entradas seleccionadas:

  • The first four lines correspond to the arguments of the Screen.setup method.

  • Line 5 and 6 correspond to the arguments of the method Screen.screensize.

  • shape puede ser cualquiera de las formas integradas, por ejemplo: arrow, turtle, etc. Para obtener más información, pruebe con help(shape).

  • If you want to use no fill color (i.e. make the turtle transparent), you have to write fillcolor = "" (but all nonempty strings must not have quotes in the cfg file).

  • Si desea reflejar el estado de la tortuga, debe usar resizemode = auto.

  • If you set e.g. language = italian the docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. in the same directory as turtle).

  • Las entradas exampleturtle y examplescreen definen los nombres de estos objetos a medida que aparecen en las cadenas de documentos. La transformación de método-docstrings en función-docstrings eliminará estos nombres de las docstrings.

  • using_IDLE: Set this to True if you regularly work with IDLE and its -n switch («no subprocess»). This will prevent exitonclick() to enter the mainloop.

Puede haber un archivo turtle.cfg en el directorio donde se almacena turtle y uno adicional en el directorio de trabajo actual. Este último anulará la configuración del primero.

El directorio Lib/turtledemo contiene un archivo turtle.cfg. Puede estudiarlo como un ejemplo y ver sus efectos al ejecutar las demostraciones (preferiblemente no desde el visor de demostraciones).

turtledemo — Scripts de demostración

El paquete turtledemo incluye un conjunto de scripts de demostración. Estos scripts se pueden ejecutar y visualizar utilizando el visor de demostración suministrado de la siguiente manera:

python -m turtledemo

Alternativamente, puede ejecutar los scripts de demostración individualmente. Por ejemplo,

python -m turtledemo.bytedesign

El directorio del paquete turtledemo contiene:

  • Un visor de demostración __main__.py que se puede utilizar para ver el código fuente de los scripts y ejecutarlos al mismo tiempo.

  • Múltiples scripts que demuestran diferentes características del módulo turtle. Se puede acceder a los ejemplos a través del menú de ejemplos. También se pueden ejecutar de forma independiente.

  • Un archivo turtle.cfg que sirve como ejemplo de cómo escribir y usar dichos archivos.

Los scripts de demostración son:





patrón de gráficos de tortuga clásica compleja

tracer(), retrasar (delay), update()


gráficos dinámicos de Verhulst, muestra que los cálculos de la computadora pueden generar resultados a veces contra las expectativas del sentido común

coordenadas mundiales


reloj analógico que muestra la hora de su computadora

tortugas como manecillas de reloj, temporizador


experimento con r, g, b



3 árboles de ancho primero



Curvas Hilbert & Koch



etnomatemáticas (kolams indios)



Torres de Hanoi

Tortugas rectangulares como discos de Hanoi (shape, tamaño de forma)


juega el clásico juego de nim con tres montones de palos contra la computadora.

tortugas como nimsticks, impulsado por eventos (mouse, teclado)


programa de dibujo super minimalista




turtle: apariencia y animación


embaldosado aperiódico con cometas y dardos



simulación de sistema gravitacional

formas compuestas, Vec2D


un patrón del artículo de wikipedia sobre gráficos de tortuga (turtle)

clone(), undo()


tortugas bailarinas que giran por parejas en dirección opuesta

formas compuestas, clonar tamaño de forma, tilt, get_shapepoly, update


demostración visual de diferentes métodos de ordenamiento

alineación simple, aleatorización


un primer árbol de amplitud (gráfico, usando generadores)



diseño simple

tortugas en dos lienzos (two_canvases)


otro ejemplo elemental



Cambios desde Python 2.6

  • The methods Turtle.tracer, Turtle.window_width and Turtle.window_height have been eliminated. Methods with these names and functionality are now available only as methods of Screen. The functions derived from these remain available. (In fact already in Python 2.6 these methods were merely duplications of the corresponding TurtleScreen/Screen methods.)

  • The method Turtle.fill() has been eliminated. The behaviour of begin_fill() and end_fill() have changed slightly: now every filling process must be completed with an end_fill() call.

  • A method Turtle.filling has been added. It returns a boolean value: True if a filling process is under way, False otherwise. This behaviour corresponds to a fill() call without arguments in Python 2.6.

Cambios desde Python 3.0

  • The Turtle methods shearfactor(), shapetransform() and get_shapepoly() have been added. Thus the full range of regular linear transforms is now available for transforming turtle shapes. tiltangle() has been enhanced in functionality: it now can be used to get or set the tilt angle.

  • The Screen method onkeypress() has been added as a complement to onkey(). As the latter binds actions to the key release event, an alias: onkeyrelease() was also added for it.

  • The method Screen.mainloop has been added, so there is no longer a need to use the standalone mainloop() function when working with Screen and Turtle objects.

  • Two input methods have been added: Screen.textinput and Screen.numinput. These pop up input dialogs and return strings and numbers respectively.

  • Se han agregado dos scripts de ejemplo tdemo_nim.py y tdemo_round_dance.py al directorio Lib/turtledemo.