Categorías
Python

Generación de datos aleatorios en Python

 

Tabla de Contenidos

  • comprender el marco Kivy
  • Instalación Kivy
  • Trabajar con Kivy WidgetsRunning un “Hola, Kivy!” ProgramDisplaying una imagen
  • Ejecución de un “Hola, Kivy!” Programa
  • mostrar una imagen
  • Fotomontaje de la interfaz de usuario
  • Adición de Eventos
  • Uso del KV Idioma
  • Creación de una
  • Aplicación Kivy Embalaje Su aplicación para Android
  • Embalaje Su aplicación para iOS
  • Embalaje Su aplicación para Windows
  • Embalaje Su aplicación para macOS
  • Conclusión
  • lectura adicional
  • Ejecución de un “Hola, Kivy!” Programa
  • mostrar una imagen

En estos días, los desarrolladores son altamente propensos a estar trabajando en una aplicación móvil o en la web. Python no se han incorporado en la capacidad de desarrollo de móviles, pero hay paquetes que puede utilizar para crear aplicaciones móviles, como Kivy, PyQt, o biblioteca de Toga incluso Beeware.

Estas bibliotecas son los principales actores en el espacio móvil Python. Sin embargo, hay algunos beneficios que usted verá si decide crear aplicaciones móviles con Kivy . No sólo su aplicación tienen el mismo aspecto en todas las plataformas, sino que también no tendrá que compilar el código después de cada cambio. Lo que es más, usted será capaz de utilizar una sintaxis clara de Python para construir sus aplicaciones.

En este tutorial, aprenderá a:

  • Trabaja con Kivy widgets de
  • diseñar la interfaz de usuario
  • añadir eventos
  • uso del idioma KV
  • Crear una aplicación de calculadora
  • paquete para su aplicación iOS, Android, Windows y macOS

Este tutorial asume que está familiarizado con la programación orientada a objetos. Si no es así, entonces echa un vistazo Programación orientada a objetos (POO) en Python 3. get de

Vamos a comenzar! Bono

gratuito: Haga clic aquí para obtener acceso a un capítulo de trucos Python: El libro que te muestra las mejores prácticas de Python con ejemplos sencillos puede aplicar instantáneamente a escribir código más bonito + Pythonic.

comprender el marco Kivy

Kivy fue lanzado por primera vez a principios de 2011. Este multiplataforma marco de Python se puede implementar en Windows, Mac, Linux y Frambuesa Pi. Es compatible con los eventos multitouch, además de entradas de teclado y ratón normal. Kivy incluso soporta la aceleración de GPU de sus gráficos, ya que están construidos usando OpenGL ES2. El proyecto utiliza la licencia MIT, por lo que puede utilizar esta biblioteca para el software libre y comercial.

Cuando se crea una aplicación con Kivy, que está creando una interfaz natural o NUI usuario. La idea detrás de una interfaz de usuario natural es que el usuario puede aprender fácilmente cómo utilizar su software con poca o ninguna instrucción.

Kivy no intenta usar controles o widgets nativos. Todos sus widgets personalizados están tirados. Esto significa que las aplicaciones Kivy se verá igual en todas las plataformas. Sin embargo, esto también significa que el aspecto de su aplicación y el tacto serán diferentes de las aplicaciones nativas de su usuario. Esto podría ser una ventaja o una desventaja, dependiendo de su audiencia.

Instalación Kivy

Kivy tiene muchas dependencias, por lo que se recomienda instalar en un entorno virtual de Python. Puede utilizar cualquiera de Python biblioteca incorporada Venv o el paquete virtualenv. Si usted nunca ha usado un entorno virtual de Python antes, entonces echa un vistazo a Python entornos virtuales: Una cartilla.

Así es como se puede crear un entorno virtual de Python:

$ python3 -m venv my_kivy_project

Esto copia el ejecutable de Python 3 en una carpeta llamada my_kivy_project y añadir algunas otras subcarpetas a ese directorio.

Para utilizar el entorno virtual, es necesario activarlo. En Mac y Linux, que puede hacer que al ejecutar el siguiente mientras que dentro de la carpeta my_kivy_project:

$ source bin/activate

El sistema de Windows es similar, pero la ubicación de la secuencia de comandos de activación está dentro de la carpeta scripts en lugar de bin.

Ahora que tiene un entorno virtual de Python activado, puede ejecutar pip para instalar Kivy. En Linux y Mac, se encontrará con el siguiente comando:

$ python -m pip install kivy

En Windows, la instalación es un poco más complejo. Echa un vistazo a la documentación oficial para saber cómo instalar Kivy en Windows. (Los usuarios de Mac también pueden descargar un archivo dmg e instalar Kivy de esa manera.)

Si surge algún problema al instalar Kivy en su plataforma, y ​​luego ver la página de descarga Kivy para obtener instrucciones adicionales.

de Trabajo Con Kivy Reproductores

