2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
GUI est l'abréviation de Graphical User Interface. Toute personne ayant utilisé un ordinateur doit être familiarisée avec l'interface utilisateur graphique, il n'est donc pas nécessaire d'entrer dans les détails ici. Le module de développement d'interface graphique par défaut de Python est tkinter (nommé Tkinter dans les versions antérieures à Python 3). D'après ce nom, il est basé sur Tk. Il s'agit d'une boîte à outils conçue à l'origine pour Tcl et qui a ensuite été portée dans de nombreux autres scripts. langages, il fournit des contrôles GUI multiplateformes. Bien sûr, Tk n'est pas le dernier et le meilleur choix, et il ne dispose pas de contrôles GUI particulièrement puissants. En fait, le développement d'applications GUI n'est pas ce pour quoi Python est le meilleur. Si vous avez vraiment besoin d'utiliser Python pour développer des applications GUI, wxPython, PyQt, PyGTK, etc. Les modules sont un bon choix.
Fondamentalement, utiliser tkinter pour développer des applications GUI nécessite les 5 étapes suivantes :
Le code suivant montre comment utiliser tkinter pour créer une application GUI simple.
import tkinter
import tkinter.messagebox
def main():
flag = True
# 修改标签上的文字
def change_label_text():
nonlocal flag
flag = not flag
color, msg = ('red', 'Hello, world!')
if flag else ('blue', 'Goodbye, world!')
label.config(text=msg, fg=color)
# 确认退出
def confirm_to_quit():
if tkinter.messagebox.askokcancel('温馨提示', '确定要退出吗?'):
top.quit()
# 创建顶层窗口
top = tkinter.Tk()
# 设置窗口大小
top.geometry('240x160')
# 设置窗口标题
top.title('小游戏')
# 创建标签对象并添加到顶层窗口
label = tkinter.Label(top, text='Hello, world!', font='Arial -32', fg='red')
label.pack(expand=1)
# 创建一个装按钮的容器
panel = tkinter.Frame(top)
# 创建按钮对象 指定添加到哪个容器中 通过command参数绑定事件回调函数
button1 = tkinter.Button(panel, text='修改', command=change_label_text)
button1.pack(side='left')
button2 = tkinter.Button(panel, text='退出', command=confirm_to_quit)
button2.pack(side='right')
panel.pack(side='bottom')
# 开启主事件循环
tkinter.mainloop()
if __name__ == '__main__':
main()
Il convient de noter que les applications GUI sont généralement pilotées par les événements. La raison pour laquelle il faut entrer dans la boucle d'événements principale est de surveiller l'apparition de divers événements tels que la souris et le clavier et d'exécuter le code correspondant pour traiter les événements, car les événements continueront à se produire. Une telle boucle doit donc être exécutée tout le temps en attendant que le prochain événement se produise. D'autre part, Tk fournit trois gestionnaires de disposition pour le placement des contrôles. Les contrôles peuvent être positionnés via les gestionnaires de disposition. Ces trois gestionnaires de disposition sont :Placer(Le développeur fournit la taille et l'emplacement du contrôle),Packer(remplir automatiquement les contrôles dans les positions appropriées) etGrid(Placez des contrôles basés sur les coordonnées de la grille), qui ne seront pas décrits ici.
Pygame est un module Python open source spécifiquement utilisé pour le développement d'applications multimédias (telles que des jeux vidéo), qui inclut la prise en charge des images, des sons, des vidéos, des événements, des collisions, etc. Pygame est construit sur SDL, qui est un ensemble de bibliothèques de développement multimédia multiplateformes implémentées en langage C et largement utilisé dans le développement de jeux, de simulateurs, de lecteurs, etc. Pygame permet aux développeurs de jeux de ne plus être liés par le langage sous-jacent et de se concentrer davantage sur les fonctions et la logique du jeu.
Terminons maintenant un jeu simple. Le nom du jeu est "Big Ball Eats Small Ball". Bien sûr, terminer ce jeu n'est pas l'objectif non plus. comprendre comment utiliser les étapes précédentes du processus. Expliquez la programmation orientée objet et apprenez à utiliser cette idée de programmation pour résoudre des problèmes réels.
import pygame
def main():
# 初始化导入的pygame中的模块
pygame.init()
# 初始化用于显示的窗口并设置窗口尺寸
screen = pygame.display.set_mode((800, 600))
# 设置当前窗口的标题
pygame.display.set_caption('大球吃小球')
running = True
# 开启一个事件循环处理发生的事件
while running:
# 从消息队列中获取事件并对事件进行处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if __name__ == '__main__':
main()
Vous pouvez dessiner sur la fenêtre grâce à la fonction du module draw de pygame. Les graphiques pouvant être dessinés incluent : des lignes, des rectangles, des polygones, des cercles, des ellipses, des arcs, etc. Il convient de noter que le système de coordonnées de l'écran définit le coin supérieur gauche de l'écran comme origine des coordonnées (0, 0). À droite se trouve la direction positive de l'axe des x et en bas, la direction positive de l'axe des y. Axe Lorsque vous exprimez la position ou définissez la taille, nos unités par défaut sont les pixels. Le soi-disant pixel est un point sur l'écran. Vous pouvez utiliser un logiciel de navigation d'images pour essayer d'agrandir une image plusieurs fois pour voir ces points. La représentation des couleurs dans pygame utilise la méthode de représentation des trois couleurs primaires, c'est-à-dire que la valeur RVB de la couleur est spécifiée via un tuple ou une liste. Chaque valeur est comprise entre 0 et 255, car chaque couleur primaire utilise un 8 bits (bit). Pour représenter la valeur, les trois couleurs équivalent à un total de 24 bits, ce qui est souvent appelé « représentation des couleurs 24 bits ».
import pygame
def main():
# 初始化导入的pygame中的模块
pygame.init()
# 初始化用于显示的窗口并设置窗口尺寸
screen = pygame.display.set_mode((800, 600))
# 设置当前窗口的标题
pygame.display.set_caption('大球吃小球')
# 设置窗口的背景色(颜色是由红绿蓝三原色构成的元组)
screen.fill((242, 242, 242))
# 绘制一个圆(参数分别是: 屏幕, 颜色, 圆心位置, 半径, 0表示填充圆)
pygame.draw.circle(screen, (255, 0, 0,), (100, 100), 30, 0)
# 刷新当前窗口(渲染窗口将绘制的图像呈现出来)
pygame.display.flip()
running = True
# 开启一个事件循环处理发生的事件
while running:
# 从消息队列中获取事件并对事件进行处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if __name__ == '__main__':
main()
Si vous devez charger l'image directement dans la fenêtre, vous pouvez utiliser la fonction du module image dans pygame pour charger l'image, puis restituer l'image via la méthode blit de l'objet fenêtre précédemment obtenu. Le code est le suivant.
import pygame
def main():
# 初始化导入的pygame中的模块
pygame.init()
# 初始化用于显示的窗口并设置窗口尺寸
screen = pygame.display.set_mode((800, 600))
# 设置当前窗口的标题
pygame.display.set_caption('大球吃小球')
# 设置窗口的背景色(颜色是由红绿蓝三原色构成的元组)
screen.fill((255, 255, 255))
# 通过指定的文件名加载图像
ball_image = pygame.image.load('./res/ball.png')
# 在窗口上渲染图像
screen.blit(ball_image, (50, 50))
# 刷新当前窗口(渲染窗口将绘制的图像呈现出来)
pygame.display.flip()
running = True
# 开启一个事件循环处理发生的事件
while running:
# 从消息队列中获取事件并对事件进行处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if __name__ == '__main__':
main()
En ce qui concerne le mot animation, tout le monde le connaît. En fait, pour réaliser des effets d'animation, le principe en lui-même est très simple : jouer des images discontinues en continu tant qu'un certain nombre d'images par seconde est atteint. alors cela peut être fait Produire un effet d'animation plus fluide. Si vous souhaitez que la balle dans le code ci-dessus bouge, vous pouvez utiliser une variable pour représenter la position de la balle, modifier la position de la balle dans la boucle, puis actualiser toute la fenêtre.
import pygame
def main():
# 初始化导入的pygame中的模块
pygame.init()
# 初始化用于显示的窗口并设置窗口尺寸
screen = pygame.display.set_mode((800, 600))
# 设置当前窗口的标题
pygame.display.set_caption('大球吃小球')
# 定义变量来表示小球在屏幕上的位置
x, y = 50, 50
running = True
# 开启一个事件循环处理发生的事件
while running:
# 从消息队列中获取事件并对事件进行处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
screen.fill((255, 255, 255))
pygame.draw.circle(screen, (255, 0, 0,), (x, y), 30, 0)
pygame.display.flip()
# 每隔50毫秒就改变小球的位置再刷新窗口
pygame.time.delay(50)
x, y = x + 5, y + 5
if __name__ == '__main__':
main()
Habituellement, il y aura de nombreux objets dans un jeu, et une « collision » entre ces objets est inévitable, comme un boulet de canon frappant un avion, une boîte heurtant le sol, etc. La détection des collisions est un problème crucial qui doit être traité dans la plupart des jeux. Le module sprite (sprite animé) de pygame prend en charge la détection des collisions. Nous ne présenterons pas ici les fonctions fournies par le module sprite. détecter si deux petites boules entrent en collision. Il vous suffit de vérifier si la distance entre les centres des boules est inférieure à la somme des rayons des deux boules. Afin de créer plus de petites boules, nous pouvons traiter les événements de la souris pour créer de petites boules avec des couleurs, des tailles et des vitesses de déplacement aléatoires à l'endroit où la souris est cliquée. Bien sûr, pour ce faire, nous pouvons utiliser ce que nous avons appris avant d'appliquer. connaissances orientées objet.
Les événements de souris peuvent être traités dans la boucle d'événements. Le type d'événement peut être déterminé via l'attribut type de l'objet événement et la position du clic de souris peut être obtenue via l'attribut pos. Si vous souhaitez gérer les événements du clavier, c'est également l'endroit idéal. La méthode est similaire à la gestion des événements de la souris.
def main():
# 定义用来装所有球的容器
balls = []
# 初始化导入的pygame中的模块
pygame.init()
# 初始化用于显示的窗口并设置窗口尺寸
screen = pygame.display.set_mode((800, 600))
# 设置当前窗口的标题
pygame.display.set_caption('大球吃小球')
running = True
# 开启一个事件循环处理发生的事件
while running:
# 从消息队列中获取事件并对事件进行处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# 处理鼠标事件的代码
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
# 获得点击鼠标的位置
x, y = event.pos
radius = randint(10, 100)
sx, sy = randint(-10, 10), randint(-10, 10)
color = Color.random_color()
# 在点击鼠标的位置创建一个球(大小、速度和颜色随机)
ball = Ball(x, y, radius, sx, sy, color)
# 将球添加到列表容器中
balls.append(ball)
screen.fill((255, 255, 255))
# 取出容器中的球 如果没被吃掉就绘制 被吃掉了就移除
for ball in balls:
if ball.alive:
ball.draw(screen)
else:
balls.remove(ball)
pygame.display.flip()
# 每隔50毫秒就改变球的位置再刷新窗口
pygame.time.delay(50)
for ball in balls:
ball.move(screen)
# 检查球有没有吃到其他的球
for other in balls:
ball.eat(other)
if __name__ == '__main__':
main()
En rassemblant les deux morceaux de code ci-dessus, nous avons terminé le jeu « la grosse balle mange la petite balle » (comme le montre l'image ci-dessous, pour être précis, ce n'est pas un jeu, mais nous avons transmis les connaissances de base pour créer un). petit jeu. Cet exemple indique à tout le monde qu'avec ces connaissances, vous pouvez commencer votre parcours de développement de mini-jeux. En fait, il y a de nombreux domaines qui méritent d'être améliorés dans le code ci-dessus. Par exemple, le code pour actualiser la fenêtre et déplacer la balle ne doit pas être placé dans la boucle d'événements. Après avoir appris les connaissances du multi-threading, il est possible de l'utiliser. un fil d'arrière-plan pour gérer ces choses est un meilleur choix. Si nous voulons obtenir une meilleure expérience utilisateur, nous pouvons également ajouter une musique de fond au jeu et jouer des effets sonores lorsque la balle entre en collision avec la balle. En utilisant les modules de mixage et de musique de pygame, nous pouvons facilement le faire. ce. En fait, si vous souhaitez en savoir plus sur pygame, le meilleur tutoriel est le site officiel de pygame. Si vous n'avez aucun problème avec l'anglais, vous pouvez aller y jeter un œil. Si vous souhaitez développer des jeux 3D, pygame semble être insuffisant. Les lecteurs intéressés par le développement de jeux 3D voudront peut-être jeter un œil à Panda3D.
Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.
