https://jorgechac.blogspot.com: febrero 2023

viernes, 17 de febrero de 2023

Dibujando en Python utilizando la libreria Matplotlib y Numpy

Bienvenido a mi blog, hoy hablaremos un poco de el conjunto de Mandelbrot, que es el más estudiado de los fractales. Se conoce así en honor al matemático Benoît Mandelbrot (1924-2010), que investigó sobre él en los años setenta. Este conjunto se define en el plano complejo fijando un número complejo C cualquiera, a partir de C, se construye una sucesión por recursión. Fractal (del latín fractus, "irregular", "fragmentado") es una palabra que acuñó el propio Mandelbrot para describir la repetición "infinita" de patrones geométricos a diferentes escalas, que muestran versiones cada vez más pequeñas de sí mismos. Las partes pequeñas de un fractal, explicaba Mandelbrot, son semejantes al todo, al conjunto completo. Lo más interesante es que el matemático demostró que la mayoría de las formas de la naturaleza son fractales. Los fractales se han utilizado para explicar fenómenos atmosféricos, para analizar las redes vasculares y las redes neuronales del cuerpo humano, para calcular la longitud de las costas, para explicar el crecimiento de los cerebros de los mamíferos, para estudiar los seísmos... Incluso en telecomunicaciones se han diseñado antenas fractales como las que utilizan los teléfonos celulares actuales.

Para ello haremos uso de Matplotlib, la cuál es una librería completa para crear visualizaciones estáticas, animadas e interactivas en Python, de igual forma también usaremos la librería NumPy, que nos trae el poder computacional de lenguajes como C y Fortran a Python, un lenguaje mucho más fácil de aprender y usar.

Este será un post corto, vamos primero a tratar de explicar el script linea por linea, después veremos el código final limpio y acabaremos generando la grafica respectiva.

import numpy # importamos la librería NumPy

# NumPy es una biblioteca en Python que proporciona un objeto de matriz N-dimensional

# y funciones matemáticas de alto rendimiento para operar en esas matrices.

import matplotlib.pyplot # importamos la librería Matplotlib que se utiliza para la creación de gráficos y visualizaciones

# comenzamos la definición de una función que calcula el Conjunto de Mandelbrot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):

X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje x. La función linspace de NumPy genera un número especificado de puntos equidistantes entre dos valores dados

Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje y

C = X + Y[:, None]*1j # generamos una matriz de números complejos que representan todos los puntos en el plano complejo. La notación 1j es una forma de representar la unidad imaginaria en Python

N = numpy.zeros_like(C, dtype=int) # Se crea un array N con la misma forma que C y se inicializa en cero

Z = numpy.zeros_like(C) # Se crea un array Z con la misma forma que C e inicializa en cero

for n in range(maxiter): # se itera sobre un rango de maxiter elementos

I = numpy.less(abs(Z), horizon) # se crea una matriz booleana I que es verdadera en las posiciones donde la magnitud de Z es menor que horizon

N[I] = n # asignamos el valor actual de la variable "n" a las posiciones en el array "N" donde la condición "I" es verdadera

Z[I] = Z[I]**2 + C[I] # es la fórmula iterativa para calcular el conjunto de Mandelbrot. Esta línea está asignando el resultado de esta fórmula a aquellos elementos en el array "Z" donde la condición "I" es verdadera

N[N == maxiter-1] = 0 # asignamos el valor 0 a aquellos elementos en el array "N" que tienen un valor igual a "maxiter-1"

return Z, N # la función "mandelbrot_set" devuelve los arrays "Z" y "N" como resultados

# Si se está ejecutando este archivo, define los parámetros y ejecuta la función mandelbrot_set

if __name__ == '__main__':

# Se definen los límites para que el gráfico incluya la región rectangular con esquinas opuestas (-2, -1.5) y (1, 1.5)

xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

# Se definen las dimensiones de la matriz que se va a utilizar para almacenar los valores de iteración para cada punto del conjunto de Mandelbrot

# Se usarán matrices de 3000x2500 para almacenar los valores de iteración

xn, yn = numpy.array([3000, 2500], dtype=int)

# La variable "maxiter" define el número máximo de iteraciones que se realizarán en el cálculo del conjunto de Mandelbrot.

# En este caso, se han establecido en 200

maxiter = 200

# La variable "horizon" se usa para definir el umbral que determina si un punto está dentro del conjunto de Mandelbrot. En este caso, se ha definido

