python实现圆圈烟花_附完整源码【第21篇—python过新年】

文章目录

  • 前言
  • 效果图(动态)
  • 完整代码
  • 代码讲解
  • 总结
  • 寄语

前言

烟花是一种庆祝、欢庆或庆典活动中常见的美丽表现,它们以多彩的光芒和炫丽的形状为人们带来欢乐和惊喜。在这个项目中,我们将使用Python编程语言创建一个简单而有趣的程序,实现在屏幕上绘制出圆圈烟花的效果。

  • 利用Python的图形库(例如pygame、turtle等),在屏幕上绘制出圆形烟花的效果。
  • 实现烟花的动态效果,使其在屏幕上以一种生动活泼的方式展现。
  • 考虑添加一些额外的特效,例如烟花爆炸后的颜色变化、尾迹效果等,以提升视觉效果。

实现步骤:

  • 导入所需的图形库(例如pygame)。
  • 初始化屏幕并设置窗口大小。
  • 设计一个函数,用于绘制烟花的圆形效果。
  • 在主程序中,调用绘制烟花的函数,并在屏幕上显示出烟花效果。
  • 考虑添加烟花的动态效果,例如烟花上升、爆炸等过程。
  • 优化程序,增加一些额外的特效,提高烟花的美观程度。

效果图(动态)

python实现圆圈烟花_附完整源码【第21篇—python过新年】_第1张图片
python实现圆圈烟花_附完整源码【第21篇—python过新年】_第2张图片

完整代码

# -*- coding: utf-8 -*-

import math, random,time
import threading
import tkinter as tk
import re
#import uuid

Fireworks=[]
maxFireworks=8
height,width=600,600

class firework(object):
    def __init__(self,color,speed,width,height):
        #uid=uuid.uuid1()
        self.radius=random.randint(2,4)  #粒子半径为2~4像素
        self.color=color   #粒子颜色
        self.speed=speed  #speed是1.5-3.5秒
        self.status=0   #在烟花未爆炸的情况下,status=0;爆炸后,status>=1;当status>100时,烟花的生命期终止
        self.nParticle=random.randint(20,30)  #粒子数量
        self.center=[random.randint(0,width-1),random.randint(0,height-1)]   #烟花随机中心坐标
        self.oneParticle=[]    #原始粒子坐标(100%状态时)
        self.rotTheta=random.uniform(0,2*math.pi)  #椭圆平面旋转角

        #椭圆参数方程:x=a*cos(theta),y=b*sin(theta)
        #ellipsePara=[a,b]

        self.ellipsePara=[random.randint(30,40),random.randint(20,30)]   
        theta=2*math.pi/self.nParticle
        for i in range(self.nParticle):
            t=random.uniform(-1.0/16,1.0/16)  #产生一个 [-1/16,1/16) 的随机数
            x,y=self.ellipsePara[0]*math.cos(theta*i+t), self.ellipsePara[1]*math.sin(theta*i+t)    #椭圆参数方程
            xx,yy=x*math.cos(self.rotTheta)-y*math.sin(self.rotTheta),  y*math.cos(self.rotTheta)+x*math.sin(self.rotTheta)     #平面旋转方程
            self.oneParticle.append([xx,yy])
        
        self.curParticle=self.oneParticle[0:]     #当前粒子坐标
        self.thread=threading.Thread(target=self.extend)   #建立线程对象
        

    def extend(self):         #粒子群状态变化函数线程
        for i in range(100):
            self.status+=1    #更新状态标识
            self.curParticle=[[one[0]*self.status/100, one[1]*self.status/100] for one in self.oneParticle]   #更新粒子群坐标
            time.sleep(self.speed/50)
    
    def explode(self):
        self.thread.setDaemon(True)    #把现程设为守护线程
        self.thread.start()          #启动线程
            

    def __repr__(self):
        return ('color:{color}\n'  
                'speed:{speed}\n'
                'number of particle: {np}\n'
                'center:[{cx} , {cy}]\n'
                'ellipse:a={ea} , b={eb}\n'
                'particle:\n{p}\n'
                ).format(color=self.color,speed=self.speed,np=self.nParticle,cx=self.center[0],cy=self.center[1],p=str(self.oneParticle),ea=self.ellipsePara[0],eb=self.ellipsePara[1])


