Python Aplicaciones prácticas

Introducción

Python es un lenguaje de programación de propósito general creado por Guido Van Rosum en los 90 trabajo en Google y en la actualidad en Dropbox, su nombre proviene del cómic Monty Python. Cuenta con una sintaxis muy limpia y legible. Posee tipado dinámico esto quiere decir que una variable puede poseer datos de varios tipos, junto con su naturaleza interpretada, hacen de este un lenguaje para ser el primer en aprender. Python es un lenguaje interpretado, lo que nos indica que no se necesita compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas.

Python está escrito en el lenguaje C, por lo que se puede extender a través de su api en C o C++ y escribir nuevos tipos de datos, funciones, etc. En la actualidad hay dos vertientes la versión 2.x y 3.x, al final llegara el momento que se integraran estas dos versiones, es recomendable utilizar la última versión estable 3.x Algunas de las características más importantes es que Python es multiparadigma: Programación estructurada, Programación Orientada a Objetos y Programación Funcional.

Python en el desarrollo web se puede utilizar los framework: Django y Flask. Entre las empresas más conocidas que utilizan Python tenemos: Dropbox y Instagram.

En Data Sciencia y Machine Learning tenemos: Pandas, Scikit-Learn y TensorFlow. Además, es multiplataforma: Linux, Windows, Mac OS, Solaris, etc.

Python permite ser implementado en diferentes lenguajes:

CPython - Python tradicional escrito en C.

Jython - Python para la JVM.

IronPython - Python para .NET.

Pypy - Python más rápido con compilador JIT.

StacklessPython - Branch de CPython con soporte para microthreads.

A continuación, un listado de los lenguajes más populares:

Fuente: http://pypl.github.io/PYPL.html

Este libro te introduce de manera fácil los conceptos y características básicas, intermedias y avanzadas del lenguaje de Python. Es bueno tener un intérprete de Python a mano para experimentar.

1

Kivy

QuÉ es Kivy

Kivy es una librería open source para el desarrollo rápido de aplicaciones equipadas con novedosas interfaces de usuario, como aplicaciones multitáctiles.

Filosofía

A continuación, describiremos que es Kivy y de qué se trata:

Fresh.- Kivy está hecho para el presente y futuro. Los nuevos métodos de entrada como Multi-Touch se han vuelto cada vez más importantes para la interacción.

Fast.- Kivy es rápido. Esto se aplica tanto al desarrollo de la aplicación como a la velocidad de ejecución de la misma. Hemos optimizado Kivy ha sido optimizado de muchas maneras:

Implementamos funcionalidad de tiempo crítico en el nivel C para aprovechar el poder de los compiladores existentes. Más importante aún, también utilizamos algoritmos inteligentes para minimizar los costos.

También usamos la GPU donde tiene sentido en nuestro contexto. El poder computacional de las tarjetas gráficas de hoy en día supera a la de las CPU de hoy en día para algunas tareas y algoritmos, especialmente el dibujo. Es por eso que tratamos de dejar que la GPU haga la mayor parte del trabajo posible, aumentando así rendimiento considerablemente.

Flexible.- Kivy es flexible. Esto significa que se puede ejecutar en una variedad de dispositivos diferentes, incluido Android.

Teléfonos inteligentes y tabletas. Admitimos todos los principales sistemas operativos (Windows, Linux, OS X). Siendo flexible.

También significa que el rápido desarrollo de Kivy le permite adaptarse rápidamente a las nuevas tecnologías. Más que una vez hemos agregado soporte para nuevos dispositivos externos y protocolos de software, a veces incluso antes fueron liberados.

Focused.- Kivy está enfocado. Puede escribir una aplicación simple con algunas líneas de código. Se crean los programas Kivy utilizando el lenguaje de programación Python, que es increíblemente versátil y potente, pero fácil de usar.

Funded.- Kivy es una solución con influencia de la comunidad, desarrollada profesionalmente y con respaldo comercial.