# como 2 elevado a la 40, lo que significa que se realizarán un máximo de 2 elevado a la 40 iteraciones para determinar si un punto está dentro del conjunto

horizon = 2.0 ** 40

log_horizon = numpy.log2(numpy.log(horizon))/2

# Llamamos a la función "mandelbrot_set" definida previamente para calcular los valores de iteración y la matriz compleja para el conjunto de Mandelbrot

Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

# Se ignora la advertencia de que algunos valores resultantes de las operaciones sean inválidos

with numpy.errstate(invalid='ignore'):

# Calculamos los valores de M utilizando los valores de N y Z

M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

# Graficamos los valores de M con los parámetros especificados

matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal') # se muestra el conjunto de Mandelbrot como una imagen en una ventana emergente

matplotlib.pyplot.xlabel("Re(c)") # Se agrega un label o etiqueta para las coordenadas x e y y se establece un título

matplotlib.pyplot.ylabel("Im(c)")

matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")

matplotlib.pyplot.show() # Abrimos una ventana de visualización y mostramos el gráfico generado por el código.

Acá tenemos el código final limpio en Python:

# -----------------------------------------------------------------------
# (| " mandelbrot.py                                                  "|)
# (| "                                                                "|)
# (| " Script que genera el conjunto de Mandelbrot y lo visualiza     "|)
# (| " como una imagen utilizando las librerías NumPy y Matplotlib    "|)
# (| " de Python.                                                     "|)
# (| "                                                                "|)
# (| " El conjunto de Mandelbrot es un conjunto de puntos en el plano "|)
# (| " complejo que se define mediante una regla matemática iterativa."|)
# (| " El programa calcula los valores de los puntos en una cuadrícula"|)
# (| " de coordenadas en el plano complejo utilizando la función      "|)
# (| " mandelbrot_set() que implementa la regla iterativa. Luego, el  "|)
# (| " programa utiliza la librería Matplotlib para representar los   "|)
# (| " resultados como una imagen en una ventana de visualización.    "|)
# (| "                                                                "|)
# (| " Este código de ejemplo es de dominio público.                  "|)
# (| "                                                                "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB   "|)
# (| " Visita  https://jorgechac.blogspot.com                         "|)
# (| "                                                                "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	      "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                          "|)
# (| " Bucaramanga - Colombia                                         "|)
# -----------------------------------------------------------------------
import numpy
import matplotlib.pyplot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):
    
    X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32)
    Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32)

    C = X + Y[:, None]*1j

    N = numpy.zeros_like(C, dtype=int)
    Z = numpy.zeros_like(C)

    for n in range(maxiter):

        I = numpy.less(abs(Z), horizon)
        N[I] = n

        Z[I] = Z[I]**2 + C[I]

    N[N == maxiter-1] = 0
    return Z, N

if __name__ == '__main__':

    xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

    xn, yn = numpy.array([3000, 2500], dtype=int)

    maxiter = 200

    horizon = 2.0 ** 40

    log_horizon = numpy.log2(numpy.log(horizon))/2

    Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

    with numpy.errstate(invalid='ignore'):
        
        M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

    matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal')
    matplotlib.pyplot.xlabel("Re(c)")
    matplotlib.pyplot.ylabel("Im(c)")
    matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")
    matplotlib.pyplot.show()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python con matplotlib, así:

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Dibujando en Python utilizando el módulo Python Turtle

Dibujo del logotipo de Python utilizando el módulo Python Turtle

Simulador Wokwi - Generalidades

UEFI y BIOS - Generalidades

DISCOS SSD - GENERALIDADES

Creación de Particiones desde símbolo del sistema

Nuevos Microcontroladores Raspberry Pi Pico W, H y WH

Cómo Detectar un Arduino Falsificado

HDD Low Level Format Tool v4.40

Activa tu Windows 10/11 fácil

martes, 7 de febrero de 2023

Dibujando en Python utilizando el módulo Python Turtle

Bienvenido a mi blog, hoy continuaremos practicando el uso del módulo python turtle que vimos en el post pasado "Dibujo del logotipo de Python utilizando el módulo Python Turtle" en el cual esbozamos los principios de dicho módulo y los aplicamos para dibujar el logotipo de Python.

