le mie informazioni di contatto
Posta[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
GUI è l'abbreviazione di Graphical User Interface. Chiunque abbia utilizzato un computer dovrebbe avere familiarità con l'interfaccia utente grafica, quindi non è necessario entrare nei dettagli qui. Il modulo di sviluppo GUI predefinito di Python è tkinter (chiamato Tkinter nelle versioni precedenti a Python 3). Da questo nome puoi capire che è basato su Tk. Tk è un toolkit originariamente progettato per Tcl e successivamente portato in molti altri script lingue, fornisce controlli GUI multipiattaforma. Naturalmente, Tk non è la scelta migliore e più recente e non ha controlli GUI particolarmente potenti. In effetti, lo sviluppo di applicazioni GUI non è ciò in cui Python è il migliore. Se hai davvero bisogno di usare Python per sviluppare applicazioni GUI, wxPython,. I moduli PyQt, PyGTK, ecc. sono una buona scelta.
Fondamentalmente l'utilizzo di tkinter per sviluppare applicazioni GUI richiede i seguenti 5 passaggi:
Il codice seguente dimostra come utilizzare tkinter per creare una semplice applicazione GUI.
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()
Va notato che le applicazioni GUI sono generalmente guidate dagli eventi Il motivo per accedere al ciclo di eventi principale è monitorare il verificarsi di vari eventi come mouse e tastiera ed eseguire il codice corrispondente per elaborare gli eventi, poiché gli eventi continueranno a verificarsi. Quindi un ciclo di questo tipo deve essere sempre in esecuzione in attesa che si verifichi l'evento successivo. D'altra parte, Tk fornisce tre gestori di layout per il posizionamento dei controlli. I controlli possono essere posizionati tramite i gestori di layout. Questi tre gestori di layout sono:.Placer(Lo sviluppatore fornisce la dimensione e il posizionamento del controllo),Packer(popolare automaticamente i controlli nelle posizioni appropriate) eGrid(Posizionare i controlli in base alle coordinate della griglia), che non verranno descritte qui.
Pygame è un modulo Python open source utilizzato specificatamente per lo sviluppo di applicazioni multimediali (come i videogiochi), che include il supporto per immagini, suoni, video, eventi, collisioni, ecc. Pygame è basato su SDL, che è un insieme di librerie di sviluppo multimediale multipiattaforma implementate in linguaggio C ed è ampiamente utilizzato nello sviluppo di giochi, simulatori, lettori, ecc. Pygame consente agli sviluppatori di giochi di non essere più vincolati al linguaggio sottostante e di concentrarsi maggiormente sulle funzioni e sulla logica del gioco.
Ora completiamo un gioco semplice. Il nome del gioco è "Big Ball Eats Small Ball". Ovviamente, il completamento di questo gioco non è nemmeno l'obiettivo capire come utilizzare i passaggi precedenti del processo. Spiegare la programmazione orientata agli oggetti e imparare a utilizzare questa idea di programmazione per risolvere problemi della vita reale.
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()
Puoi disegnare sulla finestra attraverso la funzione del modulo di disegno in pygame. La grafica che può essere disegnata include: linee, rettangoli, poligoni, cerchi, ellissi, archi, ecc. Va notato che il sistema di coordinate dello schermo imposta l'angolo superiore sinistro dello schermo come origine delle coordinate (0, 0) A destra è la direzione positiva dell'asse x e in basso è la direzione positiva dell'asse y. asse Quando si esprime la posizione o si imposta la dimensione, le nostre unità predefinite sono i pixel. Il cosiddetto pixel è un punto sullo schermo È possibile utilizzare un software di navigazione delle immagini per provare a ingrandire un'immagine più volte per vedere questi punti. La rappresentazione del colore in pygame utilizza il metodo di rappresentazione dei tre colori primari, ovvero il valore RGB del colore è specificato tramite una tupla o un elenco. Ciascun valore è compreso tra 0 e 255, poiché ciascun colore primario utilizza un bit (8 bit). Per rappresentare il valore, i tre colori equivalgono a un totale di 24 bit, che viene spesso chiamata "rappresentazione del colore a 24 bit".
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()
Se hai bisogno di caricare l'immagine direttamente nella finestra, puoi utilizzare la funzione del modulo image in pygame per caricare l'immagine, e poi renderizzare l'immagine attraverso il metodo blit dell'oggetto finestra precedentemente ottenuto. Il codice è il seguente.
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()
Quando si tratta della parola animazione, tutti la conoscono. In effetti, per ottenere effetti di animazione, il principio stesso è molto semplice, ovvero riprodurre immagini discontinue in modo continuo finché viene raggiunto un certo numero di fotogrammi al secondo. quindi è possibile produrre un effetto di animazione più fluido. Se vuoi che la pallina nel codice sopra si muova, puoi utilizzare una variabile per rappresentare la posizione della pallina, modificare la posizione della pallina nel ciclo e quindi aggiornare l'intera finestra.
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()
Di solito ci saranno molti oggetti in un gioco e la "collisione" tra questi oggetti è inevitabile, come una palla di cannone che colpisce un aereo, una scatola che colpisce il suolo, ecc. Il rilevamento delle collisioni è un problema cruciale che deve essere affrontato nella maggior parte dei giochi. Il modulo sprite (sprite animato) di pygame fornisce supporto per il rilevamento delle collisioni. Non introdurremo qui le funzioni fornite dal modulo sprite perché in realtà è molto semplice rilevare se due palline si scontrano. Devi solo verificare se la distanza tra i centri delle palline è inferiore alla somma dei raggi delle due palline. Per creare più palline, possiamo elaborare gli eventi del mouse per creare palline con colori, dimensioni e velocità di movimento casuali nel punto in cui viene fatto clic con il mouse. Naturalmente, per fare ciò, possiamo utilizzare ciò che abbiamo imparato prima di Applicare conoscenza orientata agli oggetti.
Gli eventi del mouse possono essere elaborati nel ciclo degli eventi. Il tipo di evento può essere determinato tramite l'attributo type dell'oggetto evento e la posizione del clic del mouse può essere ottenuta tramite l'attributo pos. Se vuoi gestire gli eventi della tastiera, questo è anche il posto giusto. Il metodo è simile alla gestione degli eventi del mouse.
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()
Mettendo insieme i due pezzi di codice sopra, abbiamo completato il gioco "la palla grande mangia la palla piccola" (come mostrato nell'immagine qui sotto). piccolo gioco. Questo esempio dice a tutti che con questa conoscenza puoi iniziare il tuo viaggio nello sviluppo di mini giochi. In effetti, ci sono molte aree che meritano di essere migliorate nel codice precedente. Ad esempio, il codice per aggiornare la finestra e spostare la pallina non dovrebbe essere inserito nel ciclo degli eventi Dopo aver appreso la conoscenza del multi-threading, è possibile utilizzarlo un thread in background per gestire queste cose è una scelta migliore. Se vogliamo ottenere una migliore esperienza utente, possiamo anche aggiungere musica di sottofondo al gioco e riprodurre effetti sonori quando la palla colpisce la palla. Usando il mixer e i moduli musicali di pygame, possiamo farlo facilmente Questo. Infatti, se vuoi saperne di più su pygame, il miglior tutorial è il sito ufficiale di pygame. Se non hai problemi con l'inglese, puoi andare a dare un'occhiata. Se vuoi sviluppare giochi 3D, pygame sembra non essere sufficiente. I lettori interessati allo sviluppo di giochi 3D potrebbero voler dare un'occhiata a Panda3D.
Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro
Posta[email protected]