Hola a todos, el editor está aquí para responder las siguientes preguntas. Python usa la biblioteca de tortugas para dibujar formas de árboles y Python Turtle dibuja árboles simples. ¡Ahora echemos un vistazo!
Autor |
Editor de 1_bit | Producido por Wang Xiaoman
| Blog de CSDN
comenzar
Usé Turtle para dibujar un árbol y miré el código en Internet. Básicamente, el método principal es usar la recursividad; en segundo lugar, el grosor del lápiz se cambia pasando parámetros de forma recursiva para cambiar el segmento de línea durante el dibujo y el tamaño del tronco. del árbol Al atravesar hasta el último nodo, cambie el color y el grosor del bolígrafo y dibuje los pétalos u hojas verdes en la parte superior del árbol.
Esta publicación de blog es una modificación del código en Internet. Básicamente, es simple de escribir y usa recursividad. También la tomé y la usé para resumir los puntos de prueba secundarios de Python y las preguntas frecuentes de Python . Por cierto, originalmente quería dibujar el entorno, pero tengo que ir a trabajar mañana y tengo otras cosas que hacer hoy, así que tengo que dejarlo y escribir otro caso para arreglar el entorno cuando tenga tiempo; el siguiente es el resultado después de ejecutar el código final (el código no está optimizado y la eficiencia puede no ser muy buena):
Se siente un poco fresco, jajaja, el color se combina deliberadamente, ¡floral!
Bien, ahora veamos cómo escribirlo. El código final está en la parte inferior y lo anterior es una explicación paso a paso de algunos de los problemas encontrados.
Primero, utilizamos la forma más sencilla de dibujar el tronco del árbol, el código es el siguiente:
from turtle import *
left(80)
fd(100)
right(30)
fd(30)
right(30)
fd(40)
input()
El resultado es el siguiente:
El código anterior primero usa t.left(80) para mover la tortuga a una posición casi perpendicular a la línea horizontal, luego usa t.fd(100) para dibujar un segmento de línea de 100 unidades en la dirección del cabezal de corte, y luego usa t.right(30) para dibujar un segmento de línea de 100 unidades en la dirección del cabezal de corte. Gire a la derecha 30 grados y luego dibuje un segmento de línea de 30 unidades hacia adelante con t.fd(30); en este momento, hay un nodo entre los segmentos de línea. Este nodo se genera girando el ángulo recto para simular el tronco del árbol, finalmente t.right(30) gira 30 grados a la derecha y t.fd(40) dibuja 40 unidades. longitud de los segmentos de línea hacia adelante para extender el torso final.
Sin embargo, los segmentos de línea anteriores no son adecuados para describir el árbol como una planta, pero no se preocupe, primero cambiemos el grosor y el color de los segmentos de línea dibujados para que la imagen dibujada se parezca más a un árbol.
color|tamaño de pluma()
Cambie el grosor y el color del lápiz mediante t.pensize() y t.color(), el código es el siguiente:
from turtle import *
color('#5E5E5E')
pensize(10)
left(80)
fd(100)
right(30)
fd(30)
right(30)
fd(40)
input()
Después de cambiar el grosor del bolígrafo, el resultado del dibujo es el siguiente:
Quizás el resultado se parezca más a una brizna de hierba, pero no importa, poco a poco vamos cambiando el código, ahora alargamos las ramas del árbol y reducimos el grosor del bolígrafo:
from turtle import *
color('#5E5E5E')
pensize(6)
left(80)
fd(150)
right(30)
fd(50)
right(30)
fd(60)
input()
El resultado es el siguiente:
Se ve mucho mejor. Toda la parte del tronco se puede dividir en el tronco principal y las ramas dispersas. Podemos dividirlo en varias partes para escribir; primero dibuje el tronco del árbol y luego use la función para dibujar las ramas del árbol:
from turtle import *
def drawTree(length):
right(20)
fd(length)
color('#5E5E5E')
pensize(5)
up()
goto(0,-300)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(60)
input()
Los resultados de ejecución son los siguientes:
En este momento, el código comienza desde la parte inferior del área de dibujo y dibuja hacia arriba. Utilice color('#5E5E5E') para establecer el color del dibujo; pensize(5) establece el grosor del segmento de línea dibujado; goto(0,- 300) salta al área de dibujo. La parte inferior se usa como punto de partida; luego gira 80 grados hacia la izquierda y dibuja un segmento de línea como el tronco del árbol; luego llama a la función drawTree(120) y pasa la longitud para dibujar las ramas En la función drawTree, right(20) El lado derecho se gira 20 grados y fd(length) dibuja un segmento de línea como una rama.
Ahora que hemos escrito la función, podemos usar la recursividad para comenzar a dibujar ramas:
from turtle import *
def drawTree(length):
if length>1:
right(20)
fd(length)
drawTree(length - 10)
color('#5E5E5E')
pensize(5)
up()
goto(0,-300)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(60)
input()
运行结果如下：
Desde el punto de vista del código, solo se ha modificado el contenido del código de la parte de la función drawTree; la recursividad se usa en la función y el valor pasado después de la recursividad es la longitud actual menos 10 longitudes, y se juzga en la función que solo se ejecutará cuando la longitud sea mayor que 1, por lo que esto evita bucles infinitos causados por condiciones sin escape en recursividad.
Las longitudes actuales tienen diferencias fijas. Se utilizan números aleatorios para hacer que las longitudes de las ramas dibujadas sean aleatorias, lo que se acerca más a las ramas reales (aquí solo se publica la parte modificada del código):
def drawTree(length):
if length>1:
right(20)
fd(length)
randlen=random.random()
drawTree(length - 10*randlen)
resultado de la operación:
El código utiliza números aleatorios, resta el valor aleatorio de la diferencia fija de 10 y participa en la operación de resta después de obtener el valor.
Entonces aquí, el ángulo de rotación también es fijo, aleatoricemos el ángulo de rotación:
def drawTree(length):
if length>1:
randangle=random.random()
randlen=random.random()
right(20*randangle)
fd(length)
drawTree(length - 10*randlen)
resultado de la operación:
comenzar oficialmente
Nuestras ramas ahora tienen una sola dirección, que es hacia la derecha. Ahora agregamos ramas orientadas hacia la izquierda para dibujar:
from turtle import *
import random
def drawTree(length):
if length>1:
randangle=random.random()
randlen=random.random()
right(20*randangle)
fd(length)
drawTree(length - 10*randlen)
left(40 * randangle)
fd(length)
color('#5E5E5E')
pensize(5)
up()
goto(0,-300)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(60)
input()
Sin embargo ocurrió un error:
¿Por qué está pasando esto?
Eso es porque necesitamos saltar a la posición de dibujo anterior, solo use la función hacia atrás. Cambie la función drawTree de la siguiente manera:
def drawTree(length):
if length>1:
randangle=random.random()
randlen=random.random()
right(20*randangle)
fd(length)
up()
backward(length)
down()
left(40 * randangle)
fd(length)
drawTree(length - 10*randlen)
El resultado es el siguiente:
De hecho, este efecto sigue siendo bueno, pero no es lo que queremos. Este efecto puede ser bueno para pintar pasto cola de perro, cambie el código:
from turtle import *
import random
def drawTree(length):
if length>1:
#随机角度与长度
randangle=random.random()
randlen=random.random()
#每次使用函数先绘制线段，再调整角度，这里是向右的角度转动
fd(length)
right(20*randangle)
drawTree(length - 10*randlen)
#这里是向左的角度转动
left(40 * randangle)
drawTree(length - 10*randlen)
#为什么需要再向右转20度？那是因为我一共向左转了40度，使用backward后退，必须是相同的角度，不然退回去角度就不同了位置就不会对
right(20 * randangle)
up()
backward(length)
down()
tracer(False)
color('#5E5E5E')
pensize(5)
up()
goto(0,-300)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(60)
input()
El resultado es el siguiente:
La explicación del código está en los comentarios. Es una recursión simple. Sin embargo, dado que la longitud pasada no es larga, no hay muchos segmentos de línea dibujados en las ramas, lo que hará que todo el árbol no crezca lo suficientemente exuberante. Modifiquemos El valor de longitud pasado es 120, y el resultado del dibujo es el siguiente. Tenga en cuenta que dado que el dibujo lleva demasiado tiempo, puede usar directamente el trazador (Falso) para mostrar directamente el efecto. No es necesario dibujar y renderizar una vez (esto depende de sus parámetros, simplemente cámbielo a False); aquí Para cambiar el sistema de coordenadas, personalícelo a un sistema de coordenadas más grande que el actual. De lo contrario, la visualización de la pantalla no estará completa. Simplemente use el código setworldcoordinates(-1000, -750,1000,750). El código general es el siguiente:
from turtle import *
import random
def drawTree(length):
if length>1:
#随机角度与长度
randangle=random.random()
randlen=random.random()
#每次使用函数先绘制线段，再调整角度，这里是向右的角度转动
fd(length)
right(20*randangle)
drawTree(length - 10*randlen)
#这里是向左的角度转动
left(40 * randangle)
drawTree(length - 10*randlen)
#为什么需要再向右转20度？那是因为我一共向左转了40度，使用backward后退，必须是相同的角度，不然退回去角度就不同了位置就不会对
right(20 * randangle)
up()
backward(length)
down()
setworldcoordinates(-1000,-750,1000,750)
tracer(False)
color('#5E5E5E')
pensize(5)
up()
goto(0,-300)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(120)
input()
El resultado es el siguiente:
Sin embargo, dado que no existe un límite de longitud mínima para las esquinas de números aleatorios y la longitud de las ramas, puede multiplicar un número adecuado en momentos aleatorios y ajustar la posición inicial hacia abajo. El código es el siguiente:
randangle=2*random.random()
randlen=2*random.random()
.
.
.
.
.
.
goto(0,-700)
El resultado es el siguiente:
casi termino
Se ha dibujado la forma general de un árbol. Ahora comience a rellenar las flores verdes y rojas en las ramas del árbol. En términos generales, cuanto más alta sea la parte superior de las ramas del árbol, más pequeñas serán. Juzgando el valor de la De longitud, será verde dentro de un cierto rango. , es rojo dentro de un cierto rango, luego puede simular el efecto de las flores de los árboles y las hojas verdes. El código es el siguiente y usted mismo puede ajustar el código de color:
from turtle import *
import random
def drawTree(length):
if length>1:
if length<30 and length>14:#缩小一下树干
pensize(4)
elif length<15 and length>5:#长度这个范围内那么就是绿叶
color('#04B486')#
pensize(3)
elif length<5 and length>1:#红花
color('#FE2E9A')
pensize(2)
else:
color('#5E5E5E')#其他范围就是正常的树干
pensize(5)
#随机角度与长度
randangle=2*random.random()
randlen=2*random.random()
#每次使用函数先绘制线段，再调整角度，这里是向右的角度转动
fd(length)
right(20*randangle)
drawTree(length - 10*randlen)
#这里是向左的角度转动
left(40 * randangle)
drawTree(length - 10*randlen)
#为什么需要再向右转20度？那是因为我一共向左转了40度，使用backward后退，必须是相同的角度，不然退回去角度就不同了位置就不会对
right(20 * randangle)
up()
backward(length)
down()
setworldcoordinates(-1000,-750,1000,750)
tracer(False)
color('#5E5E5E')
pensize(5)
up()
goto(0,-700)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(120)
input()
Los resultados de ejecución son los siguientes:
Dibujar flores cayendo
El árbol es un poco largo y frondoso, jajaja; la forma del árbol es aleatoriamente diferente cada vez, así que no entiendo que no quepa en una pantalla, pero no importa mucho. Ahora comenzamos a dibujar. el efecto de la caída de hojas y flores.
La función del efecto de flor que cae es la siguiente:
def fallingFlowers(m):
x,y=-1000,-750
yval=50
for i in range(m):
a = 100*random.random()
b = 2*random.random()
print(a)
if a>59:
color('#FE2E9A')
else:
color('#04B486')
circle(5)
up()
goto(x,y+(yval*b))
fd(a)
yval+=50
down()
Ejecute de la siguiente manera:
Debido a que el sistema de coordenadas que definimos es [-1000, -750] a [1000,750], comenzamos a dibujar las flores que caen desde la esquina inferior izquierda. Los valores de las coordenadas xey definidas en el código son x, y = -1000, -750, y luego use un valor y en el ciclo para aumentar cada vez. La posición del dibujo sube desde la esquina inferior izquierda cada vez, por lo que la coordenada y aumenta cada vez en el ciclo y se le da una multiplicación aleatoria. , para que Para una mejor aleatorización, use goto(x,y+yval) cada vez para saltar a la posición de coordenadas x,y especificada, pero tenga en cuenta aquí que el valor de x permanece sin cambios; y en el bucle configuro A La variable a se utiliza principalmente para que fd(a) realice la aleatorización en el eje x. El mismo valor conducirá a la misma disposición, lo cual no es muy hermoso. Esta es también la razón por la cual el valor aleatorio b se multiplica por yval.
Luego modifique el código y establezca un bucle en la capa exterior para agregar los valores de la coordenada x y llenar el área de dibujo horizontalmente:
from turtle import *
import random
def drawTree(length):
if length>1:
if length<30 and length>14:#缩小一下树干
pensize(4)
elif length<15 and length>5:#长度这个范围内那么就是绿叶
color('#04B486')#
pensize(3)
elif length<5 and length>1:#红花
color('#FE2E9A')
pensize(2)
else:
color('#5E5E5E')#其他范围就是正常的树干
pensize(5)
#随机角度与长度
randangle=2*random.random()
randlen=2*random.random()
#每次使用函数先绘制线段，再调整角度，这里是向右的角度转动
fd(length)
right(20*randangle)
drawTree(length - 10*randlen)
#这里是向左的角度转动
left(40 * randangle)
drawTree(length - 10*randlen)
#为什么需要再向右转20度？那是因为我一共向左转了40度，使用backward后退，必须是相同的角度，不然退回去角度就不同了位置就不会对
right(20 * randangle)
up()
backward(length)
down()
def fallingFlowers(m):
x,y=-1000,-750
for i in range(30):
up()
goto(x,y)
x+=100
down()
yval=50
for i in range(m):
a = 100*random.random()
b = 2*random.random()
print(a)
if a>59:
color('#FE2E9A')
else:
color('#04B486')
circle(5)
up()
goto(x,y+(yval*b))
fd(a)
yval+=50
down()
setworldcoordinates(-1000,-750,1000,750)
tracer(False)
color('#5E5E5E')
pensize(5)
# up()
# goto(0,-700)#跳到绘制起始点
# down()
# left(80)
# fd(140)
# drawTree(120)
fallingFlowers(10)
input()
resultado de la operación:
El nuevo bucle exterior incrementa el valor de x y finalmente coloca en mosaico la mitad inferior del área de dibujo.
Resultados finales
Finalmente, combinado con el código de dibujo del árbol, abra los comentarios y establezca el color de fondo bgcolor("#F5F6CE"):
from turtle import *
import random
def drawTree(length):
if length>1:
if length<30 and length>14:#缩小一下树干
pensize(4)
elif length<15 and length>5:#长度这个范围内那么就是绿叶
color('#04B486')#
pensize(3)
elif length<5 and length>1:#红花
color('#FE2E9A')
pensize(2)
else:
color('#5E5E5E')#其他范围就是正常的树干
pensize(5)
#随机角度与长度
randangle=2*random.random()
randlen=2*random.random()
#每次使用函数先绘制线段，再调整角度，这里是向右的角度转动
fd(length)
right(20*randangle)
drawTree(length - 10*randlen)
#这里是向左的角度转动
left(40 * randangle)
drawTree(length - 10*randlen)
#为什么需要再向右转20度？那是因为我一共向左转了40度，使用backward后退，必须是相同的角度，不然退回去角度就不同了位置就不会对
right(20 * randangle)
up()
backward(length)
down()
def fallingFlowers(m):
x,y=-1000,-750
for i in range(30):
up()
goto(x,y)
x+=100
down()
yval=50
for i in range(m):
a = 100*random.random()
b = 2*random.random()
print(a)
if a>59:
color('#FE2E9A')
else:
color('#04B486')
circle(5)
up()
goto(x,y+(yval*b))
fd(a)
yval+=50
down()
setworldcoordinates(-1000,-750,1000,750)
tracer(False)
fallingFlowers(10)#绘制落叶
bgcolor("#F5F6CE")
color('#5E5E5E')
pensize(5)
up()
goto(0,-700)#跳到绘制起始点
down()
left(80)
fd(140)
drawTree(120)
input()
El resultado es el siguiente:
Si cree que no hay suficientes hojas y flores caídas, puede cambiar los parámetros. Debido a que el código no está optimizado, el efecto de ejecución es demasiado lento, lo publicaré después de la optimización.
Declaración de derechos de autor: este artículo es un artículo original del blogger de CSDN "1_bit" y sigue el acuerdo de derechos de autor CC 4.0 BY-SA. Adjunte el enlace de la fuente original y esta declaración al reimprimir.
Enlace original: https://blog.csdn.net/a757291228/article/details/106029202
【FIN】
更多精彩推荐
☞Flash 已死，Deno 当立？
☞OceanBase 十年：一群追梦人的成长史
☞2 年 6 个月 11 天，外包到阿里的修仙之路！| 原力计划
☞服务器软件大扫盲！
☞绝悟之后再超神，腾讯30篇论文入选AI顶会ACL
☞中本聪并没有出现，那真相是？
你点的每个“在看”，我都认真当成了喜欢