The pace of the Spring Festival is getting closer and closer. During the Spring Festival, many places will set off fireworks to increase the festival atmosphere. However, due to the intensification of environmental pollution, fireworks have been banned in many places in recent years. In order to make up for this regret, in this article, we will take a look at how to use Python to realize a fireworks show.

realization

Python libraries used for function implementation include tkinter, PIL, time, random and math. If the third library has not been installed before, use PIP install pilot to install it.

First, we use tkinter to create a canvas. We can choose a suitable picture as the background according to our preferences. The code is as follows:

root = tk.Tk()
# Draw a canvas
cv = tk.Canvas(root, height=457, width=690)
# Background map
image = Image.open("bg.jpeg")
photo = ImageTk.PhotoImage(image)
# Draw a picture on the drawing board
cv.create_image(0, 0, image=photo, anchor='nw')
cv.pack()

Look at the effect

 

Then we will realize the effect of fireworks and display it on the canvas. First, define a fireworks class fireworks, which mainly includes initialization methods and update data methods.

The main parameters of the initialization method include: fireworks blooming coordinate axis, speed, color, particle number and time, etc. the code is implemented as follows:

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
	# Fireworks bloom x-axis
	self.x = x
	# Fireworks bloom x-axis
	self.y = y
	self.initial_speed = explosion_speed
	# External x-axis speed
	self.vx = vx
	# External y-axis speed
	self.vy = vy
	# Number of particles in bloom
	self.total = total
	# Dwell time
	self.age = 0
	# colour
	self.color = color
	# canvas
	self.cv = cv
	self.cid = self.cv.create_oval(x - size, y - size, x + size, y + size,
	fill=self.color)
	self.lifespan = lifespan

After the fireworks are set off, you need to refresh. Take a look at the update method. The code implementation is as follows:

def update(self, dt):
	self.age += dt
	# Particle expansion
	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)
	# Expand to maximum drop
	elif self.alive():
		move_x = cos(radians(self.id * 360 / self.total))
		self.cv.move(self.cid, self.vx + move_x, self.vy + 0.5 * dt)
		self.vy += 0.5 * dt
	# Expired removal
	elif self.cid is not None:
		cv.delete(self.cid)
		self.cid = None

Next, let's look at the implementation of fireworks discharge. The main elements include: the number of fireworks, the range and speed of explosion, residence time and refresh time. The code implementation is as follows:

def ignite(cv):
    t = time()
    # Fireworks list
    explode_points = []
    wait_time = randint(10, 100)
    # Number of explosions
    numb_explode = randint(6, 10)
    for point in range(numb_explode):
        # Explosive particle list
        objects = []
        # Explosion x-axis
        x_cordi = randint(50, 550)
        # Explosion y-axis
        y_cordi = randint(50, 150)
        speed = uniform(0.5, 1.5)
        size = uniform(0.5, 3)
        color = choice(colors)
        # Explosion blooming speed
        explosion_speed = uniform(0.2, 1)
        # Number of particles and radius of explosion
        total_particles = randint(10, 50)
        for i in range(1, total_particles):
            r = fireworks(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))
            # Add to particle list
            objects.append(r)
        # Add particle list to fireworks list
        explode_points.append(objects)
    total_time = .0
    # Keep updated within 1.8 second time frame
    while total_time < 1.8:
        # Pause the screen for 0.01s
        sleep(0.01)
        # Refresh time
        tnew = time()
        t, dt = tnew, tnew - t
        # Traverse the fireworks list
        for point in explode_points:
            # Traverse the list of particles in fireworks
            for item in point:
                # Update time
                item.update(dt)
        # Refresh page
        cv.update()
        total_time += dt
    root.after(wait_time, ignite, cv)

Finally, let's look at the effect:

summary

In this article, we use Python to realize the special effects of fireworks. If you are interested, you can try it yourself. Finally, I wish you progress every day!! The most important thing to learn Python is mentality. We are bound to encounter many problems in the process of learning. We may not be able to solve them if we want to break our head. This is normal. Don't rush to deny yourself and doubt yourself. If you have difficulties in learning at the beginning and want to find a python learning and communication environment, you can join us, receive learning materials and discuss together.