Este será un post corto, ya que iremos directamente a programar en Python 3 un dibujo en constante cambio de colores que se mueva hacia adelante y hacia arriba en una espiral, con una curva suave. Vamos a escribir el script completo colocando los respectivos comentarios para poder entenderlo y finalmente visualizaremos el resultado:

# -----------------------------------------------------------------------
# (| " Graphics_turtle.py                                             "|)
# (| "                                                                "|)
# (| " El resultado final es un dibujo en constante cambio de colores "|)
# (| " que se mueve hacia adelante y hacia arriba en una espiral, con "|)
# (| " una curva suave.                                               "|)
# (| "                                                                "|)
# (| " Python turtle es un módulo de Python que permite crear gráficos"|)
# (| " vectoriales mediante el uso de comandos simples. Estos comandos"|)
# (| " controlan un cursor, conocido como tortuga (turtle), que se    "|)
# (| " mueve por la pantalla y dibuja líneas y figuras geométricas y  "|)
# (| " nos permite crear diseños personalizados.                      "|)
# (| "                                                                "|)
# (| " Este código de ejemplo es de dominio público.                  "|)
# (| "                                                                "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB   "|)
# (| " Visita  https://jorgechac.blogspot.com                         "|)
# (| "                                                                "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	      "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                          "|)
# (| " Bucaramanga - Colombia                                         "|)
# -----------------------------------------------------------------------

# Importa todas las funciones y métodos del módulo "turtle"
from turtle import *

# Importa el módulo "colorsys"
import colorsys

# Establece el color de fondo de la ventana de gráficos en negro
bgcolor('black')

# Establece la velocidad máxima de animación
speed(0)

# Establece el grosor de la pluma en 3
pensize(3)

# Establece un valor inicial para la variable "hue" en 0.0 la variable
# "hue" se utiliza para determinar el color de la pluma en cada iteración
# del bucle
hue = 0.0

# Repite las siguientes acciones 300 veces
for i in range(300):

    # Convierte el valor de hue a un color RGB y lo establece como el
    # color de la pluma
    color = colorsys.hsv_to_rgb(hue, 1, 1)
    pencolor(color)
    # Aumenta el valor de hue en 0.005
    hue += 0.005
    # Gira el lápiz hacia la derecha en la cantidad de "i"
    right(i)
    # Dibuja un círculo con un radio de 50 y un ángulo de "i"
    circle(50, i)
    # Avanza hacia adelante la cantidad de "i"
    forward(i)
    # Gira el lápiz hacia la izquierda en 91° grados
    left(91)

# Finaliza la gráfica y mantiene la ventana abierta hasta que el usuario
# la cierre manualmente
done()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python, así:

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

jueves, 2 de febrero de 2023

Dibujo del logotipo de Python utilizando el módulo Python Turtle

Bienvenido a mi blog, hoy hablaremos un poco de Python turtle, el cual es un módulo de Python que permite crear gráficos vectoriales mediante el uso de comandos simples. Estos comandos controlan un cursor, conocido como tortuga (turtle), que se mueve por la pantalla y dibuja líneas y figuras geométricas y nos permite crear diseños personalizados. Es comúnmente utilizado en la enseñanza de la programación, ya que es fácil de entender y usar. Con Python turtle, los estudiantes pueden aprender conceptos básicos de programación como bucles, condicionales y funciones mientras crean sus propios gráficos. Algunos ejemplos de cómo utilizar la función turtle incluyen:

Mover el cursor hacia adelante utilizando el comando "forward()"
Girar el cursor utilizando el comando "left()" o "right()"
Cambiar el color de la línea utilizando el comando "pencolor()"
Escribir texto en la pantalla utilizando el comando "write()"
Mostrar o ocultar el cursor utilizando el comando "showturtle()" o "hideturtle()"

Para utilizar la función turtle, primero debemos importar el módulo en nuestro script. Luego, podemos crear una instancia de turtle y utilizar los comandos mencionados anteriormente para dibujar en la pantalla. Hoy aprenderemos a dibujar el logotipo de Python con el modulo Python Turtle.

Paso 1: Importación de bibliotecas

# Importación de la biblioteca turtle para dibujar el logotipo de Python

import turtle

Paso 2: crear un cursor y un lienzo separado para dibujar el logotipo de Python

# Creando nuestro cursor tortuga para dibujar

my_turtle_cursor = turtle.Turtle()

# Creación de un lienzo separado para dibujar el logotipo de Python

my_turtle_screen = turtle.Screen()

