Formation Python
De nos jours, il est fort probable que les développeurs travaillent sur une application mobile ou Web. Python ne dispose pas de fonctionnalités de développement mobile intégrées, mais il existe des packages que vous pouvez utiliser pour créer des applications mobiles, tels que Kivy, PyQt ou même la bibliothèque Beoga de Toga.
Ces bibliothèques sont toutes des acteurs majeurs de l’espace mobile Python. Cependant, vous verrez certains avantages si vous choisissez de créer des applications mobiles avec Kivy. Non seulement votre application aura la même apparence sur toutes les plates-formes, mais vous n’aurez pas besoin de compiler votre code après chaque modification. De plus, vous pourrez utiliser la syntaxe claire de Python pour créer vos applications.
Dans ce tutoriel, vous allez apprendre à:
- Travailler avec les widgets Kivy
- Disposez l'interface utilisateur
- Ajouter des événements
- Utiliser le langage KV
- Créer une application de calculatrice
- Créez un package pour votre application pour iOS, Android, Windows et OS X
Ce tutoriel suppose que vous maîtrisez la programmation orientée objet. Si ce n’est pas le cas, consultez la programmation orientée objet dans Python 3.
Commençons!
Comprendre le cadre de Kivy
Kivy a été lancé pour la première fois au début de 2011. Ce cadre Python multiplate-forme peut être déployé sous Windows, Mac, Linux et Raspberry Pi. Il prend en charge les événements multitouch en plus des entrées habituelles au clavier et à la souris. Kivy prend même en charge l’accélération graphique de ses graphiques, car ils sont conçus avec OpenGL ES2. Le projet utilise la licence MIT, vous pouvez donc utiliser cette bibliothèque pour les logiciels libres et commerciaux.
Lorsque vous créez une application avec Kivy, vous créez une interface utilisateur naturelle ou NUI. L'idée derrière une interface utilisateur naturelle est que l'utilisateur peut facilement apprendre à utiliser votre logiciel avec peu d'instructions, voire aucune.
Kivy n'essaie pas d'utiliser des contrôles ou des widgets natifs. Tous ses widgets sont dessinés sur mesure. Cela signifie que les applications Kivy auront le même aspect sur toutes les plateformes. Cependant, cela signifie également que l'apparence de votre application sera différente de celle des applications natives de vos utilisateurs. Cela pourrait être un avantage ou un inconvénient, selon votre public.
Installer Kivy
Kivy a de nombreuses dépendances, il est donc recommandé de l’installer dans un environnement virtuel Python. Vous pouvez utiliser les fonctions intégrées de Python venv
bibliothèque ou virtualenv
paquet. Si vous n’avez jamais utilisé d’environnement virtuel Python auparavant, consultez l’environnement virtuel Python: un guide.
Voici comment créer un environnement virtuel Python:
$ python3 -m venv my_kivy_project
Cela copiera votre exécutable Python 3 dans un dossier appelé my_kivy_project
et ajoutez quelques autres sous-dossiers à ce répertoire.
Pour utiliser votre environnement virtuel, vous devez l'activer. Sur Mac et Linux, vous pouvez le faire en exécutant ce qui suit à l’intérieur du logiciel. my_kivy_project
dossier:
La commande pour Windows est similaire, mais l'emplacement du script d'activation est à l'intérieur de la Les scripts
dossier au lieu de poubelle
.
Maintenant que vous avez un environnement virtuel Python activé, vous pouvez exécuter pépin
installer Kivy. Sous Linux et Mac, vous exécuterez la commande suivante:
$ python -m pip installer kivy
Sous Windows, l'installation est un peu plus complexe. Consultez la documentation officielle pour savoir comment installer Kivy sous Windows. (Les utilisateurs Mac peuvent également télécharger un fichier Dmg
déposer et installer Kivy de cette façon.)
Si vous rencontrez des problèmes lors de l’installation de Kivy sur votre plate-forme, consultez la page de téléchargement de Kivy pour obtenir des instructions supplémentaires.
UNE widget est un contrôle à l'écran avec lequel l'utilisateur va interagir. Tous les kits d'outils d'interface utilisateur graphique sont livrés avec un ensemble de widgets. Certains widgets courants que vous avez peut-être utilisés incluent les boutons, les listes déroulantes et les onglets. Kivy a de nombreux widgets intégrés dans son cadre.
Lancer un programme «Bonjour Kivy!
Pour voir comment Kivy fonctionne, jetez un coup d'œil à l'application «Hello, World!» Suivante:
de kivy.app importation App
de kivy.uix.label importation Étiquette
classe MainApp(App):
def construire(soi):
étiquette = Étiquette(texte='Bonjour de Kivy',
size_hint=(.5, .5),
pos_hint='center_x': .5, 'center_y': .5)
revenir étiquette
si __Nom__ == '__principale__':
app = MainApp()
app.courir()
Chaque application Kivy doit être sous-classe App
et passer outre construire()
. C’est là que vous placerez votre code d’interface utilisateur ou ferez des appels à d’autres fonctions définissant votre code d’interface utilisateur. Dans ce cas, vous créez un Étiquette
widget et passer dans son texte
, size_hint
, et pos_hint
. Ces deux derniers arguments ne sont pas nécessaires.
size_hint
indique à Kivy les proportions à utiliser lors de la création du widget. Il faut deux chiffres:
- Le premier numéro est le
X
indice de taille et se réfère à la largeur du contrôle. - Le deuxième numéro est le
y
indice de taille et se réfère à la la taille du contrôle.
Ces deux nombres peuvent être compris entre 0 et 1. La valeur par défaut pour les deux indicateurs est 1. Vous pouvez également utiliser pos_hint
pour positionner le widget. Dans le bloc de code ci-dessus, vous indiquez à Kivy de centrer le widget sur les axes x et y.
Pour que l'application s'exécute, vous instanciez votre MainApp
classe et ensuite appeler courir()
. Lorsque vous le faites, vous devriez voir ce qui suit sur votre écran:
Kivy envoie également beaucoup de texte à stdout
:
[INFO ] [Logger ] Enregistrer le journal dans /home/mdriscoll/.kivy/logs/kivy_19-06-07_2.txt
[INFO ] [Kivy ] v1.11.0
[INFO ] [Kivy ] Installé dans "/home/mdriscoll/code/test/lib/python3.6/site-packages/kivy/__init__.py"
[INFO ] [Python ] v3.6.7 (par défaut, 22 octobre 2018, 11:32:17)
[GCC 8.2.0]
[INFO ] [Python ] Interprétation sur "/ home / mdriscoll / code / test / bin / python"
[INFO ] [Factory ] 184 symboles chargés
[INFO ] [Image ] Fournisseurs: img_tex, img_dds, img_sdl2, img_gif (img_pil, img_ffpyplayer ignoré)
[INFO ] [Text ] Fournisseur: sdl2 (['text_pango'] ignoré)
[INFO ] [Window ] Fournisseur: sdl2 (['window_egl_rpi'] ignoré)
[INFO ] [GL ] Utilisation du système graphique "OpenGL"
[INFO ] [GL ] Backend utilisé
[INFO ] [GL ] Version OpenGL
[INFO ] [GL ] Fournisseur OpenGL
[INFO ] [GL ] Rendeur OpenGL
[INFO ] [GL ] Version analysée par OpenGL: 4, 6
[INFO ] [GL ] Version d'ombrage
[INFO ] [GL ] Texture max taille <16384>
[INFO ] [GL ] Unités de texture maximum <32>
[INFO ] [Window ] ajout automatique du fournisseur d'entrée sdl2
[INFO ] [Window ] clavier virtuel non autorisé, mode unique, non ancré
[INFO ] [Base ] Lancer la boucle principale de l'application
[INFO ] [GL ] Le support de texture NPOT est disponible
Ceci est utile pour déboguer votre application.
Ensuite, vous allez essayer d’ajouter un Image
widget et voir comment cela diffère d'un Étiquette
.
Affichage d'une image
Kivy propose différents widgets liés aux images. Vous pouvez utiliser Image
charger des images locales depuis votre disque dur ou AsyncImage
charger une image à partir d'une URL. Pour cet exemple, vous allez vous en tenir à la norme Image
classe:
de kivy.app importation App
de kivy.uix.image importation Image
classe MainApp(App):
def construire(soi):
img = Image(la source='/path/to/real_python.png',
size_hint=(1, .5),
pos_hint='center_x':.5, 'center_y':.5)
revenir img
si __Nom__ == '__principale__':
app = MainApp()
app.courir()
Dans ce code, vous importez Image
du kivy.uix.image
sous-package. le Image
classe prend beaucoup de paramètres différents, mais celui que vous voulez utiliser est la source
. Cela indique à Kivy quelle image charger. Ici, vous passez un chemin complet à l’image. Le reste du code est identique à ce que vous avez vu dans l'exemple précédent.
Lorsque vous exécutez ce code, vous verrez quelque chose comme ce qui suit:
Le texte de l'exemple précédent a été remplacé par une image.
Vous allez maintenant apprendre à ajouter et organiser plusieurs widgets dans votre application.
Disposer l'interface utilisateur
Chaque infrastructure graphique que vous utilisez a sa propre méthode d'organisation des widgets. Par exemple, dans wxPython, vous utiliserez des calibreurs, tandis que dans Tkinter, vous utiliserez un gestionnaire de disposition ou de géométrie. Avec Kivy, vous utiliserez Layouts. Vous pouvez utiliser différents types de mises en forme. Voici quelques-unes des plus courantes:
BoxLayout
FloatLayout
Disposition de la grille
Vous pouvez rechercher dans la documentation de Kivy la liste complète des modèles disponibles. Vous pouvez aussi regarder dans kivy.uix
pour le code source réel.
Essayez le BoxLayout
avec ce code:
importation Kivy
importation Aléatoire
de kivy.app importation App
de kivy.uix.button importation Bouton
de kivy.uix.boxlayout importation BoxLayout
rouge = [[[[1,0,0,1]
vert = [[[[0,1,0,1]
bleu = [[[[0,0,1,1]
violet = [[[[1,0,1,1]
classe HBoxLayoutExample(App):
def construire(soi):
disposition = BoxLayout(rembourrage=dix)
couleurs = [[[[rouge, vert, bleu, violet]
pour je dans intervalle(5):
btn = Bouton(texte="Bouton #% s" % (je+1),
Couleur de l'arrière plan=Aléatoire.choix(couleurs)
)
disposition.add_widget(btn)
revenir disposition
si __Nom__ == "__principale__":
app = HBoxLayoutExample()
app.courir()
Ici, vous importez BoxLayout
de kivy.uix.boxlayout
et instancier. Ensuite, vous créez une liste de couleurs, qui sont elles-mêmes des listes de couleurs rouge-bleu-vert (RVB). Enfin, vous passez en boucle sur un intervalle
de 5, créer un bouton btn
pour chaque itération. Pour rendre les choses un peu plus amusant, vous définissez la Couleur de l'arrière plan
du bouton à une couleur aléatoire. Vous ajoutez ensuite le bouton à votre mise en page avec layout.add_widget (btn)
.
Lorsque vous exécutez ce code, vous verrez quelque chose comme ceci:
Il y a 5 boutons de couleur aléatoire, un pour chaque itération de votre pour
boucle.
Lorsque vous créez une mise en page, vous devez connaître quelques arguments:
rembourrage
: Vous pouvez spécifier lerembourrage
en pixels entre la mise en page et ses enfants de l'une des trois manières suivantes:- Une liste à quatre arguments: [[[[
padding_left
,padding_top
,padding_right
,padding_bottom
] - Une liste à deux arguments: [[[[
padding_horizontal
,padding_vertical
] - Un argument singulier:
rembourrage = 10
- Une liste à quatre arguments: [[[[
espacement
: Vous pouvez ajouter un espace entre les widgets enfants avec cet argument.orientation
: Vous pouvez changer la valeur par défautorientation
duBoxLayout
de l'horizontal à la verticale.
Ajout d'événements
Comme la plupart des toolkits graphiques, Kivy est principalement événementiel. L'infrastructure répond aux pressions de l'utilisateur, aux événements de souris et aux événements tactiles. Kivy a le concept d'un L'horloge que vous pouvez utiliser pour planifier des appels de fonction pour un certain temps dans le futur.
Kivy a aussi le concept de Propriétés
, qui fonctionne avec le EventDispatcher
. Les propriétés vous aident à vérifier la validation. Ils vous permettent également de déclencher des événements chaque fois qu'un widget change de taille ou de position.
Ajoutons un événement de bouton à votre code de bouton de plus tôt:
de kivy.app importation App
de kivy.uix.button importation Bouton
classe MainApp(App):
def construire(soi):
bouton = Bouton(texte='Bonjour de Kivy',
size_hint=(.5, .5),
pos_hint='center_x': .5, 'center_y': .5)
bouton.lier(on_press=soi.on_press_button)
revenir bouton
def on_press_button(soi, exemple):
impression(«Vous avez appuyé sur le bouton!)
si __Nom__ == '__principale__':
app = MainApp()
app.courir()
Dans ce code, vous appelez button.bind ()
et lier le on_press
événement à MainApp.on_press_button ()
. Cette méthode prend implicitement dans le widget exemple
, qui est le bouton
objet lui-même. Enfin, un message sera imprimé à stdout
chaque fois que l'utilisateur appuie sur votre bouton.
Utiliser le langage KV
Kivy fournit également un langage de conception appelé KV que vous pouvez utiliser avec vos applications Kivy. Le langage KV vous permet de séparer la conception de votre interface de la logique de l’application. Ceci suit le principe de séparation des préoccupations et fait partie du modèle architectural Model-View-Controller. Vous pouvez mettre à jour l'exemple précédent pour utiliser le langage KV:
de kivy.app importation App
de kivy.uix.button importation Bouton
classe ButtonApp(App):
def construire(soi):
revenir Bouton()
def on_press_button(soi):
impression(«Vous avez appuyé sur le bouton!)
si __Nom__ == '__principale__':
app = ButtonApp()
app.courir()
Ce code peut paraître un peu étrange au premier abord, car il crée un Bouton
sans définir aucun de ses attributs ni le lier à des événements. Ce qui se passe ici, c'est que Kivy recherchera automatiquement un fichier portant le même nom que la classe en minuscule, sans le App
une partie du nom de la classe.
Dans ce cas, le nom de la classe est ButtonApp
, Kivy va donc chercher un fichier nommé bouton.kv
. Si ce fichier existe et est correctement formaté, Kivy l'utilisera pour charger l'interface utilisateur. Allez-y, créez ce fichier et ajoutez le code suivant:
1
Voici ce que fait chaque ligne:
- Ligne 1 correspond à la
Bouton
appelez votre code Python. Il dit à Kivy de rechercher dans l'objet instancié une définition de bouton. - Ligne 2 règle le bouton
texte
. - Ligne 3 définit la largeur et la hauteur avec
size_hint
. - Ligne 4 définit la position du bouton avec
pos_hint
. - Ligne 5 définit le
on_press
gestionnaire d'événements. Pour indiquer à Kivy où se trouve le gestionnaire d'événements, vous utilisezapp.on_press_button ()
. Ici, Kivy sait qu’il cherchera dans leApplication
classe pour une méthode appelée.on_press_button ()
.
Vous pouvez configurer tous vos widgets et vos dispositions dans un ou plusieurs fichiers de langue KV. Le langage KV prend également en charge l’importation de modules Python dans KV, la création de classes dynamiques, etc. Pour plus de détails, consultez le guide de Kivy sur la langue KV.
Vous êtes maintenant prêt à créer une application réelle!
Créer une application Kivy
L'un des meilleurs moyens d'apprendre une nouvelle compétence consiste à créer quelque chose d'utile. Dans cet esprit, vous utiliserez Kivy pour créer une calculatrice prenant en charge les opérations suivantes:
- Une addition
- Soustraction
- Multiplication
- Division
Pour cette application, vous aurez besoin d’une série de boutons dans une sorte de disposition. Vous aurez également besoin d’une boîte en haut de votre application pour afficher les équations et leurs résultats. Voici un croquis de votre calculatrice:
Maintenant que vous avez un objectif pour l'interface utilisateur, vous pouvez écrire le code:
1 de kivy.app importation App
2 de kivy.uix.boxlayout importation BoxLayout
3 de kivy.uix.button importation Bouton
4 de kivy.uix.textinput importation Saisie de texte
5
6 classe MainApp(App):
sept def construire(soi):
8 soi.les opérateurs = [[[["/", "*", "+", "-"]
9 soi.last_was_operator = Aucun
dix soi.last_button = Aucun
11 main_layout = BoxLayout(orientation="verticale")
12 soi.Solution = Saisie de texte(
13 multiligne=Faux, lecture seulement=Vrai, halign="droite", taille de police=55
14 )
15 main_layout.add_widget(soi.Solution)
16 boutons = [[[[
17 [[[["sept", "8", "9", "/"],
18 [[[["4", "5", "6", "*"],
19 [[[["1", "2", "3", "-"],
20 [[[[".", "0", "C", "+"],
21 ]
22 pour rangée dans boutons:
23 h_layout = BoxLayout()
24 pour étiquette dans rangée:
25 bouton = Bouton(
26 texte=étiquette,
27 pos_hint="center_x": 0.5, "center_y": 0.5,
28 )
29 bouton.lier(on_press=soi.on_button_press)
30 h_layout.add_widget(bouton)
31 main_layout.add_widget(h_layout)
32
33 est égal à = Bouton(
34 texte="=", pos_hint="center_x": 0.5, "center_y": 0.5
35 )
36 est égal à.lier(on_press=soi.on_solution)
37 main_layout.add_widget(est égal à)
38
39 revenir main_layout
Voici comment fonctionne votre code de calculatrice:
- Aux lignes 8 à 10, vous créez une liste de
les opérateurs
et quelques valeurs pratiques,last_was_operator
etlast_button
, que vous utiliserez plus tard. - Lignes 11 à 15, vous créez une mise en page de premier niveau
main_layout
et ajouter une lecture seuleSaisie de texte
widget à elle. - Aux lignes 16 à 21, vous créez une liste imbriquée de listes contenant la plupart de vos
boutons
pour la calculatrice. - En ligne 22, vous commencez un
pour
boucle sur ceuxboutons
. Pour chaque liste imbriquée, procédez comme suit:- À la ligne 23, vous créez un
BoxLayout
avec une orientation horizontale. - En ligne 24, vous commencez un autre
pour
boucle sur les éléments de la liste imbriquée. - Dans les lignes 25 à 39, vous créez les boutons de la ligne, vous les liez à un gestionnaire d’événements et vous les ajoutez à l’horizontale.
BoxLayout
de la ligne 23. - À la ligne 31, vous ajoutez cette mise en page à
main_layout
.
- À la ligne 23, vous créez un
- Aux lignes 33 à 37, vous créez le bouton d’égal à égal (
=
), le lier à un gestionnaire d’événements et l’ajouter àmain_layout
.
La prochaine étape consiste à créer le .on_button_press ()
gestionnaire d'événements. Voici à quoi ce code ressemble:
41 def on_button_press(soi, exemple):
42 courant = soi.Solution.texte
43 button_text = exemple.texte
44
45 si button_text == "C":
46 # Effacer le widget de solution
47 soi.Solution.texte = ""
48 autre:
49 si courant et (
50 soi.last_was_operator et button_text dans soi.les opérateurs):
51 # N'ajoutez pas deux opérateurs l'un après l'autre
52 revenir
53 elif courant == "" et button_text dans soi.les opérateurs:
54 # Le premier caractère ne peut pas être un opérateur
55 revenir
56 autre:
57 new_text = courant + button_text
58 soi.Solution.texte = new_text
59 soi.last_button = button_text
60 soi.last_was_operator = soi.last_button dans soi.les opérateurs
La plupart des widgets de votre application appellent .on_button_press ()
. Voilà comment cela fonctionne:
-
Ligne 41 prend le
exemple
argument afin que vous puissiez accéder à quel widget appelé la fonction. -
Lignes 42 et 43 extraire et stocker la valeur de la
Solution
et le boutontexte
. -
Lignes 45 à 47 vérifiez pour voir quel bouton a été appuyé. Si l'utilisateur a appuyé sur
C
, vous effacerez laSolution
. Sinon, passez à laautre
déclaration. -
Ligne 49 vérifie si la solution a une valeur préexistante.
-
Ligne 50 à 52 vérifiez si le dernier bouton enfoncé était un bouton opérateur. Si c'était le cas, alors
Solution
ne sera pas mis à jour. Cela empêche l'utilisateur d'avoir deux opérateurs à la suite. Par exemple,1 */
n'est pas une déclaration valide. -
Lignes 53 à 55 vérifiez si le premier caractère est un opérateur. Si c'est le cas, alors
Solution
ne sera pas mis à jour, car la première valeur ne peut pas être une valeur d'opérateur. -
Lignes 56 à 58 déposer à la
autre
clause. Si aucune des conditions précédentes n'est remplie, alors mettez à jourSolution
. -
Ligne 59 ensembles
last_button
à l'étiquette du dernier bouton enfoncé. -
Ligne 60 ensembles
last_was_operator
àVrai
ouFaux
selon qu’il s’agisse ou non d’un caractère opérateur.
Le dernier bit de code à écrire est .on_solution ()
:
62 def on_solution(soi, exemple):
63 texte = soi.Solution.texte
64 si texte:
65 Solution = str(eval(soi.Solution.texte))
66 soi.Solution.texte = Solution
Encore une fois, vous récupérez le texte actuel de Solution
et utiliser les fonctions intégrées de Python eval ()
pour l'exécuter. Si l'utilisateur a créé une formule comme 1 + 2
, puis eval ()
exécutera votre code et renverra le résultat. Enfin, vous définissez le résultat comme nouvelle valeur pour Solution
widget.
Remarque: eval ()
est un peu dangereux car il peut exécuter du code arbitraire. La plupart des développeurs évitent de l'utiliser pour cette raison. Cependant, étant donné que vous n'autorisez que les entiers, les opérateurs et la période, eval ()
, son utilisation est sans danger dans ce contexte.
Lorsque vous exécutez ce code, votre application ressemblera à ceci sur un ordinateur de bureau:
Pour voir le code complet de cet exemple, développez le bloc de code ci-dessous.
Voici le code complet de la calculatrice:
de kivy.app importation App
de kivy.uix.boxlayout importation BoxLayout
de kivy.uix.button importation Bouton
de kivy.uix.textinput importation Saisie de texte
classe MainApp(App):
def construire(soi):
soi.les opérateurs = [[[["/", "*", "+", "-"]
soi.last_was_operator = Aucun
soi.last_button = Aucun
main_layout = BoxLayout(orientation="verticale")
soi.Solution = Saisie de texte(
multiligne=Faux, lecture seulement=Vrai, halign="droite", taille de police=55
)
main_layout.add_widget(soi.Solution)
boutons = [[[[
[[[["sept", "8", "9", "/"],
[[[["4", "5", "6", "*"],
[[[["1", "2", "3", "-"],
[[[[".", "0", "C", "+"],
]
pour rangée dans boutons:
h_layout = BoxLayout()
pour étiquette dans rangée:
bouton = Bouton(
texte=étiquette,
pos_hint="center_x": 0.5, "center_y": 0.5,
)
bouton.lier(on_press=soi.on_button_press)
h_layout.add_widget(bouton)
main_layout.add_widget(h_layout)
est égal à = Bouton(
texte="=", pos_hint="center_x": 0.5, "center_y": 0.5
)
est égal à.lier(on_press=soi.on_solution)
main_layout.add_widget(est égal à)
revenir main_layout
def on_button_press(soi, exemple):
courant = soi.Solution.texte
button_text = exemple.texte
si button_text == "C":
# Effacer le widget de solution
soi.Solution.texte = ""
autre:
si courant et (
soi.last_was_operator et button_text dans soi.les opérateurs):
# N'ajoutez pas deux opérateurs l'un après l'autre
revenir
elif courant == "" et button_text dans soi.les opérateurs:
# Le premier caractère ne peut pas être un opérateur
revenir
autre:
new_text = courant + button_text
soi.Solution.texte = new_text
soi.last_button = button_text
soi.last_was_operator = soi.last_button dans soi.les opérateurs
def on_solution(soi, exemple):
texte = soi.Solution.texte
si texte:
Solution = str(eval(soi.Solution.texte))
soi.Solution.texte = Solution
si __Nom__ == "__principale__":
app = MainApp()
app.courir()
Il est temps de déployer votre application!
Emballage de votre application pour Android
Maintenant que vous avez terminé le code de votre application, vous pouvez le partager avec d'autres. Une excellente façon de le faire est de transformer votre code en une application pouvant être exécutée sur votre téléphone Android. Pour ce faire, vous devez d’abord installer un paquet nommé Buildozer
avec pépin
:
Créez ensuite un nouveau dossier et naviguez-le dans votre terminal. Une fois que vous y êtes, vous devrez exécuter la commande suivante:
Cela va créer un buildozer.spec
fichier que vous utiliserez pour configurer votre build. Pour cet exemple, vous pouvez éditer les premières lignes du fichier de spécification comme suit:
[app]
# (str) Titre de votre application
titre = KvCalc
# (str) Nom du package
package.name = kvcalc
# (str) Domaine du paquet (nécessaire pour les paquets android / ios)
package.domain = org.kvcalc
N'hésitez pas à parcourir le reste du fichier pour voir ce que vous pouvez changer d'autre.
À ce stade, vous êtes presque prêt à créer votre application, mais vous devez d’abord installer les dépendances pour Buildozer
. Une fois ceux-ci installés, copiez votre application de calculatrice dans votre nouveau dossier et renommez-le en main.py
. Ceci est requis par Buildozer
. Si vous ne nommez pas le fichier correctement, la construction échouera.
Maintenant, vous pouvez exécuter la commande suivante:
$ buildozer -v android debug
L'étape de construction prend beaucoup de temps! Sur ma machine, cela a pris 15 à 20 minutes. En fonction de votre matériel, cela peut prendre encore plus longtemps, alors n'hésitez pas à prendre une tasse de café ou à courir pendant que vous attendez. Buildozer
téléchargera toutes les pièces du SDK Android nécessaires pendant le processus de construction. Si tout se passe comme prévu, vous aurez un fichier nommé quelque chose comme kvcalc-0.1-debug.apk
dans votre poubelle
dossier.
La prochaine étape consiste à connecter votre téléphone Android à votre ordinateur et à copier le apk
déposer à elle. Ensuite, vous pouvez ouvrir le navigateur de fichiers sur votre téléphone et cliquer sur le bouton apk
fichier. Android devrait vous demander si vous souhaitez installer l'application. Un message d'avertissement peut s'afficher depuis le téléchargement de l'application à partir de l'extérieur de Google Play, mais vous devriez toujours pouvoir l'installer.
Voici la calculatrice fonctionnant sur mon Samsung S9:
le Buildozer
Cet outil a plusieurs autres commandes que vous pouvez utiliser. Consultez la documentation pour voir ce que vous pouvez faire d'autre.
Vous pouvez également emballer l'application à l'aide de python pour android
si vous avez besoin d'un contrôle plus fin. Vous ne couvrirez pas cette question ici, mais si cela vous intéresse, consultez le quickstart du projet.
Emballage de votre application pour iOS
Les instructions pour créer une application pour iOS sont un peu plus complexes qu'Android. Pour obtenir les informations les plus récentes, vous devez toujours utiliser la documentation d’emballage officielle de Kivy. Vous devez exécuter les commandes suivantes avant de pouvoir conditionner votre application pour iOS sur votre Mac:
$ infuser installer autoconf automake libtool pkg-config
$ lien brassage libtool
$ sudo easy_install pip
$ sudo pip installer Cython==029,10
Une fois ceux-ci installés, vous devez compiler la distribution à l’aide des commandes suivantes:
$ git clone git: //github.com/kivy/kivy-ios
$ CD kivy-ios
$ ./toolchain.py construire python3 kivy
Si vous obtenez une erreur qui dit iphonesimulator
introuvable, consultez cette réponse à StackOverflow pour trouver des solutions à ce problème. Ensuite, essayez à nouveau d'exécuter les commandes ci-dessus.
Si vous rencontrez des erreurs SSL, alors vous n’aurez probablement pas la configuration OpenSSL de Python. Cette commande devrait corriger ça:
$ CD / Applications / Python 3.sept/
$ ./Installer Certificats.command
Maintenant, retournez et essayez de lancer le chaîne d'outils
commande à nouveau.
Une fois que vous avez exécuté toutes les commandes précédentes avec succès, vous pouvez créer votre projet Xcode à l'aide du chaîne d'outils
scénario. Le point d’entrée de votre application principale doit être nommé main.py
avant de créer le projet Xcode. Voici la commande que vous allez exécuter:
./toolchain.py créer
Il devrait y avoir un répertoire nommé Titre
avec votre projet Xcode dedans. Vous pouvez maintenant ouvrir ce projet dans Xcode et y travailler à partir de là. Notez que si vous souhaitez soumettre votre application sur l'App Store, vous devez créer un compte de développeur sur developer.apple.com et payer leurs frais annuels.
Emballage de votre application pour Windows
Vous pouvez conditionner votre application Kivy pour Windows à l'aide de PyInstaller. Si vous ne l’avez jamais utilisé auparavant, consultez la rubrique Utilisation de PyInstaller pour distribuer facilement des applications Python.
Vous pouvez installer PyInstaller en utilisant pépin
:
$ pip installer pyinstaller
La commande suivante conditionnera votre application:
Cette commande créera un exécutable Windows et plusieurs autres fichiers. le -w
L'argument indique à PyInstaller qu'il s'agit d'une application avec fenêtre plutôt que d'une application en ligne de commande. Si vous préférez que PyInstaller crée un seul fichier exécutable, vous pouvez passer le --onefile
argument en plus de -w
.
Emballage de votre application pour OS X
Vous pouvez utiliser PyInstaller pour créer un exécutable Mac comme vous le faites pour Windows. La seule exigence est que vous exécutiez cette commande sur un Mac:
$ pyinstaller main.py -w --onefile
Cela créera un seul fichier exécutable dans le dist
dossier. Le fichier exécutable aura le même nom que le fichier Python que vous avez transmis à PyInstaller. Si vous souhaitez réduire la taille du fichier de l’exécutable ou si vous utilisez GStreamer dans votre application, consultez la page d’emballage de Kivy pour OS X pour plus d’informations.
Conclusion
Kivy est un cadre d'interface graphique très intéressant que vous pouvez utiliser pour créer des interfaces utilisateur de bureau et des applications mobiles sur iOS et Android. Les applications Kivy ne ressembleront pas aux applications natives sur aucune plate-forme. Cela peut être un avantage si vous souhaitez que votre application soit différente de la concurrence!
Dans ce didacticiel, vous avez appris les bases de Kivy, notamment comment ajouter des widgets, connecter des événements, mettre en forme plusieurs widgets et utiliser le langage KV. Ensuite, vous avez créé votre première application Kivy et appris à la distribuer sur d'autres plates-formes, y compris mobile!
Il existe de nombreux widgets et concepts sur Kivy que vous n’avez pas abordés ici. Assurez-vous de consulter le site Web de Kivy pour des tutoriels, des exemples d’application, etc.
Lectures complémentaires
Pour en savoir plus sur Kivy, consultez ces ressources:
Pour voir comment créer une application de bureau avec un autre framework d'interface graphique Python, consultez la rubrique Comment créer une application d'interface graphique Python avec wxPython.
[ad_2]