A widget de es un control en pantalla que el usuario va a interactuar con. Todos los kits de herramientas de interfaz gráfica de usuario vienen con un conjunto de widget de s. Algunos común widget de s que puede haber utilizado incluyen botones, cuadros combinados, y las pestañas. Kivy tiene muchas widget de s integrado en su marco.

Ejecución de un “Hola, Kivy!” Programa

Para ver cómo funciona Kivy, echar un vistazo a la siguiente “Hola, mundo!” aplicación: aplicación

from kivy.app import App
from kivy.uix.label import Label

class MainApp(App):
def build(self):
label = Label(text='Hello from Kivy',
size_hint=(.5, .5),
pos_hint={'center_x': .5, 'center_y': .5})

return label

if __name__ == '__main__':
app = MainApp()
app.run()

Cada Kivy necesita subclase App y acumulación de anulación (). Aquí es donde se va a poner su código de interfaz de usuario o realizar llamadas a otras funciones que definen el código de interfaz de usuario. En este caso, se crea un widget de etiquetas y pasar en su texto, size_hint y pos_hint. No se requieren estos dos últimos argumentos.

size_hint dice Kivy las proporciones de uso al crear el widget. Se necesitan dos números:

Ambos de estos números pueden estar en cualquier lugar entre 0 y 1. El valor por defecto para ambas pistas es 1. También puede utilizar pos_hint para posicionar el widget. En el bloque de código anterior, le dice Kivy para centrar el widget en los ejes x e y.

Para hacer que la aplicación se ejecute, se instancia la clase MainApp y luego llamar a run (). Cuando lo hace, debería ver lo siguiente en la pantalla:

Kivy también da salida a una gran cantidad de texto a la salida estándar:

[INFO ] [Logger ] Record log in /home/mdriscoll/.kivy/logs/kivy_19-06-07_2.txt
[INFO ] [Kivy ] v1.11.0
[INFO ] [Kivy ] Installed at "/home/mdriscoll/codeest/lib/python3.6/site-packages/kivy/__init__.py"
[INFO ] [Python ] v3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0]
[INFO ] [Python ] Interpreter at "/home/mdriscoll/codeest/bin/python"
[INFO ] [Factory ] 184 symbols loaded
[INFO ] [Image ] Providers: img_tex, img_dds, img_sdl2, img_gif (img_pil, img_ffpyplayer ignored)
[INFO ] [Text ] Provider: sdl2(['text_pango'] ignored)
[INFO ] [Window ] Provider: sdl2(['window_egl_rpi'] ignored)
[INFO ] [GL ] Using the "OpenGL" graphics system
[INFO ] [GL ] Backend used
[INFO ] [GL ] OpenGL version
[INFO ] [GL ] OpenGL vendor
[INFO ] [GL ] OpenGL renderer
[INFO ] [GL ] OpenGL parsed version: 4, 6
[INFO ] [GL ] Shading version
[INFO ] [GL ] Texture max size <16384>
[INFO ] [GL ] Texture max units <32>
[INFO ] [Window ] auto add sdl2 input provider
[INFO ] [Window ] virtual keyboard not allowed, single mode, not docked
[INFO ] [Base ] Start application main loop
[INFO ] [GL ] NPOT texture support is available

Esto es útil para la depuración de la aplicación.

A continuación, se va a tratar de añadir un widget de imagen y ver en qué se diferencia de una etiqueta.

mostrar una imagen

Kivy tiene un par de diferentes widgets relacionados con la imagen para elegir. Puede usar la imagen para cargar las imágenes locales de su disco duro o AsyncImage para cargar una imagen desde una URL. Para este ejemplo, usted se pega con la clase de imagen estándar:

from kivy.app import App
from kivy.uix.image import Image

class MainApp(App):
def build(self):
img = Image(source='/patho/real_python.png',
size_hint=(1, .5),
pos_hint={'center_x':.5, 'center_y':.5})

return img

if __name__ == '__main__':
app = MainApp()
app.run()

En este código, importa una imagen de la kivy.uix.image sub-paquete. La clase de la imagen tiene un montón de diferentes parámetros, pero el que desea utilizar es de código. Esto le dice a Kivy qué imagen se cargue. A continuación, se pasa una ruta completa a la imagen. El resto del código es lo mismo que lo que ha visto en el ejemplo anterior.

Cuando se ejecuta este código, se verá algo como lo siguiente:

El texto del ejemplo anterior se ha sustituido por una imagen.

Ahora usted aprenderá cómo agregar y organizar varios controles de su aplicación.

Fotomontaje de la interfaz de usuario

Cada marco de interfaz gráfica de usuario que utilice tiene su propio método de disponer widgets. Por ejemplo, en wxPython que va a utilizar medidores, mientras que en Tkinter se utiliza un controlador de distribución o la geometría. Con Kivy, va a utilizar Presentaciones . Hay varios tipos diferentes de diseños de que se pueden utilizar. Éstos son algunos de los más comunes los:

  • BoxLayout
  • FloatLayout
  • GridLayout