Paso 3: Creación de una función para pausar el cursor al final

# Creación de una función de pausa, para pausar el cursor

def pause():

my_turtle_cursor.speed(2)

for i in range(100):

my_turtle_cursor.left(90)

Paso 4A: crear una función para dibujar el punto superior del logotipo de Python

# Función para dibujar el punto superior del logotipo de Python

def draw_upper_dot_of_python_logo():

my_turtle_cursor.penup()

my_turtle_cursor.right(90)

my_turtle_cursor.forward(160)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(70)

my_turtle_cursor.pencolor("white")

my_turtle_cursor.dot(35)

Paso 4B: Creando una función para ir a la Segunda Posición en nuestro Lienzo

# Función para hacer la segunda posición

def goto_second_position():

my_turtle_cursor.penup()

my_turtle_cursor.forward(20)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(10)

my_turtle_cursor.right(90)

my_turtle_cursor.pendown()

Paso 5: Crear una función media

def half():

my_turtle_cursor.forward(50)

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(90)

draw_first_left_curve_of_python_logo()

my_turtle_cursor.forward(40)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(80)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(10)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(120) # on test

draw_second_left_curve_of_python_logo()

my_turtle_cursor.forward(30)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(50)

draw_right_curve_of_python_logo()

my_turtle_cursor.forward(40)

my_turtle_cursor.end_fill()

Paso 6: crear una función para dibujar el segundo punto del logotipo de Python

# Función para dibujar el segundo punto

def draw_lower_dot_of_python_logo():

my_turtle_cursor.left(90)

my_turtle_cursor.penup()

my_turtle_cursor.forward(310)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(120)

my_turtle_cursor.pendown()

my_turtle_cursor.dot(35)

Paso 7: Creación de una función para dibujar la primera curva izquierda del logotipo de Python

# Función para dibujar la primera curva izquierda

def draw_first_left_curve_of_python_logo():

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(80)

draw_side_curve_of_python_logo()

Paso 8: Creación de una función para dibujar la segunda curva izquierda del logotipo de Python

# Función para dibujar la segunda curva izquierda

def draw_second_left_curve_of_python_logo():

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(90)

draw_side_curve_of_python_logo()

Paso 9: Crear una función para dibujar una curva lateral

# Función para Dibujar Curva Lateral

def draw_side_curve_of_python_logo():

for i in range(90):

my_turtle_cursor.left(1)

my_turtle_cursor.forward(1)

Paso 10: Creación de una función para dibujar la curva derecha

# Función para dibujar la curva derecha

def draw_right_curve_of_python_logo():

for i in range(90):

my_turtle_cursor.right(1)

my_turtle_cursor.forward(1)

Paso 11: Configuración del tamaño del lápiz y la velocidad de nuestro cursor

# Configuración del cursor según nuestras necesidades

my_turtle_cursor.pensize(2)

my_turtle_cursor.speed(10)

my_turtle_cursor.pensize(2)

my_turtle_cursor.pencolor("black")

Paso 12: Establecer los colores de relleno para diferentes partes y llamar a todas las funciones

# cambiamos el color de fondo del lienzo

my_turtle_screen.bgcolor("white")

# Configuración del color de relleno de la parte superior del logotipo de python

my_turtle_cursor.fillcolor("#306998")

# Comenzando a llenar el color de la parte superior del logo de python

my_turtle_cursor.begin_fill()

half()

# Inclinando el cursor para llenar el color en la parte superior del logo de python

my_turtle_cursor.end_fill()

goto_second_position()

# Configuración del color de relleno de la parte inferior del logotipo de python

my_turtle_cursor.fillcolor("#FFD43B")

my_turtle_cursor.begin_fill()

half()

# Inclinando el cursor para llenar el color en la parte inferior del logotipo de python

my_turtle_cursor.end_fill()

# Dibujo de puntos (ojos) superior e inferior del logotipo de python

draw_upper_dot_of_python_logo()

draw_lower_dot_of_python_logo()

pause()

Para sintetizar acá tenemos el código completo para dibujar el logotipo de Python usando el modulo Phyton Turtle, nuestro código está completo y finalmente lo ejecutamos para ver el logotipo de Python.

