TUTORIAL 7
Lenguaje de programación: Python
Autor: José Gerardo Carrillo González
Contenido
Librería turtle ................................................................................................................................2
Ejemplo practico ...................................................................................................................... 13
El juego gato............................................................................................................................... 14
El juego pong .............................................................................................................................. 16
Librería turtle
Imagine un robot tortuga (en inglés, turtle) que tiene una pluma y que le podemos dar instrucciones
para que dibuje, esto lo podemos hacer con la librería turtle. Inicialmente el robot se encuentra en
la coordenada (0,0) y apunta hacia la dirección positiva del eje-x (hacia el este), considerando un
plano de dos dimensiones como el de la Figura 1 (tomada de [Link]
guide-python-turtle/). La coordenada (0,0) se conoce como Home.
Figura 1. Plano de dos dimensiones
Para iniciar, importamos el módulo turtle,
import turtle
Para mover la tortuga en la dirección actual en la que se encuentre mientras dibuja una línea
mientras lo hace utilizamos la función [Link](pixeles), y como argumento pasamos la
cantidad de pixeles (1 cm = 37.7952 pixeles) que se debe mover; para moverla en sentido contrario
(respecto hacia donde apunta) utilizamos la función [Link](pixeles). Para que gire en la
dirección de las manecillas del reloj utilizamos la función [Link](grados), y como argumento
pasamos los grados que debe girar; para girar en la dirección opuesta a las manecillas del reloj
utilizamos la función [Link](grados). Ejemplo, trazar un cuadrado de 100 pixeles por lado,
[Link](100)
[Link](90)
[Link](100)
[Link](90)
[Link](100)
[Link](90)
[Link](100)
Salida en Python Turtle Graphics:
Para cambiar el color de la pluma lo hacemos con la función [Link]('color'), siendo 'color' el
color de nuestra elección; para cambiar el ancho de la pluma lo hacemos con la función
[Link](entero), siendo entero el ancho de la pluma. Ejemplo, trazar nuevamente un rectángulo
con cada lado de diferente color y de diferente ancho,
[Link]('black')
[Link](1)
[Link](100)
[Link](90)
[Link]('blue')
[Link](2)
[Link](100)
[Link](90)
[Link]('green')
[Link](3)
[Link](100)
[Link](90)
[Link]('red')
[Link](4)
[Link](100)
Salida en Python Turtle Graphics:
Es posible mover la pluma sin dibujar (levantamos la pluma), para esto usamos la función
[Link](), luego para habilitar volver a dibujar (bajamos la pluma) usamos la función
[Link](). Ejemplo,
[Link](3)
[Link](100)
[Link](90)
[Link]()
[Link](100)
[Link](90)
[Link]()
[Link](100)
[Link](90)
[Link]()
[Link](100)
[Link]()
Salida en Python Turtle Graphics:
Como se comentó previamente, la posición inicial de la tortuga es (0,0), con la función
[Link]() mandamos a la tortuga a la posición inicial; con la funcion [Link]() obtenemos la
coordenada actual de la tortuga; con la funcion [Link]() limpiamos la pantalla. Ejemplo,
[Link](2)
[Link](100)
[Link](90+45)
[Link](150)
[Link](45+45)
[Link](150)
[Link](45+90)
[Link]()
print([Link]())
Salida en Python Turtle Graphics:
Salida en IDLE Shell:
(100.00,0.00)
(-6.07,106.07)
(-112.13,0.00)
(0.00,0.00)
Podemos referenciar la tortuga y la pantalla en la que aparece la tortuga con identificadores.
Ejemplo
s = [Link]()
t = [Link]()
Por lo que ahora con s hacemos referencia a la pantalla y con t a la tortuga. Para mover la tortuga
a una coordenada especifica lo hacemos con la función goto, y como argumento pasamos la
coordenada hacia dónde queremos trasladar la tortuga. Ejemplo
[Link](100,100)
[Link](200,0)
[Link](0,0)
Salida en Python Turtle Graphics:
Para dibujar un círculo lo podemos hacer con el método circle(radio), donde radio es el radio del
círculo; para dibujar un círculo con relleno lo podemos hacer con el método dot(diámetro), donde
diámetro es el diámetro del círculo con relleno. Ejemplo
[Link](2)
[Link](50)
print([Link]())
[Link]()
[Link](0,-100)
[Link]()
[Link](100)
print([Link]())
Salida en Python Turtle Graphics:
Salida en IDLE Shell:
(-0.00,0.00)
(0.00,-100.00)
Por default, la pantalla para visualizar la tortuga (Python Turtle Graphics) muestra un fondo
blanco, esto se puede cambiar con la función [Link]("color"), siendo color el color de
nuestra elección. Con la función [Link]("nombre") podemos cambiar el título de la pantalla por
nombre. Otra manera de cambiar el tamaño de la pluma es con método [Link](tamaño), en donde
t es un objeto de clase [Link] y tamaño es el tamaño que queremos tenga la pluma. Para
rellenar una imagen iniciamos con t.begin_fill(), luego las instrucciones para crear la imagen,
luego terminamos con t.end_fill(). Ejemplo
t.begin_fill()
[Link](200)
[Link](90)
[Link](100)
[Link](90)
[Link](200)
[Link](90)
[Link](100)
t.end_fill()
Salida en pantalla:
Para cambiar la forma de la tortuga lo podemos hacer con el método [Link]("forma"), siendo
forma una de la siguientes opciones: square, arrow, circle, turtle, triangle, classic; la forma con la
que inicialmente aparece la tortuga es classic. Para cambiar la velocidad de la tortuga (que por
default es 3) lo podemos hacer con la función [Link](velocidad), siendo velocidad (un entero o un
string) la velocidad de la tortuga; si es un entero esta puede variar en el rango [0,10], siendo 1 la
velocidad más baja y 10 la velocidad más alta, con 0 los cambios de posición y de ángulo de la
tortuga no serán animados (suceden instantáneamente); si es un string “fastest” equivale a 0, “fast”
equivale a 10, “normal” equivale a 6, “slow” equivale a 3, y “slowest” equivale a 1. Supongamos
que queremos una tortuga que dibuje de color azul, que el relleno de lo que dibujemos sea gris,
que el tamaño de la pluma sea 5, y que la velocidad de la tortuga sea 3, ejemplo,
[Link](pencolor="blue", fillcolor="gray", pensize=5, speed=3)
t.begin_fill()
[Link](100)
t.end_fill()
Salida en pantalla:
Otra manera de levantar la pluma para no dibujar mientras la movemos, seria con el método
[Link](), para bajar la pluma y poder volver a dibujar mientras movemos la pluma, seria con el
método [Link](). Para revertir la última instrucción que se le dio a la tortuga t podemos usar
el método [Link](). Para limpiar la pantalla con respecto a lo que se haya echo con la tortuga t lo
podemos hacer con el método [Link](), después de llamar este método la tortuga t permanece en
la posición en la que se quedó y si existen otras tortugas lo dibujado con estas no se ve afectado.
Para limpiar lo que se ha hecho con la tortuga t, y resetearla a su estado original (tamaño, forma,
color, posicion), lo hacemos con el método [Link](). Se puede dibujar con varias tortugas en un
mismo código, ejemplo,
t1 = [Link]();[Link](2)
t2 = [Link]();[Link](2)
t3 = [Link]();[Link](2)
[Link]()
[Link](150)
[Link]()
[Link](50)
print([Link]())
[Link]()
[Link](150)
[Link]()
[Link](50)
print([Link]())
[Link]()
[Link](90)
[Link](100)
[Link]()
[Link](45)
[Link](120)
[Link](45+90)
[Link](170)
[Link](90+45)
[Link](120)
print([Link]())
Salida en pantalla:
Salida en IDLE Shell:
(150.00,0.00)
(-150.00,0.00)
(-0.29,-100.00)
Podemos construir un cuadrado utilizando un for, ejemplo,
t=[Link]();[Link](2)
for i in range(4):
[Link](100)
[Link](90)
Salida en pantalla:
Ejemplo de crear una espiral,
t=[Link]();[Link](2)
for steps in range(50):
for c in ('blue', 'red', 'green'):
[Link](c)
[Link](steps)
[Link](30)
Salida en pantalla:
Si t es un objeto de tipo Turtle y considerando que la posición de la tortuga es (x,y), con [Link](x)
establecemos la primera coordenada a x (entero o flotante), con [Link](y) establecemos la segunda
coordenada a y (entero o flotante), con [Link](angulo) establecemos la orientación de la
tortuga a angulo (entero o flotante). Para obtener la coordenada x de la tortuga lo hacemos con el
método [Link](); para obtener la coordenada y de la tortuga lo hacemos con el método [Link]();
para obtener la dirección de la tortuga lo hacemos con el método [Link]().
Si la orientación de la tortuga es 0 grados entonces ve hacia el este, si es 90 grados entonces ve
hacia el norte, si es 180 grades ve hacia el oeste, si es 270 grados ve hacia el sur. Con [Link]() la
tortuga regresa la posición (0,0) y a la orientación de inicio (en el modo standard 0 grados ve hacia
el este y en el modo logo ve hacia el norte). Para dibujar in circulo lo podemos hacer con el método
[Link](radio, extent=None), donde radio es el radio del circulo y extent puede ser un número o
None, si es un número va de 0 a 360, entonces para dibujar un semicírculo extent=180. Para obtener
el ángulo entre la tortuga y la posición (x,y) se hace con el método [Link](x,y). Para conocer la
distancia entre la tortuga t y la posicion (x,y) lo hacemos con el método [Link](x,y); para
conocer la distancia entre la tortuga t1 (objeto de tipo Turtle) y la tortuga t2 (objeto de tipo Turtle)
lo hacemos con el método [Link](t2). El método [Link]() regresa True si el lápiz esta abajo,
False en caso contrario.
Tenemos la opción de escribir texto con el método [Link](arg, move=False, align='left',
font=('Arial', 8, 'normal')), arg es el texto que va a escribir la tortuga, move=True desplaza el lápiz
a la esquina inferior derecha del texto, el texto se escribe con respecto a la posicion de la tortuga
y con la alineación que se indique con align (“left”, “center” or “right), font es igual a una tupla
con tres valores: nombre de fuente, tamaño de fuente, y tipo de fuente.
Para ocultar la tortuga lo hacemos con el método [Link](), para mostrar la tortuga lo hacemos
con el método [Link](); el método [Link]() regresa True si la tortuga es visible, False si
esta oculta.
Para mandar a llamar una función cuando se le da clic a la tortuga lo podemos hacer con el método
[Link](fun, btn=1), fun es una función con dos parámetros (cuando es llamada recibe como
argumentos la posición en el eje-x y en el eje-y del mouse cuando se le dio clic a la tortuga), btn=1
indica el botón izquierdo del mouse; con [Link](None) se elimina el vinculo entre la función y
el evento de dar clic en la tortuga. Para mandar a llamar una función cuando se suelta el botón del
mouse al estar sobre la tortuga lo podemos hacer con el método [Link](fun, btn=1), siendo fun
y btn lo mismo que para [Link]. Para mandar a llamar una función (repetidamente) mientras
estemos moviendo el mouse después de dar clic en la tortuga (sin soltar el botón) lo podemos hacer
con el método [Link](fun, btn=1), siendo fun y btn lo mismo que para [Link].
Para capturar texto (un str) lo podemos hacer con el método textinput(title, prompt), donde title
(str) será el título de la ventana y promt (str) será la instrucción de lo que debemos ingresar. Para
capturar un número (un float) lo podemos hacer con el método [Link](title, prompt,
default=None, minval=None, maxval=None), donde title y propt son lo mismo que lo mencionado
anteriormente, default es el valor que aparece en la ventana, minval es el mínimo valor de la
entrada y maxval es el máximo valor de la entrada; default, minval y maxval son números.
Para estirar la torguta lo podemos hacer con el método [Link](stretch_wid=None,
stretch_len=None, outline=None), stretch_wid es el factor de estiramiento de la tortuga
perpendicular a su orientación, stretch_len es el factor de estiramiento en la dirección de su
orientación, outline determina el ancho de la forma; los tres parámetros antes mencionados deben
ser un número positivo.
Ejemplo practico
En este juego dos tortugas compiten en una carrera.
2025-03-11 [Link]
El juego gato
import turtle
t=[Link]()
s=[Link]();
c=500/3;
[Link](pencolor='black',pensize=2)
[Link]()
[Link](-250+c,250)
[Link]()
[Link](-250+c,-250)
[Link]()
[Link](250-c,250)
[Link]()
[Link](250-c,-250)
[Link]()
[Link](-250,250-c)
[Link]()
[Link](250,250-c)
[Link]()
[Link](-250,-250+c)
[Link]()
[Link](250,-250+c)
style = ('Courier', 30, 'italic')
def escribir(p1,p2,p3):
[Link]()
[Link](p1,p2)
[Link]()
[Link](p3,font=('Arial', 100, 'normal') )
def imprimir():
print(f'Gana el jugador que conduce la {ca}')
uno='1';dos='2';tres='3';cuatro='4';cinco='5';
seis='6';siete='7';ocho='8';nueve='9';
it=0
while True:
nu=[Link]('Entrada', 'Escribe coordenada: ', minval=1, maxval=9)
ca=[Link]('Entrada', 'Escribe caracter: ')
#nu=int(input('Escribe coordenada: '))
#ca=input('Escribe caracter: ')
if nu==1:
escribir(-250+(c/4),250-c,ca);uno=ca
elif nu==2:
escribir(-250+(c*1)+(c/4),250-c,ca);dos=ca
elif nu==3:
escribir(-250+(c*2)+(c/4),250-c,ca);tres=ca;
if nu==4:
escribir(-250+(c/4),250-(c*2),ca);cuatro=ca
elif nu==5:
escribir(-250+(c*1)+(c/4),250-(c*2),ca);cinco=ca
elif nu==6:
escribir(-250+(c*2)+(c/4),250-(c*2),ca);seis=ca
if nu==7:
escribir(-250+(c/4),250-(c*3),ca);siete=ca
elif nu==8:
escribir(-250+(c*1)+(c/4),250-(c*3),ca);ocho=ca
elif nu==9:
escribir(-250+(c*2)+(c/4),250-(c*3),ca);nueve=ca
if (uno==dos and dos==tres):
imprimir();break
if (cuatro==cinco and cinco==seis):
imprimir();break
if (siete==ocho and ocho==nueve):
imprimir();break
if (uno==cuatro and cuatro==siete):
imprimir();break
if (dos==cinco and cinco==ocho):
imprimir();break
if (tres==seis and seis==nueve):
imprimir();break
if (uno==cinco and cinco==nueve):
imprimir();break
if (tres==cinco and cinco==siete):
imprimir();break
it+=1
if it==9:
print('Empate');break
El juego pong
import turtle
import random
import math
def moveDown():
y = [Link]()
y -= stepy
[Link](y)
def moveUp():
y = [Link]()
y += stepy
[Link](y)
def moveDownB():
y = [Link]()
y -= stepy
[Link](y)
def moveUpB():
y = [Link]()
y += stepy
[Link](y)
def restartGame():
[Link] = speedx
[Link] = [Link](pos)
def imprimir():
[Link](f' A:{playerAScore} B:{playerBScore} ', align='center', font=('Courier', 30, '
normal'))
def terminar():
global f1;
f1=True;
cm_pix=37.795280352161;
pos=[.01, .0125, .015, .0175, .02, .03, .04, .05]
f1=False;altura=2.5;stepy=15;speedx=0.05
ajuste=altura*cm_pix/3.5
screen = [Link]()
[Link]('black')
[Link]('Pong')
[Link](width=800, height=600)
[Link](0)
playerA = [Link]()
[Link]('white')
[Link](0)
[Link]()
[Link](-300, 0)
[Link]('square')
[Link](altura, 0.5, 1)
playerAScore = 0
playerB = [Link]()
[Link]('white')
[Link](0)
[Link]()
[Link](+300, 0)
[Link]('square')
[Link](altura, 0.5, 1)
playerBScore = 0
ball = [Link]()
[Link]('white')
[Link](0)
[Link]()
[Link]('circle')
[Link](0.5, 0.5, 0.5)
[Link] = 0
[Link] = 0
pen = [Link]()
[Link]('white')
[Link](0)
[Link]()
[Link](0, 260)
[Link]()
imprimir()
[Link]()
[Link](moveDown, 's')
[Link](moveUp, 'w')
[Link](moveDownB, 'Down')
[Link](moveUpB, 'Up')
[Link](restartGame, 'space')
[Link](terminar, 'q')
while True:
if f1:
[Link]()
break
[Link]()
[Link]([Link]() + [Link])
[Link]([Link]() + [Link])
if [Link]()+ajuste >= 300:
[Link](300-(ajuste))
if [Link]()-(ajuste) <= -300:
[Link](-300+(ajuste))
if [Link]()+ajuste >= 300:
[Link](300-(ajuste))
if [Link]()-(ajuste) <= -300:
[Link](-300+(ajuste))
if [Link]() < -295:
[Link] *= -1
elif [Link]() > 295:
[Link] *= -1
if ([Link]() < -290 and [Link]() > -305) and ([Link]() < [Link]()+ajuste and
[Link]() > [Link]()-ajuste):
[Link](-290)
[Link] *= -1
[Link] = [Link]( [Link](pos),[Link] )
if ([Link]() > 290 and [Link]() < 305) and ([Link]() < [Link]()+ajuste and
[Link]() > [Link]()-ajuste):
[Link](290)
[Link] *= -1
[Link] = [Link]( [Link](pos),[Link] )
if [Link]() < -333:
[Link](0,0)
[Link] *= 0
[Link] *= 0
playerBScore += 1
[Link]()
imprimir()
elif [Link]() > 333:
[Link](0,0)
[Link] *= 0
[Link] *= 0
playerAScore += 1
[Link]()
imprimir()