Python Cool Fireworks Confession Quellcode

Haben Sie für diejenigen unter Ihnen, die jeden Tag Code eingeben, jemals gedacht, dass Code auch cool und romantisch sein kann? Heute werde ich Ihnen beibringen, wie Sie mit Python ein blühendes Feuerwerk simulieren. Sie können das Programm auch jederzeit nach der Arbeit ein Feuerwerk zünden lassen.

Python Cool Fireworks Confession Source Code

Dieses interessante kleine Projekt ist nicht kompliziert, nur ein wenig Visualisierungsfähigkeiten, 100 Mit nur Mit ein paar Zeilen Python-Code und der Tkinter-Bibliothek können wir endlich den folgenden Effekt erzielen:

Nach Abschluss dieses Tutorials können Sie auch ein solches Feuerwerk erstellen.

Gesamtkonzeptüberprüfung

Unser gesamtes Konzept ist relativ einfach.

Wie im Bild oben gezeigt, simulieren wir den Explosionseffekt, indem wir ein Partikel auf dem Bildschirm in X Partikel aufteilen. Die Teilchen „dehnen“ sich aus, das heißt, sie bewegen sich mit konstanter Geschwindigkeit und in gleichen Winkeln zueinander. Dadurch können wir ein Feuerwerk in Form eines sich vergrößernden Kreises simulieren. Nach einer gewissen Zeit treten die Partikel in eine Phase des „freien Falls“ ein, in der sie beginnen, aufgrund der Schwerkraft zu Boden zu fallen, wie ein Feuerwerk, das aufblüht und dann erlischt.

(Empfohlenes Lernen: Programmier-Lernkurs)

Grundkenntnisse: Feuerwerk entwerfen mit Python und Tkinter

Hier nicht mehr Lassen Sie das gesamte mathematische Wissen auf einmal weg und wir reden über die Theorie, während wir Code schreiben. Stellen Sie zunächst sicher, dass Sie Tkinter installieren und importieren, die Standard-GUI-Bibliothek von Python, die in einer Vielzahl von Projekten und bei der Programmentwicklung weit verbreitet ist. Mit Tkinter in Python können Sie schnell GUI-Anwendungen erstellen.

import tkinter as tk
from PIL import Image, ImageTk
from time import time, sleep
from random import choice, uniform, randint
from math import sin, cos, radians

Um der Schnittstelle einen schönen Hintergrund zu verleihen, importieren wir zusätzlich zu Tkinter auch PIL für die Bildverarbeitung sowie andere Pakete wie Zeit, Zufall und Mathematik. Sie ermöglichen es uns, die Flugbahn von Feuerwerkspartikeln einfacher zu kontrollieren.

Die grundlegende Einrichtung der Tkinter-Anwendung ist wie folgt:

root = tk.Tk()

Um Tkinter zu initialisieren, müssen wir ein Tk()-Root-Widget erstellen, bei dem es sich um ein Fenster mit einer Titelleiste und Sonstigem handelt Dekorationen, die vom Fenstermanager bereitgestellt werden. Dieses Root-Widget muss erstellt werden, bevor wir andere Widgets erstellen, und es kann nur ein Root-Widget geben.

w = tk.Label(root, text="Hello Tkinter!")

Diese Codezeile enthält die Label-Komponente. Der erste Parameter im Label-Aufruf ist der Name des übergeordneten Fensters, das hier den „Root“ darstellt. Das Schlüsselwortargument „text“ gibt den anzuzeigenden Textinhalt an. Sie können auch andere Widgets aufrufen: Button, Canvas usw.

w.pack()
root.mainloop()

Die nächsten beiden Codezeilen sind wichtig. Die Verpackungsmethode besteht hier darin, Tkinter anzuweisen, die Größe des Fensters an das verwendete Widget anzupassen. Das Fenster erscheint erst, wenn wir in die Tkinter-Ereignisschleife eintreten und von root.mainloop() aufgerufen werden. Das Skript bleibt in der Ereignisschleife, bis wir das Fenster schließen.

Übersetzen Sie die Feuerwerksblüte in Code

Jetzt entwerfen wir ein Objekt, das jedes Partikel im Feuerwerksereignis darstellt. Jedes Teilchen hat einige wichtige Eigenschaften, die sein Aussehen und seine Bewegung bestimmen: Größe, Farbe, Position, Geschwindigkeit usw.

'''
particles 类
粒子在空中随机生成随机，变成一个圈、下坠、消失
属性:
    - id: 粒子的id
    - x, y: 粒子的坐标
    - vx, vy: 在坐标的变化速度
    - total: 总数
    - age: 粒子存在的时长
    - color: 颜色
    - cv: 画布
    - lifespan: 最高存在时长
'''
class part:
    def __init__(self, cv, idx, total, explosion_speed, x=0., y=0., vx = 0., vy = 0., size=2., color = 'red', lifespan = 2, **kwargs):
        self.id = idx
        self.x = x
        self.y = y
        self.initial_speed = explosion_speed
        self.vx = vx
        self.vy = vy
        self.total = total
        self.age = 0self.color = color
        self.cv = cv
        self.cid = self.cv.create_oval(
            x - size, y - size, x + size,
            y + size, fill=self.color)
        self.lifespan = lifespan

