prefacio

Se acerca el Festival Qixi, el blogger ha creado una ola de amor en su tiempo libre, amigos interesados, ¡vengan y echen un vistazo!

Primeros pasos con la tortuga

Turtle es una herramienta de dibujo simple e intuitiva, que puede ayudarlo a crear varios gráficos a través de comandos simples. Turtle era originalmente una biblioteca de gráficos basada en el lenguaje Logo. En Python, se proporciona como parte de la biblioteca estándar.

caso sencillo

Aquí hay un ejemplo básico de cómo comenzar con el dibujo de tortugas:

import turtle

Crear una ventana de lienzo

window = turtle.Screen()

Crear un pincel (objeto tortuga)

pen = turtle.Turtle()

dibujar un cuadrado

for _ in range(4):
    pen.forward(100)
    pen.right(90)

Finalice el dibujo y cierre la ventana del lienzo.

turtle.done()

En el ejemplo anterior, primero importamos el módulo tortuga y creamos un objeto de ventana de lienzo. Luego, creamos un objeto de pincel que podemos usar para dibujar la forma que queremos.
Después de crear el bolígrafo, usamos un bucle para dibujar un cuadrado, avanzamos la distancia especificada (aquí 100) a través del comando pen.forward() y giramos a la derecha el ángulo especificado (aquí 90) a través del pen.right( ) comando grados) para cambiar la dirección del pincel.
Finalmente, llamamos a turtle.done() para terminar de dibujar y cerrar la ventana del lienzo.
Este es solo un ejemplo simple del dibujo de tortugas, puede llamar a diferentes comandos y métodos para dibujar imágenes de varias formas, como líneas, círculos, polígonos, etc. Turtle también proporciona otros métodos para controlar el color, el grosor, el relleno y otras propiedades del pincel.

función de entrada

Cuando estás dibujando con Turtle, hay algunas funciones básicas que te ayudan a mover el pincel y dibujar varias formas. Aquí hay una introducción a algunas funciones básicas de Turtle:

adelante (distancia): mueve el pincel hacia adelante, especificando la distancia a mover (en píxeles).
hacia atrás (distancia) : Mueve el pincel hacia atrás, especificando la distancia a mover (en píxeles).
right(angle) : Gira el pincel hacia la derecha, especificando el ángulo de rotación (en grados).
left(angle) : Gira el pincel hacia la izquierda, especificando el ángulo de rotación (en grados).
penup() : Levanta el pincel y se mueve sin dibujar líneas.
pendown() : deja el pincel y dibuja líneas a medida que se mueve.
goto(x, y) : Mueve el pincel a la posición de coordenadas especificada (x, y).
setx(x) : Establece la coordenada x del pincel en el valor especificado.
sety(y) : establece la coordenada y del pincel en el valor especificado.
setheading(angle) : establece la orientación del pincel y especifica el ángulo de rotación (en grados).
circle(radius) : Dibuja un círculo con un radio especificado.
dot(size, color) : Dibuja un punto, especificando tamaño y color.

Estas son solo algunas de las funciones básicas disponibles en el módulo Turtle, hay muchas más funciones que se pueden usar para dibujar varios polígonos, rellenar formas, controlar el color del pincel, el grosor, etc. Puede consultar la sección del módulo Turtle en la documentación oficial de Python u otros tutoriales y códigos de muestra relacionados con Turtle para obtener más información sobre las funciones detalladas y el uso del dibujo de Turtle.

ola de amor

programación

import turtle as tu
import random as ra

tu.setup(1.0, 1.0)  # 设置画板大小（小数表示比例，整数表示大小）
tu.screensize(1.0, 1.0)  # 设置屏幕大小
tu.bgcolor('black')  # 设置画布背景颜色
t = tu.Pen()  # 设置画笔
t.ht()  # 隐藏画笔
colors = ['pink', 'hotpink', 'deeppink', 'lightpink']  # 爱心的颜色列表,可以设置自己喜欢的颜色噢
# colors = ['skyblue', 'lightblue', 'blue', 'royalblue'] # 蓝色系

class Star():  # 星星类
    def __init__(self, r):  # 初始化
        self.r = r  # 爱心的半径
        self.x = 0 # 爱心的横坐标
        self.y = 120  # 爱心的纵坐标
        self.color = ra.choice(colors)  # 爱心的颜色
        self.outline = 2 # 爱心的外框大小（可不要）

    def draw(self):  # 画爱心函数，就是用turtle画爱心
        t.pensize(self.outline)
        t.penup()
        t.color(self.color)
        t.goto(self.x, self.y)
        t.pendown()
        # t.begin_fill()
        # t.fillcolor('pink')
        t.setheading(120)
        t.circle(self.r, 195)
        t.fd(self.r * 2.4)
        t.lt(90)
        t.fd(self.r * 2.4)
        t.circle(self.r, 195)
        # t.end_fill()

    def change(self):  # 改变爱心的大小（爱心不断增大）
        if self.r <= 100:
            self.r += 1
        else:
            self.r = 1
            self.x = 0
            self.y = 120
            self.c = ra.choice(colors)