Puede buscar en la documentación del Kivy para una lista completa de los diseños disponibles. También puede buscar en kivy.uix para el código fuente real.

Pruebe la BoxLayout con este código:

import kivy
import random

from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.boxlayout import BoxLayout

red = [1,0,0,1]
green = [0,1,0,1]
blue = [0,0,1,1]
purple = [1,0,1,1]

class HBoxLayoutExample(App):
def build(self):
layout = BoxLayout(padding=10)
colors = [red, green, blue, purple]

for i in range(5):
btn = Button(text="Button #%s" % (i+1),
background_color=random.choice(colors)
)

layout.add_widget(btn)
return layout

if __name__ == "__main__":
app = HBoxLayoutExample()
app.run()

Aquí, se importan desde BoxLayout kivy.uix.boxlayout y instanciarlo. A continuación, se crea una lista de colores, los cuales son a su vez las listas de colores rojo-verde-azul (RGB). Finalmente, se reproduce en un rango de 5, creando un BTN botón para cada iteración. Para hacer las cosas un poco más divertido, se establece la background_color del botón para un color aleatorio. A continuación, agrega el botón a su diseño con layout.add_widget (BTN).

Cuando se ejecuta este código, se verá algo como esto:

Hay 5 botones de colores al azar, uno para cada iteración del bucle.

Cuando se crea un diseño, hay algunos argumentos que usted debe saber: el acolchado

  • : Puede especificar el relleno en píxeles entre el diseño y sus hijos en una de tres maneras: Una lista de cuatro argumento: [padding_left, padding_top, padding_right, padding_bottom] Una lista de dos argumentos: [padding_horizontal, padding_vertical] Un argumento singular: relleno = 10
  • Una lista de cuatro argumento: [padding_left, padding_top, padding_right, padding_bottom]
  • Una lista de dos argumentos: [ padding_horizontal, padding_vertical]
  • Un argumento singular: el relleno = 10
  • separación: puede agregar espacio entre los widgets de los niños con este argumento.
  • orientación

  • : Puede cambiar la orientación predeterminada de la BoxLayout de horizontal a vertical.

Adición de Eventos

Al igual que la mayoría kits de herramientas GUI, Kivy es sobre todo basado en eventos. Los responde a las pulsaciones de teclas marco de usuarios, eventos de ratón, y eventos táctiles. Kivy tiene el concepto de un reloj que se puede utilizar para las llamadas de función de programación para algún momento en el futuro.

Kivy también tiene el concepto de propiedades, que trabaja con el EventDispatcher. Propiedades ayudan a hacer la comprobación de validación. También le permiten disparar eventos cada vez que un widget cambia su tamaño o posición.

Vamos a añadir un evento de botón a su código del botón de antes:

from kivy.app import App
from kivy.uix.button import Button

class MainApp(App):
def build(self):
button = Button(text='Hello from Kivy',
size_hint=(.5, .5),
pos_hint={'center_x': .5, 'center_y': .5})
button.bind(on_press=self.on_press_button)

return button

def on_press_button(self, instance):
print('You pressed the button!')

if __name__ == '__main__':
app = MainApp()
app.run()

En este código, se llama a button.bind () y vincular el evento on_press a MainApp.on_press_button (). Este método toma implícitamente en la instancia de widget, que es el objeto de botón de sí mismo. Por último, un mensaje se imprimirá en la salida estándar cada vez que el usuario pulsa el botón.

Uso de la Lengua KV

Kivy también proporciona un lenguaje de diseño llamado KV que se puede utilizar con las aplicaciones de Kivy. El lenguaje KV le permite separar el diseño de la interfaz de la lógica de la aplicación. Esto sigue el principio de separación de las preocupaciones y es parte del patrón de arquitectura Modelo-Vista-Controlador. Puede actualizar el ejemplo anterior para utilizar el lenguaje KV :

from kivy.app import App
from kivy.uix.button import Button

class ButtonApp(App):
def build(self):
return Button()

def on_press_button(self):
print('You pressed the button!')

if __name__ == '__main__':
app = ButtonApp()
app.run()

Este código podría ser un poco extraño a primera vista, ya que crea un botón sin establecer ninguna de sus atributos o vinculante para cualquier evento. ¿Qué está pasando aquí es que Kivy buscará automáticamente un archivo que tiene el mismo nombre que la clase en minúsculas, sin la parte de la aplicación del nombre de la clase.

En este caso, el nombre de la clase es ButtonApp, por lo Kivy buscará un archivo llamado button.kv. Si el archivo existe y tiene el formato correcto, entonces Kivy lo utilizará para cargar la interfaz de usuario. Seguir adelante y crear este archivo y añadir el siguiente código:

1