Free.- Kivy es free o uso gratuito.

Instalación de Kivy en Windows

Para utilizar Kivy, Necesitamos tener instalado previamente Python.

En línea de comando escriba lo siguiente:

Asegúrese la última versión de: pip y wheel:

python -m pip install --upgrade pip wheel setuptools

Instale las dependencias:

python -m pip install docutils pygments

pypiwin32 kivy.deps.sdl2 kivy.deps.glew

python -m pip install kivy.deps.gstreamer

Para Python 3.5, ofrecemos angle que se puede usar en lugar de glew y se puede instalar con:

python -m pip install kivy.deps.angle

Instalación de kivy:

python -m pip install kivy

Opcionalmente, Instalación de Ejemplos:

python -m pip install kivy_examples

Instalación de Kivy en OS X

Usando Homebrew.

Requisitos usando homebrew:

$ brew install pkg-config sdl2 sdl2_image sdl2_ttf sdl2_mixer gstreamer

Instalando con Cython y Kivy usando pip:

$ pip install Cython==0.26.1

$ pip install kivy

Para instalar la versión de desarrollo:

$ pip install https://github.com/kivy/kivy/archive/master.zip

Instalación en Linux

Para instalar paquetes relativos de distribución .deb/.rpm/…

Agregar uno de los PPA.

Actualice su lista de paquetes.

$ sudo apt-get update

Instalar Kivy.

Python2 - python-kivy:

$ sudo apt-get install python-kivy

Python3 - python3-kivy:

$ sudo apt-get install python3-kivy

Opcionalmente los ejemplos:

$ sudo apt-get install python-kivy-examples

Debian (Jessie or Newer)

Agregue uno de los PPA a tus fuentes apt manual o con mediante Synaptic.

Agregue la clave GPG a su apt keyring ejecutando.

as user:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys A863D2D6

as root:

apt-key adv --keyserver keyserver.ubuntu.com --recv-keys A863D2D6

Linux Mint

Ubica tu versión de Ubuntu en el cual está basada tu instalación.

Continua con tu instalación.

Bodhi Linux

Ubica tu versión de distribución que está ejecutando y use la tabla a continuación:

OpenSuSE

Para instalar kivy vaya la a url http://software.opensuse.org/package/python-Kivy.

Si deseas acceder a los ejemplos selecciones python-Kivy-examples.

Fedora

Agregue al repositorio a través del terminal:

Fedora 18

$ sudo yum-config-manager  --add-repo=http://download.opensuse.org\

/repositories/home:/thopiekar:/kivy/Fedora_18/home:thopiekar:kivy.repo

Fedora 17

$ sudo yum-config-manager --add-repo=http://download.opensuse.org\

/repositories/home:/thopiekar:/kivy/Fedora_17/home:thopiekar:kivy.repo

Fedora 16

$ sudo yum-config-manager --add-repo=http://download.opensuse.org\

/repositories/home:/thopiekar:/kivy/Fedora_16/home:thopiekar:kivy.repo

Ciclo de Vida de una Aplicación KIVY

Mi Primera Aplicación

Ahora vamos a crear el famoso HOLA MUNDO:

HolaMundo.py

import kivy

kivy.require(‘1.10.0’)

from kivy.app import App

from kivy.uix.button import Label

class MiAplicacion (App):

    def build(self):

        return Label(text=’Hola Mundo’)

if __name__ == __main__:

    MiAplicacion ().run()

Al ejecutarse:

A continuación, explicaremos el código línea a línea:

Indicamos la versión de Kivy.

import kivy

kivy.require(‘1.10.0’)

Importamos la clase base de tu App desde app:

from kivy.app import App

El uix.button es la sección que contiene los elementos de la interfaz de usuario, como diseños y widgets que se desea mostrar.

from kivy.uix.button import Label

Aquí es donde estamos definiendo la clase base de nuestra aplicación Kivy. Solo deberías necesitar cambiar el nombre de su aplicación MyApp en esta línea:

class MiAplicacion(App):

Función que inicializa y retorna el widget.

def build(self):

    return Label(text=’Hola Mundo’)

La clase MyApp se inicializa y se llama a su método run (). Esto inicializa y comienza nuestro Kivy:

if __name__ == __main__:

    MiAplicacion().run()

Widgets Básicos

Un widget es el componente básico de las interfaces en Kivy. Una interfaz de usuario generalmente tiene muchos elementos, como cuadros de texto de entrada, etiquetas, listas desplegables, botones, botones de radio, etc. Estos elementos se denominan widgets en Kivy.

Un widget está representado por una subclase de la kivy.uix.widget.Widget clase.

Un widget puede tener propiedades como id, color, texto, tamaño de fuente, etc.

Un widget puede desencadenar algunos eventos como:

touch down

touch move

touch up

A continuación, mostraremos el código kivy describiendo algunos widgets básicos:

El nombre de la clase Label y sus propiedades en minúscula.

El nombre de la clase TextInput y sus propiedades en minúscula.

El nombre de la clase Button y sus propiedades en minúscula.

La clase Button tiene dos eventos adicionales: on_press similar a on_touch_down y on_release on_touch_down.

MÓdulo - FileChooser

El módulo FileChooser proporciona varias clases para describir, visualizar y examinar archivos.

Contenedores

Un contenedor es donde colocamos los elementos de una aplicación o sitio web, los contenedores no ayudaran en el ordenamiento adecuado de los elementos que una aplicación puede contener gráficamente.

Kivy cuenta con muchos contenedores con características diferentes. Entre los que tenemos:

FloatLayout

Gridlayout

Boxlayout

Stacklayout

Relavitelayout

Anchorlayout

Floatlayout

Este es uno de los contenedores más utilizados, gracias a la gran ventaja que tenemos de poner elementos en el lugar que más nos guste. Ejemplo:

FloatLayout1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.floatlayout import FloatLayout

Builder.load_string(‘’’

:

    Button:

        font_size: 40

        text: ‘Uno’

        size_hint: 0.1, 0.1

        pos_hint: {x: 0, ‘y’:0}

    Button:

        font_size: 40

        text: ‘Dos’

        size_hint: 0.2, 0.2

        pos_hint: {x: 0.07, ‘y’:0.07}

    Button:

        font_size: 40

        text: ‘Tres’

        size_hint: 0.3, 0.3

        pos_hint: {x: 0.18, ‘y’:0.18}

    Button:

        font_size: 40

        text: ‘Cuatro’

        size_hint: 0.4, 0.4

        pos_hint: {x: 0.4, ‘y’:0.35}

    Button:

        font_size: 40

        text: ‘Cinco’

        size_hint: 0.5, 0.5

        pos_hint: {x: 0.6, ‘y’:0.6}

‘’’)

class Flotante(FloatLayout):

    pass

class DemoApp(App):

    def build(self):

        return Flotante()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

Gridlayout

Para utilizar este layout tenemos que definir por lo menos su dimensión, si queremos que tenga una columna o más de igual forma que las filas, puedes ver este layout como una hoja de cálculo donde cada elemento toma su lugar de acuerdo al orden que los agregues, por ejemplo:

Gridlayout 1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.gridlayout import GridLayout

Builder.load_string(‘’’

:

    cols:3

    rows:3

    Button:

        font_size: 40

        text: ‘Uno’

    Button:

        font_size: 40

        text: ‘Dos’

    Button:

        font_size: 40

        text: ‘Tres’

    Button:

        font_size: 40

        text: ‘Cuatro’

    Button:

        font_size: 40

        text: ‘Cinco’

    Button:

        font_size: 40

        text: ‘Seis’

‘’’)

class Grid(GridLayout):

    pass

class DemoApp(App):

    def build(self):

        return Grid()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

Boxlayout

En este layout puedes agregar varios elementos los cuales se ordenan dependiendo del tamaño de cada elemento dentro del mismo.

Por ejemplo:

Boxlayout1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.boxlayout import BoxLayout

Builder.load_string(‘’’

:

    orientation: ‘vertical’

    padding: 20

    BoxLayout:

        Button:

            text: Primera Fila, Primera Columna

            bold: True

        Button:

            text: Primera Fila, Segunda Columna

            color: [1, 0, 0, 1]

            bold: True

    BoxLayout:

        Button:

            text: Segunda Fila, Primera Columna

            color: [0, 0, 1, 1]

            bold: True

        Button:

            text: Segunda Fila, Segunda Columna

            color: [1, 1, 0, 1]

            bold: True

‘’’)

class Caja(BoxLayout):

    pass

class DemoApp(App):

    def build(self):

        return Caja()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

Stacklayout

En este layout podemos agregar varios elementos cada elemento se acomoda dependiendo de su tamaño del espacio que el Stacklayout tenga para utilizar. Nos seria de mucha utilidad si queremos agregar varios elementos y deseamos que tengan el mismo tamaño. El layout le define el espacio a cada elemento dependiendo del espacio total que el layout tenga disponible.

Ejemplo:

Stacklayout 1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.boxlayout import BoxLayout

Builder.load_string(‘’’

:

    StackLayout:

        spacing: 5

        padding: 5

        orientation: ‘tb-rl’

        Button:

            text: boton1

            size_hint: 0.15, 0.15

        Button:

            text: boton2

            size_hint: 0.25, 0.25

        Button:

            text: boton3

            size_hint: 0.35, 0.35

‘’’)

class Caja(BoxLayout):

    pass

class DemoApp(App):

    def build(self):

        return Caja()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

Relativelayout

Es muy similar al Floatlayout, solo que este caso cada elemento se acomoda de acuerdo a la posición del layout. Ejemplo:

Stacklayout 1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.boxlayout import BoxLayout

Builder.load_string(‘’’

:

    StackLayout:

        spacing: 5

        padding: 5

        orientation: ‘tb-rl’

        Button:

            text: boton1

            size_hint: 0.15, 0.15

        Button:

            text: boton2

            size_hint: 0.25, 0.25

        Button:

            text: boton3

            size_hint: 0.35, 0.35

‘’’)

class Caja(BoxLayout):

    pass

class DemoApp(App):

    def build(self):

        return Caja()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

AnchorLayout

Este layout nos permite agregar elementos basándonos en los bordes del mismo. Ejemplo:

AnchorLayout 1.py

from kivy.app import App

from kivy.lang import Builder

from kivy.uix.boxlayout import BoxLayout

Builder.load_string(‘’’

:

    anchor_x: ‘right’

    anchor_y: ‘bottom’

    Button:

        id: label1

        size_hint: 1, 1

        text: ‘Boton1’

    Button:

        id: label2

        size_hint: 0.6, 0.6

        text: ‘Boton2’

    Button:

        id: label3

        size_hint: 0.3, 0.3

        text: ‘Boton3’

    Button:

        id: label4

        size_hint: 0.1, 0.1

        text: ‘Boton4’

‘’’)

Window.size = (800, 600)

class Caja(AnchorLayout):

    pass

class DemoApp(App):

    def build(self):

        return Caja()

if __name__ == ‘__main__’:

    DemoApp().run()

Al ejecutarse:

Personalizando mI Etiqueta

A continuación, mostramos una Aplicación que muestre múltiples líneas de texto:

TextoLargo.py

import kivy

kivy.require('1.10.0')

from kivy.app import App

from kivy.uix.button import Label

texto_largo = (Python es un lenguaje de programación de propósito general\n

"creado por Guido Van Rosum en los 90 trabajos en Google \ny en la actualidad

en Dropbox"

su nombre proviene del cómic Monty Python.\n

Python está escrito en el lenguaje C \n

por lo que se puede extender a través de su api en C o C++\n

"y escribir nuevos tipos de datos, funciones,