Stars = []  # 星星列表
for i in range(200):  # 循环增加星星
    Stars.append(Star(i-1))
while True:  # 开始画星星
    tu.tracer(0)
    t.clear()
    for i in range(99):
        Stars[i].draw()
        Stars[i].change()
    tu.update()
tu.mainloop()

análisis de programas

Este código usa el módulo tortuga de Python para lograr el efecto de dibujar estrellas de amor. El siguiente es un análisis detallado del código:

importar tortuga como tu: importa el módulo tortuga y lo alias como tu.
tu.setup(1.0, 1.0): establece el tamaño de la mesa de trabajo en 1,0 veces el tamaño de la pantalla.
tu.screensize(1.0, 1.0): establece el tamaño de la pantalla en 1,0 veces el tamaño de la pantalla.
tu.bgcolor('black'): establece el color de fondo del lienzo en negro.
t = tu.Pen(): Crea un objeto pincel.
t.ht(): Esconde el pincel.
colors = ['pink', 'hotpink', 'deeppink', 'lightpink']: define la lista de colores de los corazones.
class Star():: define una clase llamada Star para dibujar corazones.
def init (self, r):: El método de inicialización de la clase, r es el radio del corazón.
self.r = r: asigna el valor del radio entrante a la propiedad de radio self.r del objeto.
self.x = 0: Establecer la abscisa del corazón.
self.y = 120: Establecer la ordenada del corazón.
self.color = ra.choice(colors): selecciona aleatoriamente un color para asignarlo al atributo de color del corazón.
self.outline = 2: establece el tamaño del contorno del corazón.
def draw(self):: define un método para dibujar un corazón.
t.pensize(self.outline): Ajusta el tamaño del pincel al tamaño del contorno del corazón.
t.penup(): Levanta el cepillo.
t.color(self.color): Establece el color del pincel al color del corazón.
t.goto(self.x, self.y): Mueva el pincel a la posición inicial del corazón.
t.pendown(): Deja el pincel.
t.setheading(120): establece la dirección del pincel en 120 grados.
t.circle(self.r, 195): Dibuja un arco con radio self.r.
t.fd(self.r * 2.4): Avanzar la distancia de self.r * 2.4.
t.lt(90): Gire a la izquierda 90 grados.
t.fd(self.r * 2.4): Avanzar la distancia de self.r * 2.4.
t.circle(self.r, 195): Dibuja un arco con radio self.r.
def change(self):: Define el método para cambiar el tamaño del corazón.
if self.r <= 100:: Si el radio del corazón es menor o igual a 100.
self.r += 1: Suma 1 al radio del corazón.
si no:: Si el radio del corazón es mayor a 100.
self.r = 1: establece el radio del corazón en 1.
self.x = 0: establece la abscisa del corazón en 0.
self.y = 120: Establece la ordenada del corazón en 120.
self.c = ra.choice(colores): selecciona aleatoriamente un color para asignarlo al atributo de color del corazón.

Cuando se ejecuta este código, primero se importa el módulo de tortuga y se le asigna un alias a tu. Luego establezca el tamaño de la mesa de trabajo y la pantalla llamando a las funciones tu.setup() y tu.screensize(). A continuación, cree un objeto de pincel y oculte el bolígrafo llamando a t = tu.Pen(). Luego se define una lista de colores que contiene cuatro valores de color, que se utiliza para seleccionar aleatoriamente el color del corazón.

A continuación, se define una clase denominada Estrella para dibujar corazones. El método de inicialización de clase __init__ acepta un parámetro r, que representa el radio del corazón. En el método de inicialización, asigne el valor del radio entrante al atributo de radio self.r del objeto y configure las coordenadas iniciales, el color y el tamaño del marco del corazón. La clase también define un método llamado dibujar para dibujar corazones. En este método, el tamaño y el color del pincel se establecen de acuerdo con las propiedades del objeto y a través de una serie de funciones t.goto(), t.setheading(), t.circle() y t.fd() , un Radio, color de corazones.

A continuación, se crea una lista de estrellas vacía Estrellas en el programa principal. A través de un ciclo for, realice un ciclo 200 veces, cada vez cree un objeto de corazón y agréguelo a la lista de estrellas. Luego ingrese un bucle infinito y comience a dibujar efectos de animación.

Al comienzo del bucle, la animación se apaga llamando a tu.tracer(0) para que el proceso de dibujo se pueda mostrar en tiempo real. Luego llame a la función t.clear() para borrar el lienzo y prepararse para volver a dibujar. A continuación, dibuje cada corazón recorriendo los objetos de corazón en la lista de estrellas y llamando al método de dibujo del objeto por turno.

El resultado de este código es recorrer cíclicamente el dibujo de corazones de diferentes colores y tamaños sobre un lienzo con fondo negro. Durante el ciclo, el tamaño del corazón aumentará gradualmente y el color cambiará aleatoriamente.

fin

¡Les deseo a todos un feliz Tanabata!

Pitón amor onda de luz

Directorio de artículos