Wenn wir an die ursprüngliche Idee zurückdenken, werden wir erkennen, dass sichergestellt werden muss, dass alle Partikel jedes Feuerwerks drei verschiedene Phasen durchlaufen müssen, nämlich „Ausdehnung“, „Fall“ und „Verschwinden“. . Also fügen wir der Partikelklasse einige weitere Bewegungsfunktionen hinzu, wie unten gezeigt:

def update(self, dt):
    # 粒子膨胀if self.alive() and self.expand():
        move_x = cos(radians(self.id*360/self.total))*self.initial_speed
        move_y = sin(radians(self.id*360/self.total))*self.initial_speed
        self.vx = move_x/(float(dt)*1000)
        self.vy = move_y/(float(dt)*1000)
        self.cv.move(self.cid, move_x, move_y)
    # 以自由落体坠落
    elif self.alive():
        move_x = cos(radians(self.id*360/self.total))
        # we technically don't need to update x, y because move will do the job
        self.cv.move(self.cid, self.vx + move_x, self.vy+GRAVITY*dt)
        self.vy += GRAVITY*dt
    # 如果粒子的生命周期已过，就将其移除
    elif self.cid is not None:
        cv.delete(self.cid)
        self.cid = None

Das bedeutet natürlich auch, dass wir definieren müssen, wie lange jedes Partikel blüht und wie lange es fällt. In diesem Teil müssen wir einige weitere Parameter ausprobieren, um den besten visuellen Effekt zu erzielen.

# 定义膨胀效果的时间帧
def expand (self):
    return self.age <= 1.2
# 检查粒子是否仍在生命周期内
def alive(self):
    return self.age <= self.lifespan

Verwendung der Tkinter-Simulation

Jetzt konzipieren wir die Bewegung von Partikeln, aber es ist offensichtlich, dass ein Feuerwerk nicht nur ein Partikel haben kann und eine Feuerwerksshow nicht nur ein Partikel haben kann ein Feuerwerk. Unser nächster Schritt besteht darin, Python und Tkinter kontinuierlich Partikel in den Himmel „feuern“ zu lassen, und zwar auf eine Weise, die wir kontrollieren können.

An diesem Punkt müssen wir von der Bedienung eines Partikels auf die Anzeige mehrerer Feuerwerkskörper und mehrerer Partikel in jedem Feuerwerk auf dem Bildschirm umsteigen.

Unsere Lösung ist wie folgt: Erstellen Sie eine Liste. Jede Unterliste ist ein Feuerwerk, das eine Liste von Partikeln enthält. Die Beispiele in jeder Liste haben die gleichen XY-Koordinaten, die gleiche Größe, die gleiche Farbe und die gleiche Anfangsgeschwindigkeit.

numb_explode = randint(6,10)
# 为所有模拟烟花绽放的全部粒子创建一列列表
for point in range(numb_explode):
    objects = []
    x_cordi = randint(50,550)
    y_cordi = randint(50, 150)       
    size = uniform (0.5,3)
    color = choice(colors)
    explosion_speed = uniform(0.2, 1)
    total_particles = randint(10,50)
    for i in range(1,total_particles):
        r = part(cv, idx = i, total = total_particles, explosion_speed = explosion_speed, x = x_cordi, y = y_cordi, 
        color=color, size = size, lifespan = uniform(0.6,1.75))
        objects.append(r)
explode_points.append(objects)

Unser nächster Schritt besteht darin, sicherzustellen, dass die Partikeleigenschaften regelmäßig aktualisiert werden. Hier stellen wir die Partikel so ein, dass sie ihren Status alle 0,01 Sekunden aktualisieren und die Aktualisierung nach 1,8 Sekunden beenden (das bedeutet, dass jedes Partikel 1,6 Sekunden lang existiert, wovon 1,2 Sekunden der „blühende“ Zustand und 0,4 Sekunden der „fallende“ Zustand sind. 0,2 Sekunden auf der Kante, bevor Tkinter es vollständig entfernt).

total_time = .0
# 在1.8秒时间帧内保持更新
while total_time < 1.8:
    sleep(0.01)
    tnew = time()
    t, dt = tnew, tnew - t
    for point in explode_points:
        for part in point:
            part.update(dt)
    cv.update()
    total_time += dt

现在，我们只需将最后两个gist合并为一个能被Tkinter调用的函数，就叫它simulate()吧。该函数会展示所有的数据项，并根据我们设置的时间更新每个数据项的属性。在我们的主代码中，我们会用一个alarm处理模块after()调用此函数，after()会等待一定的时间，然后再调用函数。

我们这里设置让Tkinter等待100个单位（1秒钟）再调取simulate。