# -------------------------------------------------------------------------
# (| " logo_python.py                                                   "|)
# (| "                                                                  "|)
# (| " Dibujo del logotipo de Python utilizando el módulo Python Turtle."|)
# (| "                                                                  "|)
# (| " Python turtle es un módulo de Python que permite crear gráficos  "|)
# (| " vectoriales mediante el uso de comandos simples. Estos comandos  "|)
# (| " controlan un cursor, conocido como tortuga (turtle), que se mueve"|)
# (| " por la pantalla y dibuja líneas y figuras geométricas y nos      "|)
# (| " permite crear diseños personalizados.                            "|)
# (| "                                                                  "|)
# (| " Este código de ejemplo es de dominio público.                    "|)
# (| "                                                                  "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB     "|)
# (| " Visita  https://jorgechac.blogspot.com                           "|)
# (| "                                                                  "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   		"|)
# (| " Whatsapp y Ventas NEQUI +573177295861                            "|)
# (| " Bucaramanga - Colombia                                           "|)
# -------------------------------------------------------------------------

# Importación de la biblioteca turtle para dibujar el logotipo de Python
import turtle

# Creando nuestro cursor tortuga para dibujar
my_turtle_cursor = turtle.Turtle()

# Creación de un lienzo separado para dibujar el logotipo de Python
my_turtle_screen = turtle.Screen()

# Creación de una función de pausa, para pausar el cursor
def pause():
    my_turtle_cursor.speed(2)
    for i in range(100):
        my_turtle_cursor.left(90)

# Función para dibujar el punto superior del logotipo de Python
def draw_upper_dot_of_python_logo():
    my_turtle_cursor.penup()
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(160)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(70)
    my_turtle_cursor.pencolor("white")
    my_turtle_cursor.dot(35)

# Función para hacer la segunda posición
def goto_second_position():
    my_turtle_cursor.penup()
    my_turtle_cursor.forward(20)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(10)
    my_turtle_cursor.right(90)
    my_turtle_cursor.pendown()

# Crear una función media
def half():
    my_turtle_cursor.forward(50)
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(90)
    draw_first_left_curve_of_python_logo()
    my_turtle_cursor.forward(40)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(80)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(10)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(120)  # on test
    draw_second_left_curve_of_python_logo()
    my_turtle_cursor.forward(30)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(50)
    draw_right_curve_of_python_logo()
    my_turtle_cursor.forward(40)
    my_turtle_cursor.end_fill()

# Función para dibujar el segundo punto
def draw_lower_dot_of_python_logo():
    my_turtle_cursor.left(90)
    my_turtle_cursor.penup()
    my_turtle_cursor.forward(310)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(120)
    my_turtle_cursor.pendown()
    my_turtle_cursor.dot(35)

# Función para dibujar la primera curva izquierda
def draw_first_left_curve_of_python_logo():
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(80)
    draw_side_curve_of_python_logo()

# Función para dibujar la segunda curva izquierda
def draw_second_left_curve_of_python_logo():
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(90)
    draw_side_curve_of_python_logo()

# Función para Dibujar Curva Lateral
def draw_side_curve_of_python_logo():
    for i in range(90):
        my_turtle_cursor.left(1)
        my_turtle_cursor.forward(1)

# Función para dibujar la curva derecha
def draw_right_curve_of_python_logo():
    for i in range(90):
        my_turtle_cursor.right(1)
        my_turtle_cursor.forward(1)

# Configuración del cursor según nuestras necesidades
my_turtle_cursor.pensize(2)
my_turtle_cursor.speed(10)
my_turtle_cursor.pensize(2)
my_turtle_cursor.pencolor("black")

# cambiamos el color de fondo del lienzo
my_turtle_screen.bgcolor("white")

# Configuración del color de relleno de la parte superior del logotipo
# de python
my_turtle_cursor.fillcolor("#306998")

# Comenzando a llenar el color de la parte superior del logo de python
my_turtle_cursor.begin_fill()
half()

# Inclinando el cursor para llenar el color en la parte superior del logo
# de python
my_turtle_cursor.end_fill()
goto_second_position()

# Configuración del color de relleno de la parte inferior del logotipo
# de python
my_turtle_cursor.fillcolor("#FFD43B")
my_turtle_cursor.begin_fill()
half()

# Inclinando el cursor para llenar el color en la parte inferior del
# logotipo de python
my_turtle_cursor.end_fill()

# Dibujo de puntos (ojos) superior e inferior del logotipo de python
draw_upper_dot_of_python_logo()
draw_lower_dot_of_python_logo()
pause()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar el logotipo de Python, así: