今年跨年一起去看python烟花秀吧！

点击关注

绽放一场属于你的烟花秀

引子

in early winter

“希望在奔赴未来的路上,我们有着生生不息的热爱,如星灿烂,如风自由”

不知不觉又要到一年的最后啦，今年的你是否还记得年初时和自己的约定呢？去年陪你跨年的那个人今年还在你身边吗？新的一年就要来喽，让我们一起期待全新的四季吧！小编给大家准备了一场精彩的烟花秀哦，一起来看看吧~

Pygame入门

in early winter

pygame是一个基于Python的开源游戏开发库，它提供了一系列用于开发2D游戏的工具和函数。下面是关于如何入门pygame的一些基本信息。

首先，你需要安装pygame库。你可以在命令行中使用以下命令进行安装：

          
              

            pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pygame
          
        

接下来，你需要创建一个窗口来显示你的游戏。首先，导入pygame库，并在代码的开始处初始化pygame：

            
import pygame
            
pygame.init()
        

然后，创建一个窗口并设置宽度和高度：

            
screen_width = 800
            
screen_height = 600
            
screen = pygame.display.set_mode((screen_width, screen_height))
        

接着，你可以设置窗口的标题：

          
              

            pygame.display.set\_caption("My Game")
          
        

现在，你可以进入游戏循环，在循环中处理游戏中的事件：

            
running = True
            
while running:
            
    for event in pygame.event.get():
            
        if event.type == pygame.QUIT:
            
            running = False
        

在游戏循环中，我们使用pygame.event.get()来获取所有的事件并逐个处理。在上述代码中，如果接收到一个QUIT事件（即点击窗口的关闭按钮），则退出游戏循环。

在游戏循环中，你还可以进行一些其他的操作，例如绘制图形和更新游戏状态。例如，你可以使用以下代码在屏幕上绘制一个红色的矩形：

            
rect_width = 50
            
rect_height = 50
            
rect_x = 300
            
rect_y = 200
            
rect_color = (255, 0, 0)  # 红色
            
pygame.draw.rect(screen, rect_color, (rect_x, rect_y, rect_width, rect_height))
        

最后，你需要在游戏循环的最后更新屏幕：

          
              

            pygame.display.flip()
          
        

以上代码可以将绘制的图形更新到屏幕上。

除了绘制图形，pygame还提供了许多其他有用的功能，例如处理键盘和鼠标输入，播放声音和音乐，以及使用图像和动画等等。

总之，这是一个关于如何入门pygame的简单指南。通过学习和实践，你可以更深入地掌握pygame，并开始开发自己的游戏。希望你能享受pygame的乐趣！

跨年烟花秀

in early winter

环境搭建

Warm in early winter

如何下载安装PyCharm并搭建Python开发环境

关于运行Python代码的方法以及遇到问题的解决方案（计算机小白篇）

安装Pygame库

Warm in early winter

如果遇到下面这个问题

需要在终端输入 pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pygame 安装pygame库

出现如下运行结果说明安装成功啦

再运行程序就没问题喽~

完整代码

Warm in early winter

            
import pygame as pg
            
import random as ra
            
import math
            
pg.init()
            
pg.display.set_caption("🎇")
            
winScreen = pg.display.Info()
            
screenWidth = winScreen.current_w
            
screenHeight = winScreen.current_h
            
vector = pg.math.Vector2
            
trail_colors = [(45, 45, 45), (60, 60, 60), (75, 75, 75), (125, 125, 125), (150, 150, 150)]
            
# 烟花类
            
class Firework:
            
    def __init__(self):
            
        # 随机生成颜色
            
        self.colour = (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))
            
        # 随机生成三种颜色
            
        self.colours = (
            
            (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255)),
            
            (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255)),
            
            (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))
            
        )
            
        # 生成一个表示发射出的火花的粒子对象
            
        self.firework = Particle(ra.randint(0,screenWidth), screenHeight, True, self.colour)
            
        # 初始化爆炸状态为 False
            
        self.exploded = False
            
        self.particles = []
            
        # 爆炸产生的粒子数量范围
            
        self.min_max_particles = vector(666, 999)
            
    def update(self, win):
            
        g = vector(0, ra.uniform(0.15, 0.4))
            
        if not self.exploded:
            
            # 给发射出的火花施加重力
            
            self.firework.apply_force(g)
            
            self.firework.move()
            
            for tf in self.firework.trails:
            
                tf.show(win)
            
            self.show(win)
            
            if self.firework.vel.y >= 0:
            
                self.exploded = True
            
                self.explode()
            
        else:
            
            for particle in self.particles:
            
                # 给爆炸产生的粒子施加随机力
            
                particle.apply_force(vector(g.x + ra.uniform(-1, 1) / 20, g.y / 2 + (ra.randint(1, 8) / 100)))
            
                particle.move()
            
                for t in particle.trails:
            
                    t.show(win)
            
                particle.show(win)
            
    def explode(self):
            
        amount = ra.randint(int(self.min_max_particles.x), int(self.min_max_particles.y))
            
        for i in range(amount):
            
            # 在爆炸位置生成粒子对象并添加到粒子列表中
            
            self.particles.append(Particle(self.firework.pos.x, self.firework.pos.y, False, self.colours))
            
    def show(self, win):
            
        # 绘制发射出的火花
            
        pg.draw.circle(win, self.colour, (int(self.firework.pos.x), int(self.firework.pos.y)), self.firework.size)
            
    def remove(self):
            
        if self.exploded:
            
            for p in self.particles:
            
                if p.remove is True:
            
                    self.particles.remove(p)
            
            if len(self.particles) == 0:
            
                return True
            
            else:
            
                return False
            
# 粒子类
            
class Particle:
            
    def __init__(self, x, y, firework, colour):
            
        self.firework = firework
            
        self.pos = vector(x, y)
            
        self.origin = vector(x, y)
            
        self.radius = 25
            
        self.remove = False
            
        self.explosion_radius = ra.randint(15, 25)
            
        self.life = 0
            
        self.acc = vector(0, 0)
            
        self.trails = []
            
        self.prev_posx = [-10] * 10
            
        self.prev_posy = [-10] * 10
            
        if self.firework:
            
            self.vel = vector(0, -ra.randint(17, 20))
            
            self.size = 5
            
            self.colour = colour
            
            for i in range(5):
            
                self.trails.append(Trail(i, self.size, True))
            
        else:
            
            self.vel = vector(ra.uniform(-1, 1), ra.uniform(-1, 1))
            
            self.vel.x *= ra.randint(7, self.explosion_radius + 2)
            
            self.vel.y *= ra.randint(7, self.explosion_radius + 2)
            
            self.size = ra.randint(2, 4)
            
            self.colour = ra.choice(colour)
            
            for i in range(5):
            
                self.trails.append(Trail(i, self.size, False))
            
    def apply_force(self, force):
            
        # 施加力
            
        self.acc += force
            
    def move(self):
            
        if not self.firework:
            
            # 爆炸产生的粒子减速
            
            self.vel.x *= 0.8
            
            self.vel.y *= 0.8
            
        self.vel += self.acc
            
        self.pos += self.vel
            
        self.acc *= 0
            
        if self.life == 0 and not self.firework:
            
            # 判断是否超出爆炸半径
            
            distance = math.sqrt((self.pos.x - self.origin.x) ** 2 + (self.pos.y - self.origin.y) ** 2)
            
            if distance > self.explosion_radius:
            
                self.remove = True
            
        self.decay()
            
        self.trail_update()
            
        self.life += 1
            
    def show(self, win):
            
        # 绘制粒子
            
        pg.draw.circle(win, (self.colour[0], self.colour[1], self.colour[2], 0), (int(self.pos.x), int(self.pos.y)), self.size)
            
    def decay(self):
            
        if 50 > self.life > 10:
            
            ran = ra.randint(0, 30)
            
            if ran == 0:
            
                self.remove = True
            
        elif self.life > 50:
            
            ran = ra.randint(0, 5)
            
            if ran == 0:
            
                self.remove = True
            
    def trail_update(self):
            
        self.prev_posx.pop()
            
        self.prev_posx.insert(0, int(self.pos.x))
            
        self.prev_posy.pop()
            
        self.prev_posy.insert(0, int(self.pos.y))
            
        for n, t in enumerate(self.trails):
            
            if t.dynamic:
            
                t.get_pos(self.prev_posx[n + 1], self.prev_posy[n + 1])
            
            else:
            
                t.get_pos(self.prev_posx[n + 5], self.prev_posy[n + 5])
            
# 痕迹类
            
class Trail:
            
    def __init__(self, n, size, dynamic):
            
        self.pos_in_line = n
            
        self.pos = vector(-10, -10)
            
        self.dynamic = dynamic
            
        if self.dynamic:
            
            self.colour = trail_colors[n]
            
            self.size = int(size - n / 2)
            
        else:
            
            self.colour = (255, 255, 200)
            
            self.size = size - 2
            
            if self.size < 0:
            
                self.size = 0
            
    def get_pos(self, x, y):
            
        self.pos = vector(x, y)
            
    def show(self, win):
            
        # 绘制痕迹
            
        pg.draw.circle(win, self.colour, (int(self.pos.x), int(self.pos.y)), self.size)
            
def update(win, fireworks):
            
    for fw in fireworks:
            
        fw.update(win)
            
        if fw.remove():
            
            fireworks.remove(fw)
            
    pg.display.update()
            
def fire():
            
    screen = pg.display.set_mode((screenWidth, screenHeight - 66))
            
    clock = pg.time.Clock()
            
    fireworks = [Firework() for i in range(2)]
            
    running = True
            
    # 加载字体
            
    font = pg.font.SysFont("comicsansms", 99)
            
    # 渲染文本
            
    text = "Happy New Year!"
            
    text_color = (255, 190, 200)  # 字体颜色
            
    rendered_text = font.render(text, True, text_color)
            
    while running:
            
        clock.tick(99)
            
        for event in pg.event.get():
            
            if event.type == pg.QUIT:
            
                running = False
            
        # 计算文本位置
            
        text_width = rendered_text.get_width()
            
        text_height = rendered_text.get_height()
            
        text_x = (screenWidth - text_width) // 2
            
        text_y = (screenHeight - text_height) // 2 - 99
            
        screen.fill((20, 20, 30))
            
        # 绘制文本
            
        screen.blit(rendered_text, (text_x, text_y))
            
        if ra.randint(0, 10) == 1:
            
            fireworks.append(Firework())
            
        update(screen, fireworks)
            
    pg.quit()
            
    quit()
            
if __name__ == "__main__":
            
    fire()
        

嘿嘿，小编偷偷跟你说喔，在公众号的对话框里回复“python013”可以下载完整代码哦~

❤ 提取码：pps7

❤

程序分析

Warm in early winter

这段代码使用Pygame库实现了一个烟花动画效果。下面对代码进行详细分析：

0 1

导入了需要用到的模块：

• pygame：用于创建游戏窗口、处理游戏逻辑和绘制图形。
• random：用于生成随机数。
• math：用于进行数学计算。

0 2

初始化Pygame，并设置窗口标题为"🎇"。

0 3

获取当前屏幕的宽度和高度，用于设置游戏窗口的大小。

0 4

定义了一个列表trail\_colors，用于存储烟花的尾迹颜色。

0 5

定义了一个烟花类Firework，用于表示烟花对象。具体包含以下属性和方法：

• \_\_init\_\_(self)：初始化烟花对象，随机生成烟花的颜色和三种颜色。
• update(self, win)：更新烟花的状态，包括烟花的运动和爆炸效果。
• explode(self)：触发烟花的爆炸效果，生成爆炸产生的粒子对象。
• show(self, win)：在游戏窗口中绘制烟花。
• remove(self)：判断烟花是否需要被移除。

0 6

定义了一个粒子类Particle，用于表示粒子对象。具体包含以下属性和方法：

• \_\_init\_\_(self, x, y, firework, colour)：初始化粒子对象，根据粒子的类型和颜色。
• apply\_force(self, force)：施加力到粒子上。
• move(self)：控制粒子的运动。
• show(self, win)：在游戏窗口中绘制粒子。
• decay(self)：控制粒子的衰减效果。
• trail\_update(self)：更新粒子的痕迹。

0 7

定义了一个痕迹类Trail，用于表示粒子的痕迹。具体包含以下属性和方法：

• \_\_init\_\_(self, n, size, dynamic)：初始化痕迹对象，根据痕迹的位置和类型。
• get\_pos(self, x, y)：更新痕迹的位置。
• show(self, win)：在游戏窗口中绘制痕迹。

0 8

定义了一个update函数，用于更新游戏窗口中的烟花效果：

• 遍历烟花列表，调用烟花对象的update方法更新烟花的状态。
• 如果烟花需要被移除，则从烟花列表中移除。

0 9

定义了一个fire函数，用于开始游戏并创建游戏窗口，处理游戏的主循环和事件处理：

• 创建游戏窗口，设置窗口大小为屏幕宽度和高度减去66。
• 加载字体和渲染文本。（注意只能写英文或数字哦）
• 进入游戏主循环，处理事件。
• 在游戏窗口中绘制文本。
• 随机生成烟花并添加到烟花列表中。
• 调用update函数更新游戏窗口中的烟花效果。

10

在\_\_main\_\_函数中调用fire函数，开始发射烟花。

精彩推荐

in early winter

张万森，下雪了（Python）

这棵python圣诞树有亿点好看（含圣诞祝福）

C语言满屏飘字表白代码（可修改文案）

Python李峋同款跳动的爱心代码（可写字版）

一起来看python流星雨吧！（含表白界面）

写在后面

in early winter

我是一只有趣的兔子，感谢你的喜欢！