if __name__ == '__main__':
    root = tk.Tk()
    cv = tk.Canvas(root, height=600, width=600)
    # 绘制一个黑色背景
    cv.create_rectangle(0, 0, 600, 600, fill="black")
    cv.pack()
    root.protocol("WM_DELETE_WINDOW", close)
    # 在1秒后才开始调用stimulate()
    root.after(100, simulate, cv)
    root.mainloop()

好了，这样我们就用Python代码放了一场烟花秀：

本文只一个简单版本，等进一步熟悉Tkinter后，还可以添加更多颜色更漂亮的背景照片，让代码为你绽放更美的烟花！

以下是全部代码：

import tkinter as tk
from PIL import Image, ImageTk
from time import time, sleep
from random import choice, uniform, randint
from math import sin, cos, radians
# 模拟重力
GRAVITY = 0.05
# 颜色选项（随机或者按顺序）
colors = ['red', 'blue', 'yellow', 'white', 'green', 'orange', 'purple', 'seagreen', 'indigo', 'cornflowerblue']
'''
particles 类
粒子在空中随机生成随机，变成一个圈、下坠、消失
属性:
    - id: 粒子的id
    - x, y: 粒子的坐标
    - vx, vy: 在坐标的变化速度
    - total: 总数
    - age: 粒子存在的时长
    - color: 颜色
    - cv: 画布
    - lifespan: 最高存在时长
'''
class Particle:
    def __init__(self, cv, idx, total, explosion_speed, x=0., y=0., vx=0., vy=0., size=2., color='red', lifespan=2,
                 **kwargs):
        self.id = idx
        self.x = x
        self.y = y
        self.initial_speed = explosion_speed
        self.vx = vx
        self.vy = vy
        self.total = total
        self.age = 0self.color = color
        self.cv = cv
        self.cid = self.cv.create_oval(
            x - size, y - size, x + size,
            y + size, fill=self.color)
        self.lifespan = lifespan
    def update(self, dt):
        self.age += dt
        # 粒子范围扩大
        if self.alive() and self.expand():
            move_x = cos(radians(self.id * 360 / self.total)) * self.initial_speed
            move_y = sin(radians(self.id * 360 / self.total)) * self.initial_speed
            self.cv.move(self.cid, move_x, move_y)
            self.vx = move_x / (float(dt) * 1000)
        # 以自由落体坠落
        elif self.alive():
            move_x = cos(radians(self.id * 360 / self.total))
            # we technically don't need to update x, y because move will do the job
            self.cv.move(self.cid, self.vx + move_x, self.vy + GRAVITY * dt)
            self.vy += GRAVITY * dt
        # 移除超过最高时长的粒子
        elif self.cid is not None:
            cv.delete(self.cid)
            self.cid = None
    # 扩大的时间
    def expand (self):
        return self.age <= 1.2
    # 粒子是否在最高存在时长内
    def alive(self):
        return self.age <= self.lifespan
&#39;&#39;&#39;
循环调用保持不停
&#39;&#39;&#39;
def simulate(cv):
    t = time()
    explode_points = []
    wait_time = randint(10, 100)
    numb_explode = randint(6, 10)
    # 创建一个所有粒子同时扩大的二维列表
    for point in range(numb_explode):
        objects = []
        x_cordi = randint(50, 550)
        y_cordi = randint(50, 150)
        speed = uniform(0.5, 1.5)
        size = uniform(0.5, 3)
        color = choice(colors)
        explosion_speed = uniform(0.2, 1)
        total_particles = randint(10, 50)
        for i in range(1, total_particles):
            r = Particle(cv, idx=i, total=total_particles, explosion_speed=explosion_speed, x=x_cordi, y=y_cordi,
                         vx=speed, vy=speed, color=color, size=size, lifespan=uniform(0.6, 1.75))
            objects.append(r)
        explode_points.append(objects)
    total_time = .0
    # 1.8s内一直扩大
    while total_time < 1.8:
        sleep(0.01)
        tnew = time()
        t, dt = tnew, tnew - t
        for point in explode_points:
            for item in point:
                item.update(dt)
        cv.update()
        total_time += dt
    # 循环调用
    root.after(wait_time, simulate, cv)
def close(*ignore):
    """退出程序、关闭窗口"""
    global root
    root.quit()
if __name__ == &#39;__main__&#39;:
    root = tk.Tk()
    cv = tk.Canvas(root, height=400, width=600)
    # 选一个好看的背景会让效果更惊艳！
    image = Image.open("./image.jpg")
    photo = ImageTk.PhotoImage(image)
    cv.create_image(0, 0, image=photo, anchor=&#39;nw&#39;)
    cv.pack()
    root.protocol("WM_DELETE_WINDOW", close)
    root.after(100, simulate, cv)
    root.mainloop()

众多python培训视频，尽在python学习网，欢迎在线学习！

Das obige ist der detaillierte Inhalt vonPython Cool Fireworks Confession Quellcode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!