Programación Unidad 5 Hernán

Unidad 5

Mayo , 2025

Programa 1:

# Este programa crea una ventana gráfica usando la biblioteca Tkinter

# la función mainloop() mantiene la ventana abierta 

from tkinter import *

ventana.title("Bienvenidos")

ventana = Tk()

ventana.mainloop()

Programa 2:

#Este programa crea una ventana con un título y una etiqueta de texto usando Tkinter

#el título es "bienvenidos" y la etiqueta de texto es "hola, ¿cómo estas? "

#la etiqueta se muestra en la primera fila y columna de la ventana con grid().

from tkinter import *

ventana = Tk()

ventana.title("bienvenidos")

lbl = Label (ventana, text="hola, ¿cómo estas? ")

lbl.grid(column=0, row=0)

ventana.mainloop()

Programa 3:

#Este programa crea una ventana gráfica con Tkinter titulada "Programacion visual"

#se define un tamaño inicial para la ventana de 350x200 píxeles

#se agrega una etiqueta (Label) con el texto "Hola tu" en la primera fila y columna (0, 0)

#también se agrega un botón (Button) con el texto "Click Me" en la misma fila 

#pero en la segunda columna (1, 0)

#la función mainloop() mantiene la ventana activa

from tkinter import *

ventana= Tk()

ventana.title("Programacion visual")

ventana.geometry('350x200')

lbl = Label(ventana, text="Hola tu")

lbl.grid(column=0, row=0)

btn = Button(ventana, text="Click Me")

btn.grid(column=1, row=1)

ventana.mainloop()

Programa 4:

#Este programa crea una ventana con una etiqueta y un botón utilizando Tkinter

#la ventana se titula "Programacion visual" y tiene un tamaño de 350x200 píxeles.

#se muestra una etiqueta con el texto "Hola tu" en la posición (0, 0)

#se define una función llamada 'clicked' que cambia el texto de la etiqueta cuando se presiona el botón.

#el botón tiene asignado el comando 'clicked', y al hacer clic en él, se ejecuta esa función.

#el botón se coloca en la posición (1, 0) de la ventana

#finalmente, mainloop() mantiene la ventana abierta

from tkinter import *

ventana= Tk()

ventana.title("Programacion visual")

ventana.geometry('350x200')

lbl = Label(ventana, text="Hola tu")

lbl.grid(column=0, row=0)

def clicked():

lbl.configure(text="El boton fue clicked¡¡")

btn = Button(ventana, text="Click Me", command=clicked)

#con los argumentos() se activa el comando

btn.grid(column=1, row=1)

ventana.mainloop()

Programa 5

#Actividad

#Este programa de Python utiliza la biblioteca Tkinter

#consiste en una ventana principal que contiene tres elementos: una etiqueta,

#un campo de entrada de texto y un botón

#en este programa la etiqueta Label se inicializa con el texto "Hola"

#el campo de entrada de texto Entry permite al usuario escribir en el su nombre

#el botón (Button) tiene el texto "Click Me"

#En este programa cuando el usuario hace clic en el botón, 

#se activa una función llamada 'clicked' 

# esta función cambia el texto de la etiqueta a "El boton fue clicked¡¡".

from tkinter import *

ventana= Tk()

ventana.title("Programacion visual")

ventana.geometry('350x200')

nombre1=StringVar()

lbl = Label(ventana, textvariable=nombre1)

lbl.grid(column=0, row=0)

txt=Entry(ventana, width=10)

txt.grid(column=1, row=0)

def nombre():

nombre2= txt.get()

nombre1.set("Hola, " + nombre2)

def clicked():

lbl.configure(text="El boton fue clicked¡¡")

btn = Button(ventana, text="Click Me", command=nombre)

btn.grid(column=2, row=0)

ventana.mainloop()

Programa 6:

#Este programa utiliza la librería 'turtle' para dibujar dos cuadrados en la pantalla

#primero, dibuja un cuadrado en la parte superior izquierda de la pantalla

#luego, la tortuga regresa a su posición inicial (centro de la pantalla) y dibuja un segundo cuadrado

#la ventana de dibujo se configura con un tamaño 

#el programa espera un clic del usuario para cerrarse

from turtle import *# Importa todas las funciones y clases del módulo 'turtle'

#import turtle

t=Turtle()

screen=t.getscreen()

#Turtle.getscreen()

setup(640,480)#configura el tamaño de la ventana de dibujo a 640 píxeles de ancho por 480 píxeles de alto

# Primer cuadrado:

t.left(90)

t.forward(200)

t.left(-90)

t.fd(200)

t.left(-90)

t.forward(200)

t.left(-90)

t.forward(200)

t.home()# Mueve la tortuga a su posición inicial

# Segundo cuadrado (similar al primero pero la tortuga ya está orientada):

t.left(90)

t.forward(200)

t.left(90)

t.forward(200)

t.left(90)

t.forward(200)

t.left(90)

t.forward(200)

screen.exitonclick()

Programa 7:

#Este programa utiliza la librería 'turtle' para dibujar un círculo en el centro de la pantalla

#configura una tortuga, le da un radio al círculo y luego dibuja la forma

#la ventana de dibujo permanecerá abierta hasta que el usuario haga clic en ella.

import turtle

t=turtle.Turtle()

t.left(90)

r=50

t.circle(r)

screen=t.getscreen()

screen.exitonclick()

Programa 8:

#Este programa utiliza la librería 'turtle' para dibujar un círculo relleno 

#el círculo se dibuja con un radio definido y se rellena  

#la ventana de dibujo permanecerá abierta hasta que el usuario haga clic en ella

import turtle

t=turtle.Turtle()

t.left(90)

r=50

turtle.colormode(255)#Establece el modo de color

