Lenguaje de Programación Estructurada

UNI – FIIS
Glen Rodríguez R.
 Interfaces gráficas en Python
●
Interfaz: es el medio o mecanismo con que el
usuario puede comunicarse con una máquina
●
Una interfaz gráfica de usuario, o GUI (Graphical
User Interface) es un componente de un programa
informático que actúa de interfaz de usuario,
utilizando un conjunto de imágenes y objetos
gráficos para representar la información y acciones
disponibles en la interfaz. Su principal uso, consiste
en proporcionar un entorno visual sencillo para
permitir la comunicación con el resto del programa.
La interacción del usuario es a través de la
manipulación de las imágenes y objetos gráficos.
 Libreria para GUIs en Python
●
Tkinter: módulo "Tk Interface" es un conjunto
de herramientas de interfaz estándar de
Python, basado en otra librería Tk del lenguaje
Tcl .Está disponible en la mayoría de las
plataformas Unix y Linux, y en sistemas
Windows y Macintosh, desde la versión Tk 8.0.
●
WxPython
●
PyQT
●
PyGTK
●
PySide
 Pasos generales para programar
con Tkinter
●
Importar el módulo Tkinter
●
Crear una ventana
●
Crear el control o controles dentro de la
ventana
●
Asignar a cada control una lógica, ya sea
propia o prefabricada. Ejemplo de lógica pre-
fabricada: mainloop (loop infinito)
 Primer ejemplo
from tkinter import Tk, Label
# Crear ventana.
ventanaTop = Tk()
# Crear etiqueta
l = Label(ventanaTop, text = "Hola mundo")
# Posicionar la etiqueta.
l.pack()
# Run la ventana y sus hijos en un loop prefabricado
ventanaTop.mainloop()
 Qué hace mainloop?
●
La función o método mainloop pone la etiqueta en
la ventana, la ventana en la pantalla y deja al
programa en un estado de “espera”
●
Espera qué? Espera a cualquier actividad del
usuario, llamada “evento”
●
Eso es la “programación orientada a eventos”
●
La GUI es básicamente un conjunto de lógicas
“manejadoras” de eventos que comparten
información. No es una lógica lineal.
 Primer ejemplo mejorado
from tkinter import Tk, Label
ventanaTop = Tk()
l = Label(ventanaTop, text = "Hola mundo")
l.pack()
# Poner un titulo en la ventana.
ventanaTop.title("Mi Programa")
# Cambiar tamanno minimo.
ventanaTop.minsize(400, 400)
# Cambiar color de fondo
ventanaTop.configure(bg = "green")
ventanaTop.mainloop()
 Ejemplo 2
from tkinter import Label, Button, Tk
# Usamos una funcion 'callback'
# Se invoca cuando se aprieta un boton.
def hola_callback():
print("Hola")
top = Tk()
l = Label(top, text = "Mi boton:")
l.pack()
# Crear boton
b = Button(top, text = "Hola", command = hola_callback)
b.pack()
top.mainloop()
 Explicación
●
La función Button crea un botón. Su primer parámetro
es su ventana padre (puedo crear 2 o más ventanas,
y debo diferenciar cuál es el padre del botón, o sea a
que ventana pertenece). El segundo parámetro es el
texto que aparece en el botón.
●
El comando pack hace visible al botón en la ventana
y ordena a la ventana padre que cambie de tamaño
para que entre el botón.
●
Cuando hago click en el botón, se ejecuta la función
hola_callback (imprimo “Hola” en la linea de
comandos, no en la ventana del GUI)
 Mejorando
# MyApp.py
from tkinter import Label, Button
class MyApp:
def __init__ (self, master):
self.l = Label(master,text = "My Button:")
self.l.pack()
self.b = Button(master,text = "Hello",command = self.hola)
self.b.pack()
# Funcion de callback
def hola(self): print("Hola")
 Programa principal