def colorChange(fire):
    rgb=re.findall(r'(.{2})',fire.color[1:])
    cs=fire.status
    
    f=lambda x,c: hex(int(int(x,16)*(100-c)/30))[2:]    #当粒子寿命到70%时,颜色开始线性衰减
    if cs>70:
        ccr,ccg,ccb=f(rgb[0],cs),f(rgb[1],cs),f(rgb[2],cs)
    else:
        ccr,ccg,ccb=rgb[0],rgb[1],rgb[2]
        
    return '#{0:0>2}{1:0>2}{2:0>2}'.format(ccr,ccg,ccb)



def appendFirework(n=1):   #递归生成烟花对象
    if n>maxFireworks or len(Fireworks)>maxFireworks:
        pass
    elif n==1:
        cl='#{0:0>6}'.format(hex(int(random.randint(0,16777215)))[2:])   # 产生一个0~16777215(0xFFFFFF)的随机数,作为随机颜色
        a=firework(cl,random.uniform(1.5,3.5),width,height)
        Fireworks.append( {'particle':a,'points':[]} )   #建立粒子显示列表,‘particle’为一个烟花对象,‘points’为每一个粒子显示时的对象变量集
        a.explode()
    else:
        appendFirework()
        appendFirework(n-1)


def show(c):
    for p in Fireworks:                #每次刷新显示,先把已有的所以粒子全部删除
        for pp in p['points']:
            c.delete(pp)
    
    for p in Fireworks:                #根据每个烟花对象,计算其中每个粒子的显示对象
        oneP=p['particle']
        if oneP.status==100:        #状态标识为100,说明烟花寿命结束
            Fireworks.remove(p)     #移出当前烟花
            appendFirework()           #新增一个烟花
            continue
        else:
            li=[[int(cp[0]*2)+oneP.center[0],int(cp[1]*2)+oneP.center[1]] for cp in oneP.curParticle]       #把中心为原点的椭圆平移到随机圆心坐标上
            color=colorChange(oneP)   #根据烟花当前状态计算当前颜色
            for pp in li:
                p['points'].append(c.create_oval(pp[0]-oneP.radius,  pp[1]-oneP.radius,  pp[0]+oneP.radius,  pp[1]+oneP.radius,  fill=color))  #绘制烟花每个粒子

    root.after(50, show,c)  #回调,每50ms刷新一次

if __name__=='__main__':
    appendFirework(maxFireworks)
    
    root = tk.Tk()
    cv = tk.Canvas(root, height=height, width=width)
    cv.create_rectangle(0, 0, width, height, fill="black")

    cv.pack()

    root.after(50, show,cv)
    root.mainloop()
import pygame
import sys
import random

# 初始化pygame
pygame.init()

# 设置窗口大小
screen_width, screen_height = 800, 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Circle Fireworks")

# 定义烟花绘制函数
def draw_firework(x, y, color):
    pygame.draw.circle(screen, color, (x, y), 10)

# 主程序
def main():
    clock = pygame.time.Clock()

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

        # 清空屏幕
        screen.fill((0, 0, 0))

        # 生成随机位置和颜色的烟花
        firework_x = random.randint(50, screen_width - 50)
        firework_y = random.randint(50, screen_height - 50)
        firework_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))

        # 绘制烟花
        draw_firework(firework_x, firework_y, firework_color)

        # 更新显示
        pygame.display.flip()

        # 控制帧率
        clock.tick(30)

if __name__ == "__main__":
    main()

代码讲解