t.fillcolor('lightskyblue) 

t.begin_fill()

t.circle(r)

t.end_fill()

screen=t.getscreen()

screen.exitonclick()

Programa 9:

#Este programa utiliza la librería 'turtle' para dibujar una serie de círculos concéntricos

#cada círculo se dibuja con un radio creciente y todos están rellenos del mismo color

#la ventana de dibujo permanecerá abierta hasta que el usuario haga clic en ella.

import turtle

t=turtle.Turtle()

screen=t.getscreen()

#t.left(90)

r=10 #radio

n=10 #numero de circulos

turtle.colormode(255)

t.color(90,0,223)# Establece el color de la tortuga

screen=t.getscreen()

screen.exitonclick()

Programa 10: 

#Este programa utiliza la librería 'turtle' para dibujar una serie de círculos concéntricos

#cada círculo se dibuja con un radio creciente y todos están rellenos del mismo color

#la ventana de dibujo permanecerá abierta hasta que el usuario haga clic en ella.

import turtle

t=turtle.Turtle()

screen=t.getscreen()

t.left(90)

r=10 #radio

n=10 #numero de circulos

turtle.colormode(255)

t.color(90,0,223)# Establece el color de la tortuga

#bucle para dibujar círculos concéntricos:

#se itera 'n' veces (10 veces en este caso), una vez por cada círculo

for i in range(1,n+1):

t.begin_fill()

t.circle(r*i)

t.end_fill()

        t.left(75)

screen=t.getscreen()

screen.exitonclick()

Programa 11:

#Este programa es para controlar un pin GPIO

#en una Raspberry Pi para hacer parpadear un LED

#de forma intermitente

#Importa las librerías necesarias para la manipulación de GPIO y para controlar el tiempo

#define el modo de numeración de los pines

#configura el pin GPIO 18 como una salida

#parpadeo: utiliza un bucle para alternar el estado del pin entre ALTO (encendido) y BAJO (apagado)

#con una pausa de 1 segundo entre cada cambio, repitiendo este ciclo 5 veces

import Rpi.CPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setup(18,GPIO.OUT)

for i in range(0,5):

GPIO.output(18,GPIO.HIGH) #encendido

time.sleep(1)

GPIO.output(18,GPIO.LOW) #apagado

time.sleep(1)

GPIO.cleanup()

Programa 12:

#En este programa:

# La idea es que al presionar un botón  se active un LED y se dibuje una serie de círculos concéntricos.

# Luego, el LED se apaga y el dibujo se borra, todo de forma cíclica una vez.

# Importa las bibliotecas necesarias:

# tkinter para crear la interfaz gráfica.

# turtle para realizar los dibujos gráficos.

# RPi.GPIO para controlar los pines GPIO de una Raspberry Pi (¡requiere hardware específico!).

# time para introducir pausas en la ejecución.

from tkinter import *

import turtle

import RPi.GPIO as GPIO

import time

t = turtle.Turtle()

ventana = Tk()

ventana.title("Programacion visual")

ventana.geometry('350x200')

lbl = Label(ventana, text="Presiona para encender y dibujar")

lbl.grid(column=0, row=0)

#La funcion cambia el texto de la etiqueta para informar al usuario que el botón ha sido presionado

#inicializa los pines GPIO de la Raspberry Pi, con el pin 18 para controlar un LED

#dibuja y Rellena Círculos:

#enciende el LEDe

#mueve la tortuga a su posición inicial (centro)

#establece los colores de la tortuga (pluma y relleno)

#mediante un bucle, dibuja una serie de círculos concéntricos, aumentando su radio progresivamente

#durante el dibujo de *cada* círculo, el LED se apaga por un momento, hay una pausa, y luego el círculo se rellena

#después de dibujar todos los círculos, pausa la ejecución

#apaga el LED completamente

#borra todos los dibujos de la pantalla de Turtle

#y pausa nuevamente

#y por ultimo establece la configuración de los pines GPIO a su estado predeterminado al finalizar la operación

#lbl.configure(text=...): Cambia el texto de la etiqueta `lbl`

#GPIO.setmode(GPIO.BCM) y GPIO.setup(18, GPIO.OUT): configura para controlar el pin 18

#t.clear(): elimina cualquier dibujo previo de la tortuga

#GPIO.output(18, GPIO.HIGH/LOW)`: envía una señal eléctrica al pin 18 para encenderlo (HIGH) o apagarlo (LOW)

#t.home(), t.color(), t.fillcolor(): reestablecen la posición y los colores de la tortuga

#t.begin_fill(),t.circle(r*i), t.end_fill(): son comandos de Turtle para dibujar y rellenar círculos

#time.sleep(segundos): Introduce pausas en la ejecución del programa, deteniendo el flujo por el número de segundos especificado

#GPIO.cleanup():libera los pines GPIO después de usarlos

def boton():

lbl.configure(text="boton presionado")

GPIO.setmode(GPIO.BCM)

GPIO.setup(18, GPIO.OUT)

r = 30  # Radio del ci­rculo

n = 5  

t.clear()

for j in range(1):

# Encender el LED

GPIO.output(18, GPIO.HIGH)

t.home()

t.color("green")

t.fillcolor("Sky blue")

for i in range(1, n + 1):

GPIO.output(18, GPIO.HIGH)

t.begin_fill()

t.circle(r*i)

GPIO.output(18, GPIO.LOW)

time.sleep(2)#pausar 2 segundos

t.end_fill()

# Pausar durante 1 segundo

time.sleep(1)

# Apagar el LED

GPIO.output(18, GPIO.LOW)

# Borrar el dibujo

t.clear()

# Pausar durante un segundo

time.sleep(1)

GPIO.cleanup()

btn = Button(ventana, text="Click Me", command=boton)

btn.grid(column=1, row=1)

ventana.mainloop()

# Esto para cerrar la ventana de turtle

screen = t.getscreen()

screen.exitonclick()

Programa 13:

import turtle

#Carta del dia de las madres

#este programa utiliza la biblioteca 'turtle'

#donde se dibujan varios elementos

#es establecido el tamaño, el color de fondo y el título de la ventana de dibujo

#dibuja un Marco con un relleno de color y un contorno más oscuro, sirviendo como base de la carta.

#añade estrellas, dibuja dos estrellas doradas rellenas en las esquinas superiores del marco

#dibuja una flor central con pétalos rojos/dorados, un tallo verde y hojas

#y dos flores más pequeñas con pétalos en posiciones laterales

#coloca dos corazones rosados rellenos en la parte inferior de la carta

#dibuja un sobre, y

#la ventana permanece abierta 

#turtle.Screen():crea y configura la ventana de dibujo (color de fondo, título)

#turtle.Turtle():crea objetos de "tortuga" 

#penup() y pendown(): levantan o bajan la pluma para mover sin dibujar o para empezar a dibujar

#goto(): mueve la tortuga a coordenadas específicas en la pantalla

#forward() / fd(): mueve la tortuga hacia adelante

# right()/ left(): gira la tortuga

#setheading(): establece la dirección absoluta de la tortuga

#home(): Regresa la tortuga al centro  de la pantalla y la orienta hacia el este

#circle():dibuja un círculo o un arco

#write(): escribe texto en la pantalla

#speed(): controla la velocidad de animación de la tortuga (0 es instantáneo).

#pensize(): establece el grosor de la línea

#color():establece el color de la línea y el color para rellenar formas

#begin_fill(),end_fill():marcan el inicio y el fin de una forma para que sea rellenada con el fillcolor

#hideturtle(): oculta la forma del cursor de la tortuga

#shape()`: cambia la forma visual de la tortuga

colorpantalla = turtle.Screen()

colorpantalla.bgcolor("beige")

colorpantalla.title("Carta del Día de las Madres")

t = turtle.Turtle()

s = turtle.Turtle()

t.speed(0)

t.pensize(2)

s.penup()       

s.hideturtle() 

#Esta función se encarga de dibujar el marco principal de la carta

#primero, dibuja un rectángulo grande relleno con un color claro

#luego, dibuja un contorno más oscuro y grueso sobre el mismo rectángulo

#para darle una apariencia definida de marco

def marco():

t.penup()

t.shape("turtle")

t.speed(5)

t.goto(-300, 200)

t.pendown()

#relleno del marco

t.color("lightskyblue")

t.begin_fill()

for i in range(2):

t.forward(600)

t.right(90)

t.forward(400)

t.right(90)

t.end_fill()

# Dibujar el contorno del marco encima

t.penup()

t.goto(-300, 200)

t.pendown()

t.pensize(5)

t.color("darkslategray")

for i in range(2):

t.forward(600)

t.right(90)

t.forward(400)

t.right(90)

t.pensize(1)

#Esta función dibuja una estrella de cinco puntas en la parte superior derecha de la pantalla

#toma el `radio` (tamaño de la estrella) y el `color` para el relleno

#Para asegurar un relleno completo, dibuja la estrella principal y luego un pequeño pentágono

def estrella(radio, color):

t.penup()

t.goto(220, 160)

t.setheading(0)

t.pendown()

t.color(color)

# Estrella

t.begin_fill()

for j in range(5):

t.forward(radio)

t.right(144)

t.end_fill()

# Pentágono para rellenar el centro

t.penup()

t.goto(220, 155)  

t.setheading(18)   

t.forward(radio * 0.38)  

t.setheading(0)   

t.pendown()

t.begin_fill()

for i in range(5):

t.forward(radio * 0.26)  

t.right(72)

t.end_fill()

def estrella2(radio, color):

t.penup()

t.goto(-260, 160)

t.setheading(0)

t.pendown()

t.color(color)

# Dibujo de estrella

t.begin_fill()

for j in range(5):

t.forward(radio)

t.right(144)

t.end_fill()

t.penup()

t.goto(-260, 155)  

t.setheading(18)    

t.forward(radio * 0.38)  

t.setheading(0)   

t.pendown()

t.begin_fill()

for a in range(5):

t.forward(radio * 0.26)

t.right(72)

t.end_fill()

#Esta es una función para mover la tortuga a una posición específica (x, y)

#sin dejar un rastro de dibujo. Levanta la pluma antes de moverse y la baja después

def point(x, y):

t.penup()

t.goto(x, y)

t.pendown()

#Esta función dibuja una flor con pétalos, un tallo y hojas

#los pétalos se crean usando arcos de círculo, el tallo es una línea recta y las hojas

#tienen una forma similar a los pétalos pero con colores verdes

def floramarilla():

t.speed(4)

t.pensize(2)

t.penup()

t.goto(0, -30)

t.pendown()

t.setheading(0)

# Pétalos 

t.color("red", "gold")

for a in range(0, 360, 45):

point(0, -30)

t.setheading(a)

t.begin_fill()

t.circle(30, 60)

t.left(120)

t.circle(30, 60)

t.end_fill()

# Tallo

t.color("forestgreen")

t.pensize(4)

point(0, -30)

t.setheading(-90)

t.forward(80)

# Hojas

for d in [135, 45]:

t.color("green", "green")

point(0, -70)

t.setheading(d)

t.begin_fill()

t.circle(30, 60)

t.left(120)

t.circle(30, 60)

t.end_fill()

#Esta función dibuja un corazón relleno en una posición (x, `y) y con un tamaño 

#utiliza una combinación de líneas rectas y giros pequeños en un bucle para aproximar la curva del corazón

#turtle.tracer(0,0) y turtle.update() se usan para que el dibujo aparezca instantáneamente

def corazon(t, x, y, tamaño):

turtle.tracer(0,0)

t.penup()

t.goto(x, y)

t.pendown()

t.color("crimson", "lightpink")

t.begin_fill()

t.setheading(140)

t.forward(tamaño)

for i in range(200):

t.right(1)

t.forward(tamaño * 3.14159/ 400)

t.left(120)

for j in range(200):

t.right(1)

t.forward(tamaño * 3.14159/ 400)

t.forward(tamaño)

t.end_fill()

turtle.update()

#Esta función dibuja una flor con un número  de 6 petalos 

#y un colorpetalos qye define el color de pétalos  ("violeta") en la posición (x, y)

#cada pétalo se forma con dos arcos de círculo, y la tortuga gira entre pétalos para distribuirlos

def flor2(x, y, petalos=6, colorpetalos="violet"):

t.penup()

t.goto(x, y)

t.setheading(0)

t.pendown()

t.speed(0)

t.color("black", colorpetalos)

for p in range(petalos):

t.begin_fill()

t.circle(30, 60)

t.left(120)

t.circle(30, 60)

t.left(120)

t.end_fill()

t.left(360 / petalos)

turtle.update()

t.hideturtle()

#Esta función dibuja un sobre y simula su apertura de forma animada

#primero dibuja la base del sobre, luego la solapa triangular superior

#para la animación de apertura, dibuja formas del color del fondo sobre la solapa para simular que desaparece

def sobre():

t.speed(2)

t.penup()

t.goto(-100, -50)

t.pendown()

t.color("black", "linen")

t.begin_fill()

for i in range(2):

t.forward(200)

t.left(90)

t.forward(100)

t.left(90)

t.end_fill()

# Triángulo superior 

t.penup()

t.goto(-100, 50)

t.pendown()

t.color("black", "lightpink")

t.begin_fill()

t.goto(0, 120)

t.goto(100, 50)

t.goto(-100, 50)

t.end_fill()

# levantar la tapa

t.color("ivory")

t.penup()

t.goto(-100, 50)

t.pendown()

t.begin_fill()

t.goto(0, 120)

t.goto(100, 50)

t.goto(0, 50)  # Tapar la tapa

t.goto(-100, 50)

t.end_fill()

# Borrar la tapa para simular apertura

t.color("light blue")

t.begin_fill()

t.goto(-101, 51)

t.goto(0, 122)

t.goto(101, 51)

t.goto(0, 51)

t.goto(-101, 51)

t.end_fill()

# Mostrar el mensaje después de abrir

t.penup()

t.goto(0, 70)

t.color("white")

t.write("¡Feliz Día de las Madres!", align="center", font=("Arial", 18, "bold"))

#Aqui son mandadas a llamar las funciones por figura en orden con sus argumentos de entrada

marco()

sobre()

estrella(60, "gold")

estrella2(60, "gold")

floramarilla()

corazon(t, -200, -100, 40)

corazon(t,200,-100,40)

corazon(t,200,-100,40)

flor2(-100, 0)

flor2(100, 0, petalos=8, colorpetalos="lightblue")

t.hideturtle()

colorpantalla.mainloop()

colorpantalla.exitonscreen

Programa 14:

from tkinter import *#* carga toda la biblioteca

ventana=Tk()# Esta línea crea la ventana principal

ventana.geometry("300x300")# "300x300" significa que la ventana tendrá 300 píxeles de ancho y 300 píxeles de alto

ventana.title("Unidad 5")#titulo de la ventana

# 'ventana' coloca una etiqueta dentro de la ventana principal

# 'text="Minimizar"' establece el texto que mostrará la etiqueta

etiqueta=Label(ventana,text="Minimizar" )

etiqueta.pack()

#ventana coloca el botón dentro de la ventana principal

#text="Minimizar" establece el texto que se muestra en el botón

#command=ventana.iconify le dice al botón qué hacer cuando se hace clic en él

#ventana.iconify() es un método de la ventana Tk que minimiza la ventana

#iconify minimiza la ventana

boton=Button(ventana,text="Minimizar",command=ventana.iconify)

#Esto usa el pack() para colocar el botón debajo de la etiqueta

boton.pack()

ventana.mainloop()

Programa 15:

from tkinter import *#* carga toda la biblioteca

import time

#Esta función está diseñada para simular un efecto de parpadeo en la ventana de la aplicación

#cuando se llama (en este caso, al hacer clic en un botón), realiza la siguiente secuencia de acciones:

#envía la ventana principal de la aplicación a la barra de tareas 

#pausa la ejecución del programa por un tiempo determinado (2 segundos). Durante esta pausa, la ventana permanece minimizada

#despues vuelve a mostrar la ventana en su tamaño y posición anteriores en la pantalla

#Utiliza ventana.iconify()` para minimizar la ventana

#Emplea time.sleep(2) para crear la pausa

#Usa el método ventana.deiconify() para restaurar la ventana a su estado normal

def parpadear():

ventana.iconify()

time.sleep(2)

ventana.deiconify()

ventana=Tk()

ventana.title("Segunda ventana en tkinter")

btn=Button(ventana,text="Evento",command=parpadear)

btn.pack()

ventana.mainloop()

Programa 16:

#Este programa crea una ventana usando Tkinter con dos botones

#uno de los botones cierra la ventana, y el otro imprime un mensaje en la consola

from tkinter import *

def imprime():

print("Acabas de dar click a imprimir")

cuadro=Tk()

cuadro.geometry("300x300")

cuadro.title("Dos botones")

#botón que cierra la ventana

btnS=Button(cuadro,text="Salir",fg="Red",command=cuadro.quit)

btnS.pack(side=LEFT)

#botón que manda a llamar la función imprime que imprime un mensaje

btnI=Button(cuadro,text="Imprime",fg="Blue",command=imprime)

btnI.pack(side=RIGHT)

cuadro.mainloop()

Programa 17:

#Este programacrea una ventana

#utilizando la biblioteca Tkinter

#posiciona 3 etiquetas y un botón

#dentro de una ventana usando .grid() para las posiciones

from tkinter import *

ventana=Tk()

ventana.geometry("300x300")

ventana.title("Posiciones")

btn=Button(ventana,text="posicion uno").grid(row=0,column=1)

etq1=Label(ventana,text="posicion dos").grid(row=0,column=0)

etq2=Label(ventana,text="posicion tres").grid(row=1,column=1)

etq3=Label(ventana,text="posicion cuatro").grid(row=2,column=1)

ventana.mainloop()

Programa 18:

#Este programa es similar al pasado, solo que cambia el posicionamiento de

#las etiquetas y el botón, estando en cuatro esquinas formando un rectángulo

from tkinter import *

ventana=Tk()

ventana.geometry("300x300")

ventana.title("Posicionamiento")

btn=Button(ventana,text="posicion uno").place(x=10,y=10)

lbl1=Label(ventana,text="posicion dos").place(x=200,y=10)

lbl2=Label(ventana,text="posicion tres").place(x=10,y=45)

lbl3=Label(ventana,text="posicion cuatro").place(x=200,y=40)

ventana.mainloop()

Programa 19:

from tkinter import *

#esta función imprime "Te saludo"

def saludo():

print("Te saludo")

#esta función minimiza la ventana

def chiquito():

ventana.iconify()

ventana=Tk()

ventana.title("Ejercicio ")

ventana.geometry("400x200")

#etiqueta

lbl1=Label(ventana,text="Click para saludar",fg="red").place(x=30,y=50)

#botón que manda con el comando que manda a llamar saludo

btn1=Button(ventana,text="Saludar",command=saludo,bg="red",fg="light gray").place(x=200,y=45)

#etiquta 

lbl2=Label(ventana,text="Click para minimizar",fg="blue").place(x=30,y=100)

#botón que manda con el comando que manda a llamar la función chiquito

btn2=Button(ventana,text="Minimiza",command=chiquito,bg="blue",fg="light gray").place(x=200,y=95)

ventana.mainloop()

Programa 20:

#Este programa crea una ventana gráfica con Tkinter

#permite al usuario escribir su nombre y apellidos, y luego, al hacer clic en un botón,

#muestra un saludo personalizado 

from tkinter import *

def saluda():

print("Hola: "+ nombre.get()+" "+apellidoP.get()+" "+apellidoM.get())

ventana=Tk()

ventana.geometry("400x200")

ventana.title("Capture ")

#variables para ser controladas para la ventana Tk

nombre=StringVar()

apellidoP=StringVar()

apellidoM=StringVar()

#En el espacio de entrada de nombre agrega el siguiente mensaje 

nombre.set("Escribe tu nombre")

#etiquetas y entradas

lbln=Label(ventana,text="Nombre:  ").place(x=10,y=10)

bxbn=Entry(ventana,textvariable=nombre ).place(x=170,y=10)

lblap=Label(ventana,text="Apellido Paterno").place(x=10,y=40)

bxbap=Entry(ventana,textvariable=apellidoP ).place(x=170,y=38)

lblam=Label(ventana,text="Apellido Materno").place(x=10,y=70)

bxbam=Entry(ventana,textvariable=apellidoM).place(x=170,y=70)

#botón que ejecuta la función saluda como comando

btns=Button(ventana,text="Te saludo",command=saluda).place(x=10,y=100)

ventana.mainloop()

Programa 21:

#Actividad tarea

#Este programa hace lo mismo que el pasado, solo que

#el boton de saludo es de otro color

#el mensaje de la funcion se imprime tambien dentro de la ventana Tk

from tkinter import *

def saluda():

saludo= ("Hola: "+ nombre.get()+" "+apellidoP.get()+" "+apellidoM.get())

print(saludo)

saludo1.set(saludo)

ventana=Tk()

ventana.geometry("400x200")

ventana.title("Capture ")

nombre=StringVar()

saludo1 = StringVar()

apellidoP=StringVar()

apellidoM=StringVar()

nombre.set("Escribe tu nombre")

lbln=Label(ventana,text="Nombre:  ").place(x=10,y=10)

bxbn=Entry(ventana,textvariable=nombre ).place(x=170,y=10)

lblap=Label(ventana,text="Apellido Paterno").place(x=10,y=40)

bxbap=Entry(ventana,textvariable=apellidoP ).place(x=170,y=38)

lblam=Label(ventana,text="Apellido Materno").place(x=10,y=70)

bxbam=Entry(ventana,textvariable=apellidoM).place(x=170,y=70)

btns=Button(ventana,text="Te saludo",bg="lightblue", fg="white",command=saluda).place(x=10,y=100)

#esta sentencia hace que se muestre en la ventana Tk el saludo que se imprime en la ventana cmd

Label(ventana, textvariable = saludo1, fg="lightskyblue", font=("Arial", 10, "bold")).place(x=10, y=140)

ventana.mainloop()

Programa 22:

from tkinter import *

#Este programa crea una calculadora simple que realiza operaciones basadas en la selección de botones

#la función 'operacion': 

#se ejecuta cuando el usuario hace clic en el botón "Realiza operación"

#obtiene el número ingresado por el usuario del campo de entrada

#Revisa qué botón está seleccionado 'opcion'

#realiza una multiplicación del número por 10, 20, 30, 40 o 50, dependiendo de la opción seleccionada

#si ninguna de las opciones anteriores está seleccionada (es decir, la opción es 6 o cualquier otro valor)

#calcula el cuadrado del número (numero * numero)

#finalmente, crea una etiqueta dentro de la ventana para mostrar el resultado de la operación.

def operacion():

numero=num.get()

if opcion.get()==1:

total=numero*10

elif opcion.get()==2:

total=numero*20

elif opcion.get()==3:

total=numero*30

elif opcion.get()==4:

total=numero*40

elif opcion.get()==5:

total=numero*50

else:

total=numero*numero

#print("El total de las operaciones es: "+str(total))

lblp=Label(ventana,fg="blue",text="Resultado: "+str(total)).place(x=150,y=149)

ventana=Tk()

opcion=IntVar()

num=IntVar()

ventana.title("Botones de radio")

ventana.geometry("400x300")

#etiquetas y entradas de etiqueta

etiqueta1=Label(ventana,text="Escribe un numéro:  ").place(x=20,y=20)

cajaNumero=Entry(ventana,bd=3,textvariable=num).place(x=130,y=20)

etiqueta2=Label(ventana,text="Escribe tu opción:  ").place(x=20,y=50)

#botones de radio

x10=Radiobutton(ventana,text="X10",value=1,variable=opcion).place(x=20,y=80)

x20=Radiobutton(ventana,text="X20",value=2,variable=opcion).place(x=70,y=80)

x30=Radiobutton(ventana,text="X30",value=3,variable=opcion).place(x=120,y=80)

x40=Radiobutton(ventana,text="X40",value=4,variable=opcion).place(x=20,y=110)

x50=Radiobutton(ventana,text="X50",value=5,variable=opcion).place(x=70,y=110)

cuadro=Radiobutton(ventana,text="cuadro",value=6,variable=opcion).place(x=120,y=110)

#botón que contiene el comando que manda a llamar la función operación

btn=Button(ventana,text="Realiza operación",command=operacion).place(x=20,y=149)

ventana.mainloop()

Programa 23:

#Este programa crea una ventana gráfica con Tkinter.

#muestra cómo cargar una imagen desde un archivo y usarla como un elemento visual en la ventana.

from tkinter import *

ventana=Tk()

ventana.title("Uso de imagenes en tkinter")

ventana.geometry("383x131")#tamaño

foto=PhotoImage(file="espacio2.png")# Carga la imagen 'espacio2.png'

# Crea una etiqueta que contiene la imagen y la coloca en la ventana.

fondo=Label(ventana,image=foto).place(x=1,y=1) #

ventana.mainloop()

Programa 24:

#Este programa demuestra Spinbox para permitir al usuario seleccionar un valor

#también muestra cómo recuperar el valor seleccionado y mostrarlo en una ventana de mensaje.

from tkinter import *

from tkinter import messagebox

#La función 'obtener' se ejecuta cuando se hace clic en el botón

#recupera el valor actual del Spinbox que está vinculado a la variable 'valor'

#muestra un cuadro de mensaje informativo que contiene el valor seleccionado.

def obtener():

#print(valor.get())

#lnl3=Label(ventana,fg="green",text=valor.get()).place(x=80,y=170)

messagebox.showinfo("Mensaje","Selección es: "+valor.get())

ventana=Tk()

valor=StringVar()

ventana.title("Uso de Spinbox")

ventana.geometry("400x300")#tamaño de la ventana

#etiqueta

lb1=Label(ventana, text="Ejemplo 1 spinbox").place(x=20,y=20)

#Spinbox para seleccionar entre distintas opciones

combo=Spinbox(ventana,values=("Uno","Dos","Tres","Cuatro","Cinco")).place(x=20,y=50)

lbl2=Spinbox(ventana, from_=1,to=10,textvariable=valor).place(x=20,y=110)

#botón que manda a llamar obtener

boton=Button(ventana,text="Obtener valor Spinbox", command=obtener).place(x=80,y=140)

mainloop()

Programa 25:

#Este programa es una calculadora de IMC

#permite al usuario ingresar su nombre, altura y peso utilizando campos de texto y selectores (Spinbox).

#Al hacer clic en un botón, calcula el IMC y muestra el resultado en una ventana 

#También incluye una imagen de fondo

from tkinter import *

from tkinter import messagebox

def Imc():

nombre = entradanombre.get()  # corregido

altura = float(spinaltura.get())  # corregido

peso = float(spinpeso.get())  # corregido

imc = peso / (altura ** 2)

mensaje = nombre + ", tu IMC es: " + str(imc)

messagebox.showinfo("Resultado IMC", mensaje)

ventana = Tk()

ventana.title("Calculadora de IMC con Spinbox")

ventana.geometry("300x205") 

# Imagen de fondo 

foto = PhotoImage(file="starspaceimage.png")  

fondo = Label(ventana, image=foto)

fondo.place(x=0, y=0, relwidth=1, relheight=1)

Label(ventana, text="Calculadora de IMC", bg="light green").place(x=20, y=20)

Label(ventana, text="Nombre:", bg="beige").place(x=20, y=60)

Label(ventana, text="Altura (m):", bg="beige").place(x=20, y=100)

Label(ventana, text="Peso (kg):", bg="beige").place(x=20, y=140)

entradanombre = Entry(ventana)

entradanombre.place(x=120, y=60)

spinaltura = Spinbox(ventana, from_=1.30, to=2.50, increment=0.01)

spinaltura.place(x=120, y=100)

spinpeso = Spinbox(ventana, from_=30, to=200)

spinpeso.place(x=120, y=140)

Button(ventana, text="Calcular IMC", command=Imc, bg="lightskyblue").place(x=120, y=180)

ventana.mainloop()

Programa 26:

#Este programa de está diseñado para controlar LEDs conectados a los pines GPIO de una Raspberry Pi

#el objetivo es encender y apagar LEDs en una secuencia específica, creando diferentes patrones de luz

#a cada led se le asigno un pin

import sys, time

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)

GPIO.setup(11,GPIO.OUT)#RED

GPIO.setup(13,GPIO.OUT)#Green

GPIO.setup(15,GPIO.OUT)#Blue

GPIO.output(11,1)

time.sleep(1)

GPIO.output(13,1)

time.sleep(1)

GPIO.output(13,1)

time.sleep(1)

GPIO.output(11,0)

GPIO.output(13,0)

GPIO.output(15,0)

time.sleep(1

GPIO.output(11,1)

GPIO.output(13,0)

GPIO.output(15,1)

time.sleep(1)

GPIO.output(11,1)

GPIO.output(13,1)

GPIO.output(15,1)

time.sleep(1)

GPIO.output(11,0)

GPIO.output(13,1)

GPIO.output(15,1)

time.sleep(1)

Programa 27:

#programa proporcionado por la maestra como ejemplo

#para el uso de librerias distintas para el proyecto

#es un simón dice en donde el usuario tiene que repetir el

#patrón que el programa da

from random import choice

from time import sleep

from turtle import *

from freegames import floor, square, vector

pattern = []

guesses = []

tiles = {

    vector(0, 0): ('red', 'dark red'),

    vector(0, -200): ('blue', 'dark blue'),

    vector(-200, 0): ('green', 'dark green'),

    vector(-200, -200): ('yellow', 'khaki'),

}

def grid():

    """Dibuja cuadros """

    square(0, 0, 200, 'dark red')

    square(0, -200, 200, 'dark blue')

    square(-200, 0, 200, 'dark green')

    square(-200, -200, 200, 'khaki')

    update()

def flash(tile):

    """Flash tile in grid."""

    glow, dark = tiles[tile]

    square(tile.x, tile.y, 200, glow)

    update()

    sleep(0.5)

    square(tile.x, tile.y, 200, dark)

    update()

    sleep(0.5)

def grow():

    """Grow pattern and flash tiles."""

    tile = choice(list(tiles))

    pattern.append(tile)

    for tile in pattern:

        flash(tile)

    print('Pattern length:', len(pattern))

    guesses.clear()

def tap(x, y):

    """Respond to screen tap."""

    onscreenclick(None)

    x = floor(x, 200)

    y = floor(y, 200)

    tile = vector(x, y)

    index = len(guesses)

    if tile != pattern[index]:

        exit()

    guesses.append(tile)

    flash(tile)

    if len(guesses) == len(pattern):

        grow()

    onscreenclick(tap)

def start(x, y):

    """Start game."""

    grow()

    onscreenclick(tap)

setup(420, 420, 370, 0)

hideturtle()

tracer(False)

grid()

onscreenclick(start)

done()

Programa 28:

#programa proporcionado por la maestra como ejemplo

#para el uso de librerias distintas para el proyecto

#el programa abre una ventana donde hay 3 botones

#el primero es para seleccionar un audio .mp3

#el 2do es para reproducirlo 

#y el 3ero es para pausarlo

import tkinter as tk

from tkinter import filedialog

import pygame

class AudioPlayerApp:

    def __init__(self, root):  # <-- Corregido __init__

        self.root = root

        self.root.title("Reproducir Audio")

        # Create buttons for opening, playing, pausing, and resuming audio files

        self.open_button = tk.Button(root, text="Open Audio File", command=self.open_audio)

        self.play_button = tk.Button(root, text="Play", state=tk.DISABLED, command=self.play_audio)

        self.pause_button = tk.Button(root, text="Pause", state=tk.DISABLED, command=self.pause_audio)

        self.open_button.pack(pady=10)

        self.play_button.pack()

        self.pause_button.pack()

        # Initialize pygame

        pygame.mixer.init()

        # Register a callback to stop audio when the window is closed

        root.protocol("WM_DELETE_WINDOW", self.on_closing)

        # Initialize playback state

        self.paused = False

    def open_audio(self):

        file_path = filedialog.askopenfilename(filetypes=[("Audio Files", "*.mp3 *.wav")])

        if file_path:

            self.audio_file = file_path

            self.play_button.config(state=tk.NORMAL)

    def play_audio(self):

        pygame.mixer.music.load(self.audio_file)

        pygame.mixer.music.play()

        self.play_button.config(state=tk.DISABLED)

        self.pause_button.config(state=tk.NORMAL)

    def pause_audio(self):

        pygame.mixer.music.pause()

        self.pause_button.config(state=tk.DISABLED)

        self.paused = True

    def on_closing(self):

        if pygame.mixer.music.get_busy():

            pygame.mixer.music.stop()

        self.root.destroy()

if __name__ == "__main__":

    root = tk.Tk()

    app = AudioPlayerApp(root)

    root.mainloop()

Programa 29 (proyecto unidad 5):

#importación de librerias

import os

from tkinter import *

import tkinter as tk

from tkinter import messagebox, filedialog

import time

import pygame

pygame.mixer.init()# Inicializa el módulo de audio

audioesperaSound = None

#aqui agregue un audio que se reproduce si el usuario al reproducir un archivo no 

#se equivoca

#todos los audios están en un try-except por si no están 

try:

soundsecuenciacorrecta = pygame.mixer.Sound("secuenciacorrecta.mp3")

except pygame.error as e:

print("Algo salió mal")

soundsecuenciacorrecta = None

try:

soundrojo = pygame.mixer.Sound("audio1progra.mp3")

soundverde = pygame.mixer.Sound("audio2progra.mp3")

soundamarillo = pygame.mixer.Sound("audio4progra.mp3")

soundazul = pygame.mixer.Sound("audio3progra.mp3")

except:

print("Error al cargar audios de colores")

soundrojo, soundverde, soundamarillo, soundazul = None, None, None, None

#En esta parte importe la libreria para encender los leds en la raspberry

#si no esta, el programa igualmente se correrá

try:

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

gpiodisponible = True

except:

pass

gpiodisponible = False

#pines para los leds

pinledrojo = 17

pinledverde = 27

pinledamarillo = 22

pinledazul = 23

# Configura los pines como salida y apaga todos los LEDs

if gpiodisponible:

GPIO.setup(pinledrojo, GPIO.OUT)

GPIO.setup(pinledverde, GPIO.OUT)

GPIO.setup(pinledamarillo, GPIO.OUT)

GPIO.setup(pinledazul, GPIO.OUT)

def apagartodosleds():

GPIO.output(pinledrojo, GPIO.LOW)

GPIO.output(pinledverde, GPIO.LOW)

GPIO.output(pinledamarillo, GPIO.LOW)

GPIO.output(pinledazul, GPIO.LOW)

apagartodosleds()

#configuraciones de la ventana donde es capturado el archivo

#a crear o modificar

ventana = Tk()

ventana.withdraw()

ventana.title("Simon dice por Hernan")

ventana.geometry("400x400")

icono = tk.PhotoImage(file="logoita.png")

# variables globales

color = "nada" 

listacolores = []#Guarda los colores seleccionados

nombre = StringVar() #Nombre del archivo

secuenciaactualjuego = []  #Secuencia a repetir

indicesecuenciausuario = 0  #Posición actual del jugador

nombrescoloressecuenciacompleta = []  #Nombres de colores para mostrar

#Labels de información debajo de los colores

lbl = Label(ventana, text="", wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

lblsecuencia = Label(ventana, text="", wraplength=300, anchor="center", justify="center")

lblsecuencia.grid(column=0, row=5, columnspan=2, pady=10, sticky="ew")

#crea una carpeta para las partidas

def crearcartapartidas():

if not os.path.exists("partidas simon dice"):

os.makedirs("partidas simon dice")

#esta función servirá para mostrar en la ventana captura 

#los archivos disponibles en la carpeta creada

def mostrararchivosguardados():

archivos = os.listdir("partidas simon dice")

ventana2 = Toplevel()

ventana2.geometry("400x300")

ventana2.title("Partidas Guardadas")

Label(ventana2, text="Archivos guardados:").pack()

for archivo in archivos:

Label(ventana2, text=archivo).pack()

#es reproducida musica mientras esta la ventana de captura abierta con esta función

def stopaudioespera():

global audioesperaSound

if audioesperaSound:

audioesperaSound.stop()

audioesperaSound = None

#al crearse un archivo o modificarse uno, se cerrará esa misma ventana

def cerrarventananombre():

stopaudioespera()

if 'ventana1' in globals() and ventana1.winfo_exists():

ventana1.destroy()

#La siguiente función sirve para al guardar una secuencia con stop, poder 

#crear su archivo correspondiente y cierra la ventana de botones

# y abre la de captura de nuevo

def botguardar(boton1):

if boton1 == 10:

crearcartapartidas()

nombrearch = nombre.get()

with open("partidas simon dice/" + nombrearch + ".txt", "w") as archivo:

archivo.write(','.join(str(x) for x in listacolores))

listacolores.clear()

cerrarventananombre()

mostrarventanaprincipal()

mostrararchivosguardados()

#funcion para minimizar la ventana de botones

def mostrarventanaprincipal():

ventana.deiconify()

#función para cerrar la ventana de botones

#y reabrir la de captura de archivo

def cerraryrepetir():

ventana.withdraw()

abrirventananombre()

#función que servirá para mostrar los colores que el usuario seleccione

def obtenernombrecolorpornumero(numerocolor):

if numerocolor == 1:

return "Rojo"

elif numerocolor == 2:

return "Verde"

elif numerocolor == 3:

return "Amarillo"

elif numerocolor == 4:

return "Azul"

return ""

#la siguiente función verifica que los botones que el usuario seleccione

#al terminar la reproducción de un archivo coincidan y mostrará mensaje sobre 

#si la secuencia por el usuario es correcta o no

#y al final mostrará en la ventana la secuencia correcta

def verificarsecuenciausuario(colseleccionado):

global indicesecuenciausuario, secuenciaactualjuego, nombrescoloressecuenciacompleta

global soundsecuenciacorrecta

if not secuenciaactualjuego:

return

if colseleccionado == secuenciaactualjuego[indicesecuenciausuario]:

indicesecuenciausuario += 1

if indicesecuenciausuario == len(secuenciaactualjuego):

messagebox.showinfo("Secuencia correcta", " La secuencia es correcta!")

if soundsecuenciacorrecta:

soundsecuenciacorrecta.play()

lbl.config(text="")

print(f"Secuencia correcta: {' - '.join(nombrescoloressecuenciacompleta)}")

lblsecuencia.config(text="Secuencia correcta: " + ' - '.join(nombrescoloressecuenciacompleta))

secuenciaactualjuego.clear()

indicesecuenciausuario = 0

nombrescoloressecuenciacompleta.clear()

else:

messagebox.showerror("Secuencia incorrecta", "¡Oh no, la secuencia es incorrecta!")

lbl.config(text="")

print(f"Secuencia incorrecta. La secuencia correcta era: {' - '.join(nombrescoloressecuenciacompleta)}")

lblsecuencia.config(text="Secuencia incorrecta. La secuencia correcta era: " + ' - '.join(nombrescoloressecuenciacompleta))

secuenciaactualjuego.clear()

indicesecuenciausuario = 0

nombrescoloressecuenciacompleta.clear()

#Esta función maneja el comportamiento cuando se presiona un botón en el juego

#el parámetro col representa un valor entre 1 y 6, donde:

#1 a 4 representan botones de colores (Rojo, Verde, Amarillo, Azul)

#5 guarda la secuencia actual en un archivo de texto

#6 permite seleccionar y reproducir una secuencia guardada

#apaga todos los botones y espera un momento

#según el valor de col, se realiza una acción específica:

#col == 1 a 4:

#borra el texto actual en la etiqueta.

#muestra el nombre del color correspondiente.

#agrega el número a la lista `listacolores`.

#determina el sonido a reproducir.

#enciende visualmente el botón

#reproduce el sonido

#verifica si la secuencia del usuario es correcta

#apaga los botones después de un pequeño retardo

 

#col == 5 :

#verifica que el usuario haya ingresado un nombre de archivo

#crea la carpeta de partidas si no existe

#guarda la lista en un archivo .txt

#muestra una advertencia si el nombre no está ingresado

#limpia la lista y oculta la ventana principal

#muestra archivos guardados y reabre la ventana para ingresar nombre

#col == 6:

#limpia etiquetas

#Llama a seleccionaryreproducir() para cargar y reproducir una secuencia

#Otro valor:

#muestra texto "nada" como respuesta predeterminada

def clicked(col):

global color, lbl

try:

apagartodos() 

ventana.update_idletasks()

time.sleep(0.1) 

colorname = ""

soundtoplay = None

if col == 1:

color = " " * 30

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

color = "Rojo"

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

listacolores.append(1)

soundtoplay = soundrojo

elif col == 2:

color = " " * 30

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

color = "Verde"

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

listacolores.append(2)

soundtoplay = soundverde

elif col == 3:

color = " " * 30

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

color = "Amarillo"

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

listacolores.append(3)

soundtoplay = soundamarillo

elif col == 4:

color = " " * 30

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

color = "Azul"

lbl = Label(ventana, text=color, wraplength=300, anchor="center", justify="center")

lbl.grid(column=0, row=4, columnspan=2, pady=5, sticky="ew")

ventana.update_idletasks()

listacolores.append(4)

soundtoplay = soundazul

if col in [1, 2, 3, 4]:

encenderbotonSinAudio(col)

if soundtoplay:

soundtoplay.play()

verificarsecuenciausuario(col)

time.sleep(0.2)

apagartodos()

if secuenciaactualjuego:

lbl.config(text="Ahora, repite la secuencia...") 

else:

lbl.config(text="") 

elif col == 5:

if not nombre.get():

messagebox.showwarning("Advertencia", "Debes ingresar un nombre de archivo antes de jugar.")

return

crearcartapartidas()

nombrearch = nombre.get()

with open("partidas simon dice/" + nombrearch + ".txt", "w") as archivo:

archivo.write(','.join(str(x) for x in listacolores))

messagebox.showinfo("Guardado", f"Partida guardada como '{nombrearch}.txt'")

listacolores.clear()

ventana.withdraw()

mostrararchivosguardados()

abrirventananombre() 

lbl.config(text="")

lblsecuencia.config(text="") 

return

elif col == 6:

lblsecuencia.config(text="") 

lbl.config(text="Memoriza la secuencia...")

seleccionaryreproducir()

else:

color = "nada"

lbl.config(text=color)

except:

print(f"Error en clicked: {e}")

lbl.config(text="Error inesperado")

ventana.update_idletasks()

def abrirventananombre():

global ventana1, audioesperaSound

ventana1 = Toplevel()

ventana1.geometry("400x300")

ventana1.title("Captura")

if audioesperaSound is None or not (audioesperaSound.get_num_channels() > 0): 

try:

audioesperaSound = pygame.mixer.Sound("audioespera.mp3")

audioesperaSound.play(-1)

except pygame.error as e:

print(f"Error al cargar o reproducir audioespera.mp3: {e}")

audioesperaSound = None

ventana1.protocol("WM_DELETE_WINDOW", cerrarventananombre)

lbln = Label(ventana1, text="¿Quieres crear o modificar un archivo?")

lbln.place(x=10, y=10)

bxbn = Entry(ventana1, textvariable=nombre)

bxbn.place(x=10, y=50)

btns = Button(ventana1, text="Guardar", bg="lightskyblue", command=lambda: botguardar(10))

btns.place(x=10, y=80)

lblLista = Label(ventana1, text="Archivos disponibles:")

lblLista.place(x=10, y=120)

if os.path.exists("partidas simon dice"):

archivos = os.listdir("partidas simon dice")

fila = 140

for archivo in archivos:

Label(ventana1, text=archivo).place(x=10, y=fila)

fila += 20

else:

Label(ventana1, text="(No hay archivos guardados)").place(x=10, y=140)

#configuración de los botones 

r = PhotoImage(file="rojo.png")

br = r.subsample(3, 3)

btnr = Button(ventana, width=100, height=100, image=br, borderwidth=5, command=lambda: clicked(1), activebackground='Indian Red')

btnr.grid(column=0, row=0)

v = PhotoImage(file="verde.png")

bv = v.subsample(3, 3)

btnv = Button(ventana, width=100, height=100, image=bv, borderwidth=5, command=lambda: clicked(2), activebackground='limegreen')

btnv.grid(column=1, row=0)

a = PhotoImage(file="amarillo.png")

ba = a.subsample(3, 3)

btna = Button(ventana, width=100, height=100, image=ba, borderwidth=5, command=lambda: clicked(3), activebackground='gold')

btna.grid(column=0, row=1)

az = PhotoImage(file="azul.png")

baz = az.subsample(3, 3)

btnaz = Button(ventana, width=100, height=100, image=baz, borderwidth=5, command=lambda: clicked(4), activebackground='steelblue')

btnaz.grid(column=1, row=1)

alto = PhotoImage(file="stop.png")

balto = alto.subsample(3, 3)

btnalto = Button(ventana, width=100, height=100, image=balto, command=lambda: clicked(5))

btnalto.grid(column=0, row=3)

ju = PhotoImage(file="reproduce.png")

bjuega = ju.subsample(3, 3)

btnjuega = Button(ventana, width=100, height=100, image=bjuega, command=lambda: clicked(6))

btnjuega.grid(column=1, row=3)

ventana.iconphoto(True, icono)# Establece el icono de la ventana principal

#botones que remplazarán a los normales al apagarse

rclaro = PhotoImage(file="rojoclaro.png").subsample(3, 3)

vclaro = PhotoImage(file="verdeclaro.png").subsample(3, 3)

aclaro = PhotoImage(file="amarilloclaro.png").subsample(3, 3)

azclaro = PhotoImage(file="azulclaro.png").subsample(3, 3)

def apagartodos():

btnr.config(image=rclaro)

btnv.config(image=vclaro)

btna.config(image=aclaro)

btnaz.config(image=azclaro)

ventana.update()

time.sleep(0.1)

if gpiodisponible:

apagartodosleds()

#Enciende visualmente un botón de color específico (sin reproducir su sonido si no esta)

#También enciende el LED correspondiente si GPIO está disponible

def encenderbotonSinAudio(numcolor):

if numcolor == 1:

btnr.config(image=br)

if gpiodisponible:

GPIO.output(pinledrojo, GPIO.HIGH)

elif numcolor == 2:

btnv.config(image=bv)

if gpiodisponible:

GPIO.output(pinledverde, GPIO.HIGH)

elif numcolor == 3:

btna.config(image=ba)

if gpiodisponible:

GPIO.output(pinledamarillo, GPIO.HIGH)

elif numcolor == 4:

btnaz.config(image=baz)

if gpiodisponible:

GPIO.output(pinledazul, GPIO.HIGH)

ventana.update()

#Enciende visualmente un botón de color, reproduce su sonido y enciende el LED (si está disponible)

#esto se usa para reproducir la secuencia del juego

def encenderboton(numcolor):

apagartodos()

time.sleep(0.5)

if numcolor == 1:

btnr.config(image=br)

if soundrojo: soundrojo.play()

if gpiodisponible:

GPIO.output(pinledrojo, GPIO.HIGH)

elif numcolor == 2:

btnv.config(image=bv)

if soundverde: soundverde.play()

if gpiodisponible:

GPIO.output(pinledverde, GPIO.HIGH)

elif numcolor == 3:

btna.config(image=ba)

if soundamarillo: soundamarillo.play()

if gpiodisponible:

GPIO.output(pinledamarillo, GPIO.HIGH)

elif numcolor == 4:

btnaz.config(image=baz)

if soundazul: soundazul.play()

if gpiodisponible:

GPIO.output(pinledazul, GPIO.HIGH)

ventana.update()

time.sleep(1)

# Permite al usuario seleccionar un archivo de secuencia guardado y lo reproduce.

def seleccionaryreproducir():

stopaudioespera()

if not os.path.exists("partidas simon dice"):

messagebox.showinfo("Info", "No hay partidas guardadas.")

abrirventananombre() 

return

archivos = os.listdir("partidas simon dice")

if not archivos:

messagebox.showinfo("Info", "No hay archivos para reproducir.")

abrirventananombre() 

return

ventanaSel = Toplevel()

ventanaSel.geometry("300x300")

ventanaSel.title("Selecciona una partida")

ventanaSel.protocol("WM_DELETE_WINDOW", lambda: [ventanaSel.destroy(), abrirventananombre()])

Label(ventanaSel, text="Haz clic en una partida para reproducir:").pack(pady=10)

for archivo in archivos:

btn = Button(ventanaSel, text=archivo, width=30,command=lambda arch=archivo: reproducirarchivo(arch, ventanaSel))

btn.pack(pady=5)

# Reproduce la secuencia de colores desde un archivo guardado

def reproducirarchivo(nombrearchivo, ventanaSel):

global secuenciaactualjuego, indicesecuenciausuario, nombrescoloressecuenciacompleta

ruta = os.path.join("partidas simon dice", nombrearchivo)

ventanaSel.destroy()

print(f"Reproduciendo archivo: {nombrearchivo}")

try:

with open(ruta, "r") as f:

datos = f.read().strip().split(',')

secuenciaactualjuego = [int(d) for d in datos if d.strip().isdigit()]

indicesecuenciausuario = 0

nombrescoloressecuenciacompleta = [obtenernombrecolorpornumero(d) for d in secuenciaactualjuego]

lbl.config(text="Memoriza la secuencia...")

lblsecuencia.config(text="")

ventana.update_idletasks()

for d in secuenciaactualjuego:

encenderboton(d)

time.sleep(0.5)

apagartodos()

time.sleep(0.5)

lbl.config(text="Ahora, repite la secuencia...")

ventana.update_idletasks()

except Exception as e:

messagebox.showerror("Error", f"No se pudo leer el archivo: {e}")

lbl.config(text="")

lblsecuencia.config(text="")

abrirventananombre()

#Función 'alcerrar' 

#maneja el cierre de la ventana principal 

#se ejecuta cuando el usuario cierra la ventana principal del juego

def alcerrar():

if gpiodisponible:

apagartodosleds()

GPIO.cleanup()

pygame.mixer.quit()

ventana.destroy()

# Configura la ventana para llamar a la función 'alcerrar' cuando se intente cerrar

ventana.protocol("WM_DELETE_WINDOW", alcerrar)

# Abre la ventana de captura de nombre al iniciar el programa

abrirventananombre() 

# Esto hace que la ventana se muestre en pantalla y se mantenga abierta

ventana.mainloop()