Bienvenido a la documentación de Modelado y Programación 2015-2!¶
Contenido:
Introducción a Python¶
Este texto es un conjunto de información general sobre Python, se pretende que sea una referencia rápida para prácticas dejadas en clase. En ningún momento llega a sustituir la documentación oficial ni los libros sugeridos en la bibliografÃa del curso.
¿Qué es Python?¶
Es un lenguaje de programación fuertemente tipado [1] y de tipado dinámico(las variables pueden cambiar de tipo en asignaciones durante la ejecución del programa).
Es un lenguaje “Orientado a objetos” en el sentido en que todo es tratado como uno, incluso las funciones aunque Python no impone la orientación a objetos como el paradigma principal.
Interprete¶
Para poder ejecutar nuestros archivo de python necesitamos de un interprete. Python nos ofrece uno que funciona de 2 maneras. Pasando parámetros y modo interctivo.
Pasando parámetros¶
De esta forma invocamos al interprete pasándole como parámetro nuestro arhivo a ejecutar
pyhton mi_programa.py
python3 mi_programa.py
La diferencia es que en nuestro sistema podemos tener asociado python a la versión 2 o 3 por lo que puede hacer falta especificar la versión del interprete con la cual queremos ejecutar nuestro código
Modo interactivo¶
El módo interactivo nos permite escribir código y ejecutarlo al momento sin necesidad de escribir en un archivo. Es muy útil cuando se necesita probar código.
pyhton
python3
La diferencia es que en nuestro sistema podemos tener asociado python a la versión 2 o 3 por lo que puede hacer falta especificar la versión del interprete con la cual queremos ejecutar nuestro código
Hola Mundo¶
Aquà el ejemplo clásico del programa Hola Mundo!. No sé necesita más que una sola lÃnea de código
print("Hola Mundo!")
Hola Mundo!
¿Dónde está el main?¶
Los programas escritos en Python no se empiezan a ejecutar desde álgún metodo main, en cambio se empiezan a ejecutar desde la primera lÃnea del archivo.
Aunque no exista un método main, para programas algo más complejos, se recomienda declarar uno.
def main():
codigo...
main()
Tipos de Datos¶
Cadenas¶
variable = "Esta es una 'cadena' en Python"
variable = 'Esta es una "cadena" en Python'
variable = """Esta es una cadena de
varias
lÃneas"""
variable = str(234)
Números Enteros¶
variable = 234
variable = int(234.0)
variable = int("234")
Números Flotantes¶
variable = 234.0
variable = float(234)
variable = float("234.0")
Números Complejos¶
variable = 234j
variable = 234 + 456j
variable = complex(234,456)
Booleanos¶
variable = True
variable = False
Control de Flujo¶
For¶
for elemento in objeto_iterable:
codigo...
else:
codigo...
Si queremos iterar y no necesitamos de la variable podemos usar un guión bajo en la seccion de la variable del for
for _ in iterable:
codigo...
While¶
while condicion:
codigo...
else:
codigo...
If¶
if condicion1:
codigo...
elif condicion2:
codigo...
else:
codigo...
Selector¶
"cadena"[3] # 4to caracter
'e'
"cadena"[-1] # Últmio caracter
'a'
"cadena"[2:4] # Subcadena desde el 2do hasta el 4to
'de'
"cadena"[:3] # Todos los caracteres hasta el 3ro
'cad'
"cadena"[3:] # Todos los caracteres apartir del 4to
'ena'
"cadena"[::2] # Todos los caracteres impares
'cdn'
Módulos¶
Un módulo es un archivo que es importado usando alguna de las formas siguientes:
from modulo import *
from modulo import sqrt
import modulo
Paquete¶
Un paquete es una colección de módulos en directorios en cierta jerarquÃa.
from my_paquete.timing.danger.internets import modulo
Estructuras de Datos¶
Listas¶
lista = list() # Constructor de lista vacÃa
lista = [] # Constructor de lista vacÃa
lista = [1, 2, 3, "a", "b", "c"] # Constructor de lista con elementos
Se debe notar que las listas pueden tener elementos de varios tipos
Clases¶
class MiClase:
def __init__(self, parametro):
self.variable = parametro
def mi_metodo(self):
print(self.variable)
Métodos¶
def metodo(self, parametro1, parametro2=default):
codigo...
Cuando se manda a llamar a un método se necesita pasar el objeto mismo. Por eso es necesario usar el parámetro self.
Herencia¶
Python2
class A(object):
def __init__(self, variable):
self.var1 = 1
self.var2 = variable
class B(A):
def __init__(self, param1, param2):
super(A, self).__init__(param1)
self.var3 = param2
Python3
class A:
def __init__(self, variable):
self.var1 = 1
self.var2 = variable
class B(A):
def __init__(self, param1, param2):
super().__init__(param1)
self.var3 = param2
Excepciones¶
Try¶
try: # Código a ser monitoreado
pass
except Exception as ex: # Cacha la excepción y la da un nombre
raise ex
else: # Se ejecuta sólo si no se lanza una excepción en el bloque *try*
pass
finally: # Se ejecuta haya o no haya una excepción
pass
Preguntas frecuentes y cosas Interesantes¶
Retorno de las funciones¶
Las funciones siempre regresan algo. Si no se especifica el valor de retorno la función regresa el objeto None
Errores comunes¶
No se modifican las variables globales¶
Manera incorrecta de hacerlo
variable = 56
def mi_funcion():
variable = 0
mi_funcion()
print(variable)
56
Se debe usar la palabra reservada global para modificar variables globales
variable = 56
def mi_funcion():
global variable
variable = 0
mi_funcion()
print(variable)
0
Argumentos mutables por defecto¶
Lo que escribiste¶
def encola(elemento, lista=[]):
lista.append(elemento)
return lista
Lo que esperas¶
mi_lista = encola(12)
print(mi_lista)
[12]
mi_otra_lista = encola(42)
print(mi_otra_lista)
[42]
Lo que pasó¶
mi_lista = encola(12)
print(mi_lista)
[12]
mi_otra_lista = encola(42)
print(mi_otra_lista)
[12, 42]
Solución¶
def encola(elemento, lista=None):
if lista is None:
lista = list()
lista.append(elemento)
return lista
Práctica 1¶
- Lista los comandos de linux que puedan realizar las siguientes acciones:
- Crear un archivo
- item Borrar un archivo
- item Crear un directorio
- item Borrar un directorio
- item Listar archivos y directorios
- item Cambiar de directorio
- item Imprimir el directorio actual
- Lista al menos 5 funciones que Python ofrece por defecto y escribe una pequeña descripción de lo que hacen.
- Hacer un programa que reciba números de uno por uno de la lÃnea de comandos y cumpla con lo siguiente:
- Si el número actual es el primer número que se lee entonces se guarda
- Si el número actual es menor que los recibidos anteriormente se debe ignorar e imprimir los números anteriores que sà fueron agregados. Es decir, sólo se aceptan números en orden no decreciente.
- Si se recibe la letra m se debe calcular la media aritmética de los números que sà fueron agregados y se debe de imprimir
- Si se recibe una cadena vacÃa el programa debe terminar
[1] | QtGui.Application.exec_ |
[2] | Wikipedia |
[3] | PyQt |
Estilo de código¶
Código explÃcito¶
Una declaración por lÃnea¶
Mal
print ("uno"); print ("dos")
if x == 1: print("uno")
if comparacion_compleja and otra_comparacion_compleja:
pass
Bien
print ("uno")
print ("dos")
if x == 1:
print ("uno")
cond1 = comparacion_compleja
cond2 = otra_comparacion_compleja
if cond1 and cond2:
pass
Propiedades privadas¶
Se utiliza un underscore
_variable_privada = "No me toques"
En realidad esto no es diferente de declararla sin el guión bajo. Es una convención entre programadores del lenguaje
Multiple retornos en una función¶
Intentar usar sólo uno para el regreso si funcinó correctamente
No Recomendado
if algo:
return algo
elif algo2:
return algo2
elif error1:
return error1
else:
raise Except("error2")
Recomendado
regreso = None
if algo:
regreso = algo
elif algo2:
regreso = algo2
elif error1:
return error1
else:
raise Except("error2")
return regreso
Se pueden usar varios para casos de errores o se tenga que avisar lo más pronto posible
Crear lista de la misma cosa¶
Se crea una lista donde cada entrada es el mismo objeto, esto significa que si el elemento es un objeto mutable, como una lista, si se modifica uno entonces se modificaran todos los demás.
No son copias. Es el mismo objeto en cada entrada de la lista
cuatro_nones = [None] * 4
cuatro_listas = [[]] * 4
Crear listas de tamaño N¶
Se crea una lista donde cada entrada es una copia diferente, asà si modificas un objeto mutable o no mutable esto no repercute en los demás.
cuatro_listas = [[] for __ in range(4)]
numeros = [x for x in range(20)]
numeros_impares = [x for x in range(20) if x%2 != 0]
Patrones de Diseño¶
Los patrones de diseño consisten en dar soluciones a problemas generales.
Un patrón es la descripción de la solución a un problema en cierto contexto
Factory(Fábrica)¶
El patrón Factory es uno de los patrones más usados en Java. Este patrón de diseño cabe dentro de la categoria de creational pattern ya que nos proporciona una de las mejores formas de crear un objeto
En este patrón nosotros creamos un objeto sin exponer la lógica al cliente y rifiriendonos al nuevo objeto usando una interfaz común.
Implementación¶
Vamos a crear una interfaz Shape y clases concretas que la implementen. A continuación definiremos una clase ShapeFactory.
Nuestra clase FactoryPatternDemo usará ShapeFactory para obtener objetos de tipo Shape. Le pasará información(CIRCLE / RECTANGLE / SQUARE) a ShapeFactory para obtener los objetos que necesita. s Paso 1 ++++++ Creamos nuestra interfaz
public interface Shape {
void draw();
}
Paso 2¶
Creamos las clases concretas implementando la interfaz
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
Paso 3¶
Creamos nuestro objeto Fábrica(Factory) que genera nuestros objetos concretos basados en información proporcionada.
ShapeFactory.java
public class ShapeFactory {
//Usa el método getShape para obtener objetos de tipo Shape
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
Paso 4¶
Usamos la Fábrica(Factory) para obtener los objetos de las clases concretas utilizando algún tipo de información como el tipo
FactoryPatternDemo.java
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//obtenemos un objeto tipo Circle.
Shape shape1 = shapeFactory.getShape("CIRCLE");
//llamamos al método draw de Circle
shape1.draw();
//obtenemos un objeto tipo Rectangle.
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//llamamos al método draw de Rectangle
shape2.draw();
//obtenemos un objeto tipo Square.
Shape shape3 = shapeFactory.getShape("SQUARE");
//llamamos al método draw de circle
shape3.draw();
}
}
Paso 5¶
Verificamos la salida
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Abstract Factory(Fábrica abstracta)¶
Los patrones Abstract Factory trabajan alrededor de una super-fábrica que crea otras fábricas. Esta fábrica también es llamada fábrica de fábricas. Este tipo de diseño cae en la categorÃa de creational patter ya que nos proporciona una de las mejores formas de crear un objeto
En el patrón Abstract Factory una interfaz es la responsable de crear una fábrica de objetos relacionados sin especificarle sus clases. Cada fábrica generada puede proporcionar los objetos de acuerdo con el patrón Factory.
Implementación¶
Vamos a crear las interfaces Shape y Color y las clases concretas que las implementan. Creamos una clase de fábricas abstracta AbstractFactory en el siguiente paso. Definimos las clases Factory ShapeFactory y ColorFactory las cuales extienden Abstractactory. Y creamos una clase constructora/generadora FactoryProducer
AbstractFactoryPatternDemo usa FactoryProducer para obtener uno objeto de tipo AbstractFactory. Le pasará información (CIRCLE / RECTANGLE / SQUARE para Shape) a AbstractFactory para obtener el objeto que necesita. También le pasará información (RED / GREEN / BLUE para Color) a AbstractFactory para obtener el objeto que necesita.
Paso 2¶
Creamos las clases concretas implementando la interfaz.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
Paso 4¶
Creamos las clases concretas que implementan la interfaz.
Red.java
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
Green.java
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
Blue.java
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
Paso 5¶
Creamos una clase abstracta para obtener las fábricas de objetos tipo Color y Shape.
AbstractFactory.java
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}
Paso 6¶
Creamos las clases Factory extendiendo de AbstractFactory para generar objetos de las clases concretas basados en información dada.
ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
}else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
}else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
@Override
Color getColor(String color) {
return null;
}
}
ColorFactory.java
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
}else if(color.equalsIgnoreCase("GREEN")){
return new Green();
}else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}
Paso 7¶
Creamos una clase Fábrica generadora para obtener fábricas pasandole información como Color o Shape
FactoryProducer.java
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
}else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
Paso 8¶
Usamos FactoryProducer para obtener AbstractFactory para obtener fábricas de clases concretas pasandoles información como el tipo
AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//get shape factory
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//get an object of Shape Circle
Shape shape1 = shapeFactory.getShape("CIRCLE");
//call draw method of Shape Circle
shape1.draw();
//get an object of Shape Rectangle
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//call draw method of Shape Rectangle
shape2.draw();
//get an object of Shape Square
Shape shape3 = shapeFactory.getShape("SQUARE");
//call draw method of Shape Square
shape3.draw();
//get color factory
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//get an object of Color Red
Color color1 = colorFactory.getColor("RED");
//call fill method of Red
color1.fill();
//get an object of Color Green
Color color2 = colorFactory.getColor("Green");
//call fill method of Green
color2.fill();
//get an object of Color Blue
Color color3 = colorFactory.getColor("BLUE");
//call fill method of Color Blue
color3.fill();
}
}
Paso 9¶
Verificamos la salida
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.
Composite¶
El patrón Composite es usado cuando necesitamos tratar un grupo de objetos en una manera similar a uno solo. El patrón compone objetos en términos de un árbol partes como la jerarquÃa completa. Este patrón de diseño cabe dentro de la categoria de structural pattern ya que crea una estructura de árbol a partir de un grupo de objetos.
Este patrón crea una clase que contiene grupos de sus mismos objetos. Esta clase proporciona maneras de modificar su grupo de mismos objetos.
Demostraremos el uso de este patrón con el siguiente ejemplo en el cual mostraremos la jerarquÃa de empleados en una organización.
Implementación¶
Tenemos la clase Employee que tiene el rol de la clase actor en el patrón composite. CompositePatternDemo, usará la clase Employee para añadir jerarquÃa entre los departamentos e imprimir todos los empleados.
Paso 1¶
Creamos la clase Employee con una lista de objetos tipo Employee.
Employee.java
import java.util.ArrayList;
import java.util.List;
public class Employee {
private String name;
private String dept;
private int salary;
private List<Employee> subordinates;
// constructor
public Employee(String name,String dept, int sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new ArrayList<Employee>();
}
public void add(Employee e) {
subordinates.add(e);
}
public void remove(Employee e) {
subordinates.remove(e);
}
public List<Employee> getSubordinates(){
return subordinates;
}
public String toString(){
return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary+" ]");
}
}
Paso 2¶
Usamos la clase Employee para crear e imprimir la jerarquÃa de empleados.
CompositePatternDemo
public class CompositePatternDemo {
public static void main(String[] args) {
Employee CEO = new Employee("John","CEO", 30000);
Employee headSales = new Employee("Robert","Head Sales", 20000);
Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
Employee clerk1 = new Employee("Laura","Marketing", 10000);
Employee clerk2 = new Employee("Bob","Marketing", 10000);
Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
CEO.add(headSales);
CEO.add(headMarketing);
headSales.add(salesExecutive1);
headSales.add(salesExecutive2);
headMarketing.add(clerk1);
headMarketing.add(clerk2);
//print all employees of the organization
System.out.println(CEO);
for (Employee headEmployee : CEO.getSubordinates()) {
System.out.println(headEmployee);
for (Employee employee : headEmployee.getSubordinates()) {
System.out.println(employee);
}
}
}
}
Paso 3¶
Verificamos la salida
Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]
State¶
En el patrón el comportamiento de una clase cambia dependiendo de su estado. Este tipo de patrón de diseño es de tipo behavior.
Creamos objetos que representan varios estados y un objeto de contexto cuyo comportamiento varia cuando su objeto de estado varia.
Implementación¶
Vamos a crear la interfaz State definiendo una action y clase concretas implementando State. Context es una clase que contiene un State.
Usaremos Context y objetos de estado para demostrar el cambio de comportamiento en Context basado en el tipo de estado en el que se encuentra.
Paso 1¶
Creamos una interfaz
State.java
public interface State {
public void doAction(Context context);
}
Paso 2¶
Creamos la clases concretas implementando la misma interfaz.
StartState.java
public class StartState implements State {
public void doAction(Context context) {
System.out.println("Player is in start state");
context.setState(this);
}
public String toString(){
return "Start State";
}
}
StopState.java
public class StopState implements State {
public void doAction(Context context) {
System.out.println("Player is in stop state");
context.setState(this);
}
public String toString(){
return "Stop State";
}
}
Paso 3¶
Creamos la clase Context.
Context.java
public class Context {
private State state;
public Context(){
state = null;
}
public void setState(State state){
this.state = state;
}
public State getState(){
return state;
}
}
Paso 4¶
Usa el contexto para ver el cambio de comportamiente cuando State cambias
StatePatternDemo.java
public class StatePatternDemo {
public static void main(String[] args) {
Context context = new Context();
StartState startState = new StartState();
startState.doAction(context);
System.out.println(context.getState().toString());
StopState stopState = new StopState();
stopState.doAction(context);
System.out.println(context.getState().toString());
}
}
MVC¶
GUI (Graphic User Interface)¶
Es una interfaz gráfica que permite la comunicación entre un humano y un sistema
Callbacks, Signals y Slots¶
Los callback son apuntadores a funciones. Asà que si queremos que una función en ejecución nos notifique acerca de algún evento le debemos pasar un apuntador a otra función(callback). La función en ejecución llama al callback cuando se requiera.
Con Signal y Slots una señal(Signal) es emitida cuando un evento en particular ocurre. Un Slot es una función que es llamada en respuesta a una señal determinada.
Una clase que emite una señal no sabe ni le importa quien recibe la señal, ni siquiera le importa si es recibida por alguien.
Qt¶
La instalación depende mucho del sistema operativo. Para windows y linux se recomienda usar la siguiente liga http://download.qt.io/archive/qt/
Instalación¶
La instalación depende mucho del sistema operativo. Para windows y linux se recomienda usar la siguiente liga http://download.qt.io/archive/
Main event loop ó mainloop¶
En escencia no es nada más que un loop infinito que se ve más o menos asÃ:
def main_loop():
while True:
event = wait_for_event()
event.process()
if main_window_has_been_destroyed():
break
GENERAL NOTES¶
- Qt4 and Qt5 developer tools are co-installable thanks to the qtchooser tool. See ‘man qtchooser’ for more information.
PyQt4¶
Introducción¶
PyQt4 es un conjunto de herramientas para crear aplicaciones con interfaz gráfica. Es una mezcla entre Python y la biblioteca Qt. Qt library is one of the most powerful GUI libraries. Es desarrollado por la compañÃa Riverbank Computing Limited.
PyQt4 está implementado como un conjunto de módulos de Python. Cuenta con 440 clases y 6000 funciones. Es un conjunto de herramientas multiplataforma que corre en los sistemas operativos más importantes, incluyendo Unix, Windows, y Mac OS.
Clases¶
Las clases de PyQt4 están divididas en varios módulos:
- QtCore
- QtGui
- QtNetwork
- QtXml
- QtSvg
- QtOpenGL
- QtSql
QtCore¶
Contiene las las funcionalidades principales que no tienen que ver con la interfaz gráfica. Se usa para trabajar con tiempo, archivos y directorios, varios tipos de datos, flujos, urls.
QtGui¶
Contiene los componentes gráficos y sus clases relacionadas. Por ejemplo botones, ventanas, barras de estado, barras de herramienta, deslizadores, mapas de bit, colores y fuentes.
QtNetwork¶
Contiene las clases para programación en redes. Estas clses facilitan la programanción de clientes y servidores de tipo TCP/IP y UDPT haciendo que sea más fácil y más portable nuestor código.
QtXml¶
Contiene clases para trabajar con archivos XML.
QtSvg¶
Nos provee de claes para desplegar contenido de archivos SVG. Scalable Vector Graphics (SVG) es un lenguage para describir gráficos bidimensionales y aplicaciones gráficas en XML.
QtOpenGL¶
Es usado para mostrar gráficos en 3D y 2D usando la biblioteca OpenGL.
QtSql¶
Nos provee de clases para trabajar con bases de datos.
Requisitos¶
Para poder usar PyQt4 se necesitan al menos lo siguiente: - Qt versión 4 - PyQt4 para la versión de python que estén usado
Hola Mundo!¶
import sys
from PyQt4 import QtGui
def main():
app = QtGui.QApplication(sys.argv)
etiqueta_hola = QtGui.QLabel("Hola Mundo!")
etiqueta_hola.show()
return app.exec_()
if __name__ == '__main__':
sys.exit(main())
Surgen algunos pensamientos:
Ejemplo sencillo¶
import sys
from PyQt4 import QtGui
def main():
app = QtGui.QApplication(sys.argv)
widget = QtGui.QWidget()
widget.resize(250, 150)
widget.move(300, 300)
widget.setWindowTitle('Simple')
widget.show()
return app.exec_()
if __name__ == '__main__':
sys.exit(main())
Botones¶
QtGui.QPushButton
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
boton1 = QtGui.QPushButton('Botón1', self)
boton2 = QtGui.QPushButton('Botón2', self)
boton1.move(50, 50)
self.setGeometry(300, 300, 200, 150)
self.setWindowTitle('Boton')
self.show()
def main():
app = QtGui.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
Cerrando una ventana¶
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
boton1 = QtGui.QPushButton('Quit button', self)
boton2 = QtGui.QPushButton('Botón2', self)
boton1.clicked.connect(QtCore.QCoreApplication.instance().quit)
boton1.move(50, 50)
self.setGeometry(300, 300, 200, 150)
self.setWindowTitle('Boton')
self.show()
def main():
app = QtGui.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
Entrada de texto y etiquetas¶
QtGui.QLineEdit
QtGui.QLabel
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.entrada_texto = QtGui.QLineEdit(self)
self.resultado_lbl = QtGui.QLabel('Resultado:', self)
self.entrada_texto.move(0, 0)
self.resultado_lbl.move(0,40)
self.setGeometry(200, 200, 400, 300)
self.setWindowTitle('Mostrar y recibir texto')
self.show()
def main():
app = QtGui.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
Fuentes¶
fuente.setPixelSize(20)
fuente.setUnderline(True)
fuente.setBold(True)
fuente.setItalic(True)
fuente = QtGui.QFont()
fuente.setPixelSize(20)
QLabel("Hola").setFont(fuente)
etiqueta = QLabel("Hola")
fuente = etiqueta.font()
fuente.setPixelSize(20)
fuente.setFamily("Courier New")
etiqueta.setFont(fuente)
Layouts¶
Posición absoluta¶
Se espicifica a mano la posición y el tamaño de cada widget en pixeles. Cuando usamos posición absoluta debemos tener en cuenta las siguientes limitaciones:
- El tamaño y posición del widget no cambia si cambiamos el tamaño de la ventana.
- La aplicación puede cambiar de apariencia dependiendo de la plataforma
- Cmabiar la fuente la aplicación puede echar a perder la disposición de los elementos
widget.move(x, y)
widget.setGeomtry(x, y, anchura, altura)
Box layout¶
QtGui.QVBoxLayout y QtGui.QHBoxLayout¶
import sys
from PyQt4 iport QtGui
class Ejemplo(QtGui.QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
boton_ok = QtGui.QPushButton("OK")
boton_cancelar = QtGui.QPushButton("Cancelar")
fuente = QtGui.QFont()
fuente.setPixelSize(40)
boton_ok.setFont(fuente)
hbox = QtGui.QHBoxLayout()
hbox.addWidget(boton_ok)
hbox.addStretch(1)
hbox.addWidget(boton_cancelar)
vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Buttons')
self.show()
def main():
app = QtGui.QApplication(sys.argv)
ex = Ejemplo()
sys.exit(app.exec_())
QtGui.QGridLayout¶
grid = QtGui.QGridLayout()
self.setLayout(grid)
grid.addWidget(widget, fila, columna)
Cosas importantes sobre los layouts y los padres:
- Cuando se usen layouts, no se necesita pasar el padre como parámetro al construir un widget. El layout va a asignarle como padre(usando QWidget.setParent()) el widget al que pertenece.
- Los Widgets en un layout son hijos del widget al que pertenece el layout, no son hijos del layout. Los widgets sólo pueden tener como padres otros widgets, no layouts.
- Se pueden anidar layous usando addLayout() en un layout. El layout interior se vuelve hijo del layout en el que fue insertado.
Signals y Slots¶
Para que una clase pueda contener Signals y Slots debe de heredar de QObject o una de sus subclases. Cuando se emite una señal los slots conectados a esta usualmente se ejecutan inmediatamente, como si se hubiera mandado a llamar a cada una en vez de emitir la señal.
La ejecución del código que sigue a la emisión de una señal se realiza después de que todos los slots hayan hecho su return, es decir al emitir una señal esta bloquea la ejecución del método hasta que las funciones que estén escuchando esta señal hayan terminado de ejecutarse.
Si muchos slots están conectados a la misma señal se ejecutaran en el orden en el que fueron conectadas.
mi_senial = QtCore.pyqtSignal(int, str)
mi_senial.emit()
mi_senial.connect(objeto.funcion)
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
mi_senial = QtCore.pyqtSignal(Objeto)
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.entrada_texto = QtGui.QLineEdit(self)
self.resultado_lbl = QtGui.QLabel('Resultado:', self)
self.entrada_texto.move(0, 0)
self.resultado_lbl.move(0,40)
self.entrada_texto.textChanged.connect(self.calcula_suma)
self.setGeometry(200, 200, 200, 150)
self.setWindowTitle('Boton')
self.show()
def calcula_suma(self, entrada):
resultado = "Error"
print(entrada)
try:
resultado = "Resultado: " + str(eval(entrada))
except Exception as e:
print(e)
self.resultado_lbl.setText(resultado)
self.resultado_lbl.adjustSize()
def main():
app = QtGui.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
import sys
from PyQt4 import QtGui, QtCore
class Objeto:
val = 99
class Ejemplo(QtGui.QWidget):
mi_senial = QtCore.pyqtSignal(Objeto)
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
boton_ok = QtGui.QPushButton("OK")
boton_cancelar = QtGui.QPushButton("Cancelar")
fuente = QtGui.QFont()
fuente.setPixelSize(40)
boton_ok.setFont(fuente)
hbox = QtGui.QHBoxLayout()
hbox.addWidget(boton_ok,0)
hbox.addStretch(1)
hbox.addWidget(boton_cancelar)
vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
boton_ok.clicked.connect(self.emite)
self.mi_senial.connect(self.procesa_senial)
self.algo = Objeto()
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Buttons')
self.show()
def emite(self):
self.mi_senial.emit(self.algo)
def procesa_senial(self, algo):
print(algo, type(algo), algo.val)
def main():
app = QtGui.QApplication(sys.argv)
ex = Ejemplo()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
Ejemplo más complicado¶
Recomendaciones¶
- Recuerda que PyQt4 usa Qt4 por lo que si la documentación de PyQt4 no te satisface puedes ir a la documentación de Qt4
- Salvo tu Widget principal intenta que todos los widgets que construyas tengan un padre para evitar errores
[1] | QtGui.Application.exec_ |
[2] | main event loop |
[3] | QWidget PyQt |
[4] | QWidget Qt |
QML¶
Elementos¶
Lista extensiva de los elementos de QML
import sys
from PyQt4.QtCore import QUrl
from PyQt4.QtGui import QApplication
from PyQt4.QtDeclarative import QDeclarativeView
# Creamos una aplicación Qt y una vista QDeclarative
app = QApplication(sys.argv)
view = QDeclarativeView()
# Create an URL to the QML file
url = QUrl('calculadora.qml')
# Set the QML file and show
view.setSource(url)
view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
view.setGeometry(100, 100, 400, 300)
view.show()
# Enter Qt main loop
sys.exit(app.exec_())
Hola mundo¶
Vamos a crear el tradicional Hello World!
import QtQuick 1.0
Rectangle {
id: page
width: 500; height: 200
color: "lightgray"
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
}
Explicación¶
Import¶
Necesitamos importar los tipos que necesitamos para el ejemplo. La mayorÃa de los archivos QML suelen hacer el import de los tipos que vienen por defecto en Qt(Rectangle, Image, ...) usando:
import QtQuick 1.0
Rectangle¶
Rectangle {
id: page
width: 500; height: 200
color: "lightgray"
Declaramos el elemento raÃz del tipo Rectangle. Es uno de los bloques de construcción válidos que puedes usar para crear aplicaciones en QML. Le damps un id para que podamos refirirnos a él más tarde. En este caso lo nombramos “page”. También le añadimos un ancho, alto y prodiedades de sus colores. El Rectangle contiene muchas más propiedades (como ‘x’ y ‘y’), pero estos se dejan con sus valores por defecto.
Text¶
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
Añadimos un elemento Text como hijo del elemento raÃz Rectangle y despliega el texto ‘Hello world!’.
La propiedad y es usada para posicionar el texto verticalmente a 30 pixeles del tope de su padre.
La propiedad anchors.horizontalCenter se refiere al centro horizontal de un elemento. En este caso especificamos que nuestro elemento de texto debe de estar centrado horizontalmente con respecto al elemento page (Layouts basadas en anclas).
Las propiedades font.pointSize y font.bold están relacionadas con las fuentes y usan la notación de punto.
Eco¶
import QtQuick 1.0
Rectangle {
id: page
width: 500; height: 200
color: "lightgray"
Text {
id: texto
text: input.text
anchors.top: parent.top
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
Rectangle{
id: rect_input
color: "white"
anchors.top: texto.bottom
anchors.bottom: parent.bottom
anchors.left: parent.left
anchors.right: parent.right
TextInput{
anchors.fill: parent
id: input
focus: true
}
}
}
Componentes¶
Vamos a crear un programa para cambiar el color de un texto.
import QtQuick 1.0
Item {
id: container
property alias cellColor: rectangle.color
signal clicked(color cellColor)
width: 40; height: 25
Rectangle {
id: rectangle
border.color: "white"
anchors.fill: parent
}
MouseArea {
anchors.fill: parent
onClicked: container.clicked(container.cellColor)
}
}
Calculadora¶
import QtQuick 1.0
Item {
id: boton
property alias texto: boton_texto.text
signal clicked(string algo)
width: 60; height: 60
Rectangle {
id: rectangle
color: "#aaf"
anchors.fill: parent
smooth: true
radius: 30
Text {
id: boton_texto
text : ""
anchors.centerIn: parent
font.pixelSize: 40
}
}
MouseArea {
anchors.fill: parent
onClicked: boton.clicked(boton.texto)
}
}
import QtQuick 1.0
Rectangle {
id: ventana
signal calcula_resultado(string cadena)
property string name: pantalla.text
onNameChanged: console.log("Name has changed to:", name)
color: "lightgray"
anchors.fill: parent
function muestra_resultado(text) {
pantalla.text = text
}
Rectangle{
id: rect_input
height: 40
color: "black"
anchors.top: parent.top
anchors.left: parent.left
anchors.right: parent.right
Text{
id: pantalla
anchors.centerIn: parent
focus: true
color: "#ccc"
font.pixelSize : 40
}
}
Grid {
id: botones
anchors.top: rect_input.bottom
anchors.bottom: parent.bottom
anchors.horizontalCenter: parent.horizontalCenter
rows: 4; columns: 4; spacing: 3
Boton { texto: "1"; onClicked: pantalla.text += texto }
Boton { texto: "2"; onClicked: pantalla.text += texto }
Boton { texto: "3"; onClicked: pantalla.text += texto }
Boton { texto: "+"; onClicked: pantalla.text += texto }
Boton { texto: "4"; onClicked: pantalla.text += texto }
Boton { texto: "5"; onClicked: pantalla.text += texto }
Boton { texto: "6"; onClicked: pantalla.text += texto }
Boton { texto: "-"; onClicked: pantalla.text += texto }
Boton { texto: "7"; onClicked: pantalla.text += texto }
Boton { texto: "8"; onClicked: pantalla.text += texto }
Boton { texto: "9"; onClicked: pantalla.text += texto }
Boton { texto: "*"; onClicked: pantalla.text += texto }
Boton { texto: "0"; onClicked: pantalla.text += texto }
Boton { texto: "clr"; onClicked: pantalla.text = "" }
Boton { texto: "="; onClicked: ventana.calcula_resultado(pantalla.text) }
Boton { texto: "/"; onClicked: pantalla.text += texto }
}
}
import sys
from PyQt4.QtCore import QUrl, QObject, pyqtSignal
from PyQt4.QtGui import QApplication
from PyQt4.QtDeclarative import QDeclarativeView
class Evaluador(QObject):
evaluado = pyqtSignal(str)
def evalua(self, expresion):
resultado = "Error"
try:
resultado = str(eval(expresion))
except Exception:
print("'" + expresion + "'")
self.evaluado.emit(resultado)
evaluador = Evaluador()
# Create Qt application and the QDeclarative view
app = QApplication(sys.argv)
view = QDeclarativeView()
# Create an URL to the QML file
url = QUrl('calculadora.qml')
# Set the QML file and show
view.setSource(url)
view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
view.setGeometry(100, 100, 400, 300)
rootObject = view.rootObject()
evaluador.evaluado.connect(rootObject.muestra_resultado)
rootObject.calcula_resultado.connect(evaluador.evalua)
view.show()
# Enter Qt main loop
sys.exit(app.exec_())