Travailler avec des boutons à l'aide de fichiers Python Kivy et .kv

La conception d'interfaces utilisateur interactives pour les applications Kivy est simple et efficace en utilisant des boutons dans des fichiers .kv. Kivy est un framework Python permettant de créer des applications multiplateformes qui utilise le type de fichier .kv pour séparer l'apparence visuelle et la fonctionnalité des boutons du code sous-jacent. Le langage déclaratif des fichiers .kv est utilisé pour fournir des propriétés de bouton telles que le texte, la taille et les gestionnaires d'événements, permettant aux développeurs de créer des interfaces utilisateur simples, compactes et gérables. Les développeurs peuvent facilement modifier l'apparence et la fonctionnalité des boutons en les ajoutant directement au fichier .kv sans ajouter de contenu redondant dans le code Python.

Sujets abordés

• Fonctionnalités Python Kivy

• Présentation du bouton

• Concevoir des applications avec Kivy

Caractéristiques de Python Kivy

• Cadre d'interface utilisateur (UI) : Pour créer des interfaces utilisateur interactives, Kivy fournit divers widgets et gestionnaires de mise en page pour répondre à divers besoins. Il est compatible avec une variété de technologies de saisie, notamment les gestes tactiles, les clics de souris, les événements de clavier, etc.

• Support multi-touch : Kivy convient aux appareils tactiles tels que les smartphones et les tablettes, car il est conçu pour gérer les interactions multi-touch.

• Graphiques et animation : Grâce aux puissantes capacités graphiques de Kivy, les développeurs peuvent créer de superbes applications avec des animations et des transitions fluides.

• Développement multiplateforme : étant donné que l'application Python Kivy est véritablement multiplateforme, les développeurs n'ont besoin d'écrire le code qu'une seule fois pour l'utiliser sur plusieurs plates-formes sans apporter de modifications majeures.

• Open Source et axé sur la communauté : Une communauté florissante de développeurs et de bénévoles continue d'améliorer et de développer le projet open source Kivy.

• Facile à apprendre : la syntaxe de Kivy est simple et intuitive, ce qui la rend particulièrement facile à comprendre pour les développeurs Python. Les développeurs débutants et expérimentés peuvent l'utiliser car il adopte une approche déclarative lors de la création d'interfaces utilisateur.

Présentation du bouton

Dans Kivy, les widgets de boutons sont des widgets interactifs qui enregistrent les entrées de l'utilisateur et lancent des actions ou des événements spécifiques dans un programme Python. Ils permettent aux utilisateurs d'interagir avec les applications et constituent un élément clé de l'interface utilisateur. Dans la plupart des applications, les boutons réagissent au toucher, aux clics de souris, aux actions du clavier, etc., et ont une représentation visuelle telle qu'un texte ou une image.

La classe Button est un composant de la bibliothèque Kivy et est utilisée pour représenter des boutons en Python. Ils peuvent être déclarés dans un fichier .kv en utilisant une syntaxe déclarative ou par programme en utilisant du code Python. En utilisant les nombreuses propriétés et gestionnaires d'événements de la classe Button, les développeurs peuvent modifier l'apparence et le comportement d'un bouton pour mieux répondre aux exigences du programme, prendre des décisions éclairées et planifier les choses différemment.

Étapes

Installez Kivyy : Avant de commencer à concevoir votre application, assurez-vous que Kivy est installé sur votre ordinateur. En utilisant pip, vous pouvez l'installer :

pip install kivy

Importer les modules requis : importez les modules pertinents de Kivy dans votre script Python.

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

Créer un gestionnaire d'événements de bouton et une classe d'application Kivy : Créez une méthode qui sera appelée lorsque le bouton est enfoncé et définissez une classe dérivée de App.

class MyApp(App):
   def build(self):
      layout = BoxLayout(orientation='vertical')
      button = Button(text='Click Me!', on_press=self.on_button_press)
      layout.add_widget(button)
      return layout

   def on_button_press(self, instance):
      print("Button was pressed!")

Exécutez l'application Kivy

if __name__ == "__main__":
   MyApp().run()

Exécuter le script

python your_script.py

Concevez des applications avec Kivy

Grâce à sa syntaxe intuitive, Python Kivy permet aux développeurs possédant des compétences diverses de créer facilement des applications multiplateformes dynamiques. Il offre une expérience utilisateur attrayante sur différentes plates-formes avec une prise en charge multi-touch, une riche bibliothèque de widgets et des fonctionnalités d'animation séduisantes. Pour cette raison, Kivy est largement utilisé pour créer une variété d’applications innovantes au service de diverses industries et secteurs.

Développement de jeux de tennis de table

Le jeu d'arcade classique Pong est un excellent point de départ pour apprendre les compétences en programmation de jeux Python Kivy. Avec le framework open source Kivy, les développeurs peuvent facilement créer des programmes et des jeux multiplateformes, et Pong offre une excellente opportunité d'étudier son potentiel pour générer des expériences de jeu interactives. Deux joueurs s'affrontent pour les points en manipulant leurs raquettes pour faire rebondir la balle à mesure que la balle accélère.

Étapes

• Configurer l'environnement : installez toutes les bibliothèques nécessaires, y compris Kivy.

• Concevoir l'interface du jeu : Pour spécifier la disposition du jeu (y compris l'affichage de la raquette, de la balle et du score), créez un fichier Kivy.kv.

• Créer du code Python : implémentez la logique de jeu en Python pour gérer les mouvements du plateau, les collisions de balles et le suivi des scores.

• Définir les événements du jeu : utilisez l'horloge Kivy pour mettre à jour l'état du jeu et gérer des événements tels que le mouvement de la balle et la détection de collision

• Ajouter un contrôle de jeu : implémentez des événements tactiles ou clavier pour contrôler la lunette

• Test et débogage : exécutez le jeu, testez ses fonctionnalités et effectuez les ajustements nécessaires.

Créez deux fichiers : un fichier Python nommé main.py et un fichier Kivy nommé pong.kv

Example

的中文翻译为：

示例

main.py文件

from kivy.app import App
from kivy.uix.widget import Widget
from kivy.properties import (
   NumericProperty, ReferenceListProperty, ObjectProperty
)
from kivy.vector import Vector
from kivy.clock import Clock


class PongPaddle(Widget):
   score = NumericProperty(0)

   def bounce_ball(self, ball):
      if self.collide_widget(ball):
         vx, vy = ball.velocity
         offset = (ball.center_y - self.center_y) / (self.height / 2)
         bounced = Vector(-1 * vx, vy)
         vel = bounced * 1.1
         ball.velocity = vel.x, vel.y + offset


class PongBall(Widget):
   velocity_x = NumericProperty(0)
   velocity_y = NumericProperty(0)
   velocity = ReferenceListProperty(velocity_x, velocity_y)

   def move(self):
      self.pos = Vector(*self.velocity) + self.pos


class PongGame(Widget):
   ball = ObjectProperty(None)
   player1 = ObjectProperty(None)
   player2 = ObjectProperty(None)

   def serve_ball(self, vel=(4, 0)):
      self.ball.center = self.center
      self.ball.velocity = vel

   def update(self, dt):
      self.ball.move()

      self.player1.bounce_ball(self.ball)
      self.player2.bounce_ball(self.ball)

      if (self.ball.y < self.y) or (self.ball.top > self.top):
         self.ball.velocity_y *= -1

      if self.ball.x < self.x:
         self.player2.score += 1
         self.serve_ball(vel=(4, 0))
      if self.ball.right > self.width:
         self.player1.score += 1
         self.serve_ball(vel=(-4, 0))

   def on_touch_move(self, touch):
      if touch.x < self.width / 3:
         self.player1.center_y = touch.y
      if touch.x > self.width - self.width / 3:
         self.player2.center_y = touch.y


class PongApp(App):
   def build(self):
      game = PongGame()
      game.serve_ball()
      Clock.schedule_interval(game.update, 1.0 / 60.0)
      return game


if __name__ == '__main__':
   PongApp().run()

pong.kv 文件

#:kivy 1.0.9

<PongBall>:
   size: 50, 50 
   canvas:
      Ellipse:
         pos: self.pos
         size: self.size        

<PongPaddle>:
   size: 25, 200
   canvas:
      Rectangle:
         pos: self.pos
         size: self.size

<PongGame>:
   ball: pong_ball
   player1: player_left
   player2: player_right
   
   canvas:
      Rectangle:
         pos: self.center_x - 5, 0
         size: 10, self.height
   
   Label:
      font_size: 70  
      center_x: root.width / 4
      top: root.top - 50
      text: str(root.player1.score)
      
   Label:
      font_size: 70  
      center_x: root.width * 3 / 4
      top: root.top - 50
      text: str(root.player2.score)
   
   PongBall:
      id: pong_ball
      center: self.parent.center
      
   PongPaddle:
      id: player_left
      x: root.x
      center_y: root.center_y
      
   PongPaddle:
      id: player_right
      x: root.width - self.width
      center_y: root.center_y

输出

结论

Python Kivy 作为开源框架在创建 Pong 游戏中的无缝实现就是其有效性的一个例子。事实证明，从头开始创建游戏的过程是一次无价的学习机会，让我们对用户界面设计、Python 事件处理和基本游戏开发原理有了深入的了解。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!