# principal2.py
import tkinter
from MyApp import MyApp
top = tkinter.Tk()
# El constructor de MyApp toma a la
# ventana padre como argumento.
app = MyApp(top)
top.mainloop()
 Explicación
●
Una GUI puede tener muchos elementos
gráficos (botones, textos ,etc). Es mejor crear
un archivo diferente para cada elemento gráfico
y luego juntarlos por importación.
●
El elemento gráfico se “construye” (inicializa)
usando como parámetro al padre. Si no, cómo
sabe en que ventana le corresponde estar?.
 Modificando
# MyApp.py
from tkinter import Label, Button, Frame
class MyApp(Frame):
def __init__(self, master = None):
Frame.__init__(self, master)
self.pack()
self.l = Label(self, text = "Mi boton:")
self.l.pack()
self.b = Button(self, text = "Hola", command = self.hola)
self.b.pack()
def hola(self): print("Hola")

if __name__ == "__main__":
MyApp().mainloop()
 Y no necesito Programa principal
●
Frame es un contenedor parecido a una ventana. El objeto MyApp
ahora no necesita padre, contiene un label y un botón.
●
Y tiene su propia lógica mainloop. Puedo ejecutar de frente a un
Frame
●
Todo módulo en python tiene un atributo especial llamado
__name__ que define el espacio de nombres en el que se está
ejecutando. Es usado para identificar de forma única un módulo en
el sistema de importaciones. Por su parte __main__ es el nombre
del ámbito en el que se ejecuta el código de nivel superior (tu
programa principal).
●
El intérprete pasa el valor del atributo a '__main__' si el módulo se
está ejecutando como programa principal .
●
if __name__ == "__main__" da True si el programa es el principal,
False en caso contrario.
Otros elementos gráficos (widgets)
●
Buttons, Checkbuttons, Radiobuttons, Menubuttons
●
Canvas (para dibujar formas)
●
Entry (para tipear texto)
●
Message (muestra mensakes al usuario)
●
Labels (textos o imágenes)
●
Frames (un contenedor de otros widgets)
●
Scale, Scrollbar
●
Text (para mostrar y editar texto)
 Variables de control
●
Estos elementos tienen variables asociadas a
ellos, que sirven para:
– Cambiar la variable, lo que causa una modificación
en la apariencia o el comportamiento del elemento
(ejemplo: cambiar el texto dentro del botón,
cambiar el color de una ventana)
– Leer un cambio que el usuario ha hecho al objeto
(ejemplo: usuario tipeo un texto, usuario activo o
desactivo un checkbox)
 Variables de control
●
Variable ’textvariable’: es una cadena o string
asociado a un botón.
●
Variable ’variable’: es un entero. Asociado al
estado de un checkbutton (checkbox)
●
Variable ’textvariable’: string asociado a un Entry
●
Variable ’variable’: es un entero o un string.
Asociado a un radiobutton
●
Todas tiene un método set(valor) y otro get()
 Ejemplo
from tkinter import IntVar, BOTH, Checkbutton, Frame
class MyCheckbutton(Frame):
def __init__(self, master = None):
Frame.__init__(self, master)
self.pack(expand = True, fill = BOTH)
self.master.title("")
self.master.minsize(250, 100)
# variable de control
self.var = IntVar()
# Crear checkbutton.
cb = Checkbutton(self, text = "Mostrar titulo", variable = self.var, command = self.click)
cb.place(x = 50, y = 50)
def click(self):
if (self.var.get() == 1):
self.master.title("Aqui estoy!")
else: self.master.title("")
if __name__ == "__main__":
MyCheckbutton().mainloop()
 Explicación
●
BOTH es una constante que le dice a tkinter que llene
el espacio tanto en sentido vertical como horizontal.
●
Creo la variable “var” tipo Entero IntVar(). También hay
decimal DoubleVar() y texto StringVar(). Al crear el
boton le digo que su ‘variable’ es var (variable=self.var)
●
“var” es 0 si el checkbox está sin check, 1 si está con
check. Lo leo con self.var.get()
●
El self.master.title es el titulo del master (el mismo
Frame que al no necesitar padre es su propio padre)
 Leyendo textos (1)