这段代码实现了一个简单的烟花动画效果,使用了Python的tkinter库进行图形界面的展示。以下是代码的主要解析:

  1. 导入模块:

    import math, random, time
    import threading
    import tkinter as tk
    import re
    

    导入了所需的模块,包括数学计算、随机数生成、线程、图形界面和正则表达式等。

  2. 全局变量定义:

    Fireworks = []
    maxFireworks = 8
    height, width = 600, 600
    

    定义了全局变量,包括烟花列表、最大烟花数量、画布的高度和宽度。

  3. 烟花类 firework 的定义:

    class firework(object):
        # ... (详细的初始化和方法定义在这里)
    

    定义了烟花类,包括烟花的初始化、状态变化线程(extend)、爆炸方法(explode)以及__repr__方法用于对象的字符串表示。

  4. 颜色变化函数 colorChange

    def colorChange(fire):
        # ... (根据粒子状态计算颜色)
    

    根据粒子状态计算颜色,当粒子寿命到达70%时,颜色开始线性衰减。

  5. 烟花生成函数 appendFirework

    def appendFirework(n=1):
        # ... (递归生成烟花对象的函数)
    

    递归生成烟花对象,其中包括设置烟花的颜色、速度、初始坐标等信息,并启动烟花的爆炸线程。

  6. 显示函数 show

    def show(c):
        # ... (每次刷新画布,绘制烟花粒子)
    

    每次刷新画布,绘制烟花粒子,包括更新烟花状态、颜色和位置信息。

  7. 主程序入口:

    if __name__=='__main__':
        # ... (初始化烟花,创建tkinter窗口并启动刷新循环)
    

    初始化烟花,创建 tkinter 窗口,启动刷新循环,每50毫秒刷新一次画布。

总体而言,这段代码通过 tkinter 创建了一个简单的窗口,然后在窗口中显示了多个烟花的效果,通过线程和定时器实现了烟花的动画效果。

总结

这段代码实现了一个简单但趣味十足的烟花动画效果,结合了多线程和图形界面编程的知识。以下是一些总结和心得:

  1. 多线程应用: 通过使用 Python 中的 threading 模块,实现了烟花粒子的状态变化(extend方法)和动画效果。这种方式使得程序能够同时执行多个任务,提高了程序的响应性和并发性。

  2. 图形界面编程: 使用 tkinter 创建了一个简单的窗口,通过画布 Canvas 实现了动画的显示。这种方式使得程序能够在图形界面中展示烟花效果,增加了用户的可视化体验。

  3. 数学和物理模型: 通过使用数学中的椭圆参数方程和平面旋转方程,创建了烟花的粒子坐标。这种数学模型使得烟花的运动轨迹更加真实和有趣。

  4. 动画效果的控制: 通过控制粒子的状态和颜色,实现了烟花的生命周期和颜色变化效果。这种设计使得烟花的表现更加生动和多样化。

  5. 递归的使用: 通过递归方式生成烟花对象,实现了多个烟花的同时展示。这种递归生成对象的方式使得程序结构清晰,并方便了对烟花的管理和扩展。

总的来说,这个项目不仅展示了 Python 在图形界面编程和多线程方面的应用,还充分体现了程序设计中数学和物理模型的运用。通过这个项目,可以更深入地理解多线程编程、图形界面设计以及数学模型在计算机图形学中的应用。

寄语

在学习和编程的旅途中,不断挑战自己、探索新领域是非常重要的。记住,每一行代码都是一个学习的机会,每一个bug都是一个成长的机会。保持好奇心,保持对知识的渴望,永远保持学习的心态。

无论面对怎样的难题和挑战,都相信自己的能力,相信坚持不懈的努力最终会收获成功。同时,与他人合作、分享经验,共同进步,是团队中不可或缺的一部分。

编程是一门艺术,创造力是其中的灵魂。勇敢地去创造、去尝试,让你的代码成为一种表达方式,传递你的思想和激情。最重要的是,享受编程的过程,享受解决问题的乐趣。

愿你的代码能够改变世界,愿你的探索之路越走越宽,愿你的每一个项目都充满创意和成就。加油,前程似锦!

你可能感兴趣的:(python,pygame,开发语言,烟花效果,python过新年)