from tkinter import *
class lbs2kgs(Frame):
def __init__(self, master = None):
Frame.__init__(self, master)
self.pack()
frameAbajo = Frame(self).pack( side = BOTTOM )
self.lbs = StringVar()
self.mitexto= StringVar()
lbs_entry = Entry(self, width = 7, textvariable = self.lbs)
lbs_entry.pack(side = LEFT)
Label(self, text = "lbs").pack(side = LEFT)
Button(self, text = "Calcular en kg.", command = self.calc).pack(side = LEFT)
res=Label(frameAbajo, textvariable=self.mitexto)
 Leyendo textos (2)
res.pack(side = BOTTOM)
lbs_entry.focus()
for c in self.master.winfo_children():
c.pack(padx = 5, pady = 5)
def calc(self):
try:
valor = float(self.lbs.get())
kilos= str(0.453592*valor)
self.mitexto.set("Equivale a "+kilos+" kgs.")
except ValueError:
pass
if __name__== "__main__":
lbs2kgs().mainloop()
 Tipos de datos abstractos
●
Un TDA es un conjunto de datos u objetos al cual se le
asocian operaciones. El TDA provee de una interfaz con
la cual es posible realizar las operaciones permitidas,
abstrayéndose de la manera en como estén
implementadas dichas operaciones. Hay más de una
forma de implementar TDAs
●
Abstraer implica que no manipulo directamente los datos,
si no a través de funciones y operaciones predefinidas,
de alto nivel.
●
En C, una forma común es usar punteros como parte de
los datos. Otra forma es usando matrices o arrays de
varias dimensiones.
●
Ejemplos de TDA: listas, pilas, colas, árboles.
 Punteros
●
No existen punteros en Python tal cuál existen en
C, C++ o Pascal. En esos lenguajes hay variables
de tipo pointer que son direcciones en memoria de
otras variables y pueden ser sujetas a operaciones
por el programador (ej.: sumar 20 a un puntero)
●
En Java o Python, hay punteros implícitos, como
referencias a otros objetos que NO pueden ser
sujetas a operaciones (punteros como
implementación)
 Punteros
●
Los siguientes tipos son “punteros en
implementación”:
– Listas
– Tuplas
– Diccionarios
– Objetos (clases)
●
Para tipos de datos abstractos, se usan objetos
para implementar una especie de “registro con
punteros en C” para los nodos
 Clase Nodo
●
Muy útil. Representa a cualquier variable que tiene
valores propios y además un puntero o dirección a
la siguiente variable del mismo tipo.
●
Ejemplo: en una carretera tengo una lista de
ciudades Ciudad1→ Ciudad2 → … → CiudadN
●
La variable Ciudad1 contiene su nombre, población,
etc y la dirección a la variable que representa la
siguiente ciudad de la ruta.
●
Que pasa si la carretera ya no pasa por la ciudad4?
La lista se la saltea: … → ciudad3 → ciudad5 → …
●
La última ciudadN tiene como siguiente a NULL
 Clase nodo
class Nodo:
def __init__(self, carga=None,
siguiente=None):
self.carga=carga
self.siguiente=siguiente
def __str__(self):
return str(self.carga)
 Creando un TDA lista
nodo1=Nodo("Tumbes")
print(nodo1)
nodo2=Nodo("Piura")
nodo3=Nodo("Chiclayo")
nodo1.siguiente=nodo2
nodo2.siguiente=nodo3

●
Estos 3 nodos forman una LISTA ENLAZADA
 Imprime toda la lista enlazada
def imprimeLista(nodo):
while nodo:
print(nodo)
Nodo= nodo.siguiente
print()

imprimeLista(nodo1)