Python 绘制动态跳动爱心｜情人节专属浪漫代码，新手零基础也能上手

马上就是情人节，程序员的浪漫从一行行代码开始！今天分享一款纯 Python 内置库实现的动态跳动爱心，无需复杂第三方依赖，黑色背景搭配粒子化爱心，自带自然的跳动节奏和柔和光晕，既适合送给心仪的人制造惊喜，也能作为 Python 基础练手案例。本文全程保姆级文本解析 + 代码注释双保障，从环境搭建到代码逻辑逐字拆解，纯新手也能跟着一步步实现，轻松拿捏编程浪漫～

这是最近粉丝私信求表白代码的聊天记录 —— 情人节 / 过年想给心仪的人制造浪漫，用代码做一份专属爱心礼物再合适不过，安排！

一、效果预览

运行代码后会直接弹出640×480的独立图形窗口，黑色背景搭配粒子化粉色爱心，实现沉浸式浪漫视觉效果，核心效果如下：

二、环境准备

本案例基于Python 3.8及以上版本开发，仅使用Python内置标准库，无需额外安装第三方包，核心需准备「Python解释器+代码编辑器」，并掌握基础的模块导入方法，以下是一步不落的详细准备步骤，零基础也能轻松落地！

2.1 安装Python解释器

Python解释器是执行Python代码的核心载体，无解释器代码无法运行，推荐安装3.8/3.9/3.10版本（兼容性最佳，无版本冲突）：

• 【保姆级安装教程】：不会安装的小伙伴直接查看我的专属教程：https://blog.csdn.net/zsh_1314520/article/details/156536391，从下载到环境配置一步到位；
• 【安装包福利】：不想自己找资源、怕下载到非纯净版的，关注博主后私信，直接发你Python全套纯净安装包，解压即可用，免配置、免折腾；
• 【关键安装要求】：安装时务必勾选「Add Python to PATH」选项，将Python添加到系统环境变量，否则终端/编辑器无法识别Python命令，后续运行代码会报错。

2.2 安装PyCharm编辑器

纯文本编辑器（记事本/Notepad++）虽能写代码，但无代码高亮、一键运行、语法检查功能，新手极易因拼写/缩进错误出错，强烈推荐PyCharm社区版（免费、功能足够、新手友好）：

• 【安装教程】：上述教程链接中包含PyCharm的完整安装和基础使用步骤，跟着操作即可；
• 【安装包福利】：同样可私信博主领取PyCharm社区版安装包，适配Windows/Mac双系统；
• 【核心优势】：代码语法高亮、错误实时提醒、一键运行、代码自动补全，大幅降低新手写代码的难度，提升效率。

2.3 环境验证（确保Python+PyCharm可正常使用）

安装完成后必须验证环境，避免后续运行代码出错，步骤如下：

2.4 核心模块导入说明（本案例所有依赖，无额外安装）

本案例仅使用Python内置标准库，安装Python后自带，无需通过pip install命令安装，直接在代码首行用import关键字导入即可，以下是每个模块的核心作用、导入方式及使用场景，必须理解：

2.5 新建Python文件（准备写/粘贴代码）

在已创建的PyCharm空白项目中，右键项目目录 -> 「New -> Python File」，新建Python文件（命名任意，如dynamic_heart.py，后缀必须为.py，否则不属于Python文件，无法运行），新建完成后即可在文件中编写或粘贴代码。

三、核心实现原理

在查看代码和详细解析前，先理解动态爱心的整体实现逻辑，做到“知其然，更知其所以然”，而非单纯复制粘贴：

简单总结：数学公式定爱心形状，tkinter做图形展示载体，随机数打造粒子效果，正弦曲线控制跳动节奏，逐帧渲染实现动态视觉。

四、代码详解

本案例的代码按功能模块划分为5个核心部分，各模块各司其职、相互配合，最终实现动态跳动爱心效果，以下是对每个模块的超详细文本解析，结合代码中的注释，让零基础新手也能彻底理解每一部分的作用和逻辑！

4.1 全局常量配置区

这是代码的最开头部分，定义了所有可直接修改的常量，无需理解复杂逻辑，直接修改数值就能调整爱心样式、画布大小，是新手最容易上手定制的部分，每个常量的具体作用如下：

• CANVAS_WIDTH/CANVAS_HEIGHT：定义画布（即弹出的图形窗口）的宽和高，单位为像素，数值越大窗口越大；
• CANVAS_CENTER_X/CANVAS_CENTER_Y：通过画布宽高计算出画布的中心坐标，目的是让爱心绘制在画布正中心（tkinter画布的原点默认在左上角，不偏移会导致爱心显示在角落）；
• IMAGE_ENLARGE：爱心的基础缩放比例，笛卡尔心形公式生成的原始坐标点尺寸极小，必须缩放后才能在画布上清晰显示，数值越大爱心整体越大；
• HEART_COLOR：爱心粒子的颜色，使用16进制色值表示，可直接替换为其他颜色（如正红色#FF0000、深紫色#9370DB）。

4.2 核心工具函数

这部分包含4个独立的工具函数，是实现爱心形状生成、粒子扩散、跳动节奏控制的基础，为后续的爱心核心类提供底层功能支持，每个函数的解析如下：

4.2.1 heart_function(t, shrink_ratio=IMAGE_ENLARGE)

• 核心作用：根据笛卡尔心形公式，通过传入的弧度值t，计算出爱心的单个坐标点，遍历0-2π的弧度值即可生成完整爱心轮廓，是爱心形状的核心函数；
• 参数说明：t为弧度值（范围0-2π）；shrink_ratio为缩放比例，默认调用全局常量IMAGE_ENLARGE，也可手动传入数值；
• 关键逻辑：先通过笛卡尔心形公式计算原始坐标，再缩放坐标适配画布尺寸，最后偏移坐标让爱心居中，最终返回整数像素坐标（tkinter画布的坐标必须为整数，不能是浮点数）。

4.2.2 scatter_inside(x, y, beta=0.15)

• 核心作用：让爱心的基础坐标点向画布中心随机扩散，生成粒子效果，是打造粒子化爱心的关键函数；
• 参数说明：x/y为爱心基础坐标点；beta为扩散系数，数值越小扩散范围越小，粒子越密集，反之粒子越稀疏；
• 关键逻辑：通过对数随机数生成符合自然分布的扩散比例，计算出点向画布中心的偏移量，原始坐标减去偏移量，得到扩散后的新坐标，实现点“向中心聚集”的粒子效果。

4.2.3 shrink(x, y, ratio)

• 核心作用：让坐标点向画布中心收缩，专门用于生成爱心外围的光晕效果，无此函数则爱心无光晕，视觉效果更单调；
• 参数说明：x/y为爱心基础坐标点；ratio为收缩比例，数值越大收缩效果越明显；
• 关键逻辑：计算点到画布中心的“收缩力”，距离中心越远的点，收缩力越大，以此生成自然、贴合爱心轮廓的光晕基础轮廓。

4.2.4 curve(p)

• 核心作用：生成周期性的正弦曲线，返回随参数p变化的缩放比例值，是控制爱心跳动节奏的核心函数；
• 参数说明：p为随帧数递增的参数，用于控制正弦曲线的变化；
• 关键逻辑：利用正弦函数sin的周期性往复特性，生成在一定范围内循环变化的缩放比例值，为后续爱心粒子的缩放提供依据，实现“收缩-扩张”的跳动效果。

4.3 Heart核心类

这部分是整个案例的核心逻辑封装，采用Python面向对象编程的思想，将爱心的点集合构建、帧数据预计算、粒子渲染等所有核心逻辑封装为一个类，让代码结构更清晰、便于维护和后续拓展，类中的每个方法分工明确，解析如下：

4.3.1 __init__ 初始化方法

• 核心作用：创建爱心所需的各类点集合，指定爱心一个跳动周期的总帧数，调用build方法构建基础点集合，并预计算所有帧的粒子点数据；
• 关键优化点：提前预计算所有帧的点数据，而非程序运行时实时计算，能避免实时计算导致的画面卡顿，让爱心渲染更流畅，这是提升程序性能的重要技巧；
• 核心属性说明：
  • _points：原始爱心轮廓点集合（使用set集合保证无重复点），用于确定爱心的基础形状；
  • _edge_diffusion_points：爱心边缘扩散点集合，用于柔化爱心边缘，避免轮廓生硬；
  • _center_diffusion_points：爱心中心扩散点集合，用于填充爱心内部，让爱心成为饱满的实体；
  • all_points：字典类型，键为帧数，值为对应帧的粒子点列表（包含x坐标、y坐标、粒子大小），存储所有帧的渲染数据。

4.3.2 build(number) 点集合构建方法

• 核心作用：构建爱心的三类基础点集合（原始点、边缘扩散点、中心扩散点），是生成粒子化爱心的基础，无此方法则爱心仅为单一轮廓；
• 参数说明：number为原始爱心轮廓点的数量，数值越大爱心轮廓越清晰、粒子越密集；
• 分步骤逻辑：
• 生成原始点：随机生成0-2π的弧度值，调用heart_function计算对应坐标，添加到原始点集合；
• 生成边缘扩散点：为每个原始点生成3个小系数扩散点，柔化爱心边缘；
• 生成中心扩散点：从原始点中随机选取，生成4000个大系数扩散点，填充爱心内部。

4.3.3 calc_position(x, y, ratio) 静态方法

• 核心作用：根据当前帧的缩放比例，计算粒子点的新坐标，让所有粒子点按比例同步偏移，实现爱心的动态跳动；
• 参数说明：x/y为粒子点原始坐标；ratio为当前帧的缩放比例（由curve函数生成）；
• 关键逻辑：计算点到画布中心的“跳动力”，距离中心越远的点，跳动幅度越大，让爱心跳动更有立体感；在偏移量中加入轻微随机值，让粒子跳动更自然，避免机械、重复的跳动效果。

4.3.4 calc(generate_frame) 帧数据预计算方法

• 核心作用：预计算指定帧数的所有粒子点数据，包括爱心粒子点和光晕粒子点，是实现动态效果的关键；
• 参数说明：generate_frame为需要计算的帧数；
• 关键逻辑：先根据当前帧数计算出缩放比例，再同步计算光晕的半径和粒子数量，随后依次生成光晕粒子点、原始爱心粒子点、边缘扩散粒子点、中心扩散粒子点，最后将所有粒子点数据保存到all_points字典中，供渲染时调用。

4.3.5 render(render_canvas, render_frame) 渲染方法

• 核心作用：将指定帧数的粒子点数据绘制到tkinter画布上，实现爱心的可视化；
• 参数说明：render_canvas为tkinter的画布对象；render_frame为当前要渲染的帧数；
• 关键细节：
• 循环取帧：通过render_frame % self.generate_frame让帧数超过跳动周期后从0重新开始，实现爱心无限循环跳动；
• 矩形绘制粒子：使用实心矩形绘制粒子（而非圆形），原因是tkinter中矩形的渲染速度远快于圆形，能保证低配设备也能流畅运行，且粒子尺寸足够小时，矩形视觉效果与圆形无差异；
• 实心绘制：通过width=0实现矩形的实心绘制，让粒子更明显。

4.4 动态绘制循环draw函数

• 核心作用：实现爱心的逐帧递归渲染，是连接Heart核心类和tkinter窗口的关键，让爱心真正“动起来”；
• 参数说明：main为tkinter主窗口对象；render_canvas为画布对象；render_heart为Heart爱心对象；render_frame为当前渲染帧数，初始值为0；
• 关键逻辑：每帧渲染前先清空画布（避免上一帧与当前帧重叠导致画面混乱），再调用爱心对象的render方法渲染当前帧，最后通过tkinter的after方法160毫秒后递归调用自身，实现持续的动态刷新。

4.5 主程序入口if __name__ == '__main__'

• 核心作用：执行整个案例的所有逻辑，是代码的唯一入口，只有直接运行该Python文件时，这部分代码才会执行；
• 分步骤逻辑：
• 创建tkinter主窗口对象，作为所有图形的顶层载体；
• 设置窗口标题，可自定义修改；
• 创建画布对象，指定黑色背景和预设的宽高；
• 将画布布局到主窗口中（无此步骤画布无法显示）；
• 初始化Heart爱心对象，加载所有帧的粒子点数据；
• 启动动态绘制循环，开始逐帧渲染爱心；
• 进入tkinter主事件循环，让窗口保持显示（关闭窗口则循环结束，程序停止）。

五、代码展示

以下是本案例的完整代码，代码中包含简洁清晰的行内注释（辅助理解关键代码），核心逻辑已在「代码详解」部分做了超详细文本解析，直接将代码全选复制到新建的Python文件中，点击PyCharm右上角的绿色三角运行按钮，即可看到动态跳动爱心效果，无需修改任何代码！

# 导入本案例所需所有内置库，无需额外安装第三方包
import random
# 按需导入math库的核心函数，用于数学计算
from math import sin, cos, pi, log
# 导入tkinter库的所有组件，用于创建图形窗口和绘制画布
from tkinter import *

# ===================== 全局常量配置区 – 可直接修改数值调整爱心样式 =====================
CANVAS_WIDTH = 640 # 画布（窗口）宽度，单位：像素
CANVAS_HEIGHT = 480 # 画布（窗口）高度，单位：像素
CANVAS_CENTER_X = CANVAS_WIDTH / 2 # 画布中心X轴坐标，让爱心居中
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2 # 画布中心Y轴坐标，让爱心居中
IMAGE_ENLARGE = 11 # 爱心基础缩放比例，数值越大爱心越大
HEART_COLOR = "#FFC0CB" # 爱心粒子颜色，16进制色值（粉色）

# ===================== 核心工具函数 – 实现爱心坐标、粒子扩散、跳动节奏计算 =====================
def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
# 根据笛卡尔心形公式，通过弧度t计算爱心单个坐标点
x = 16 * (sin(t) ** 3)
y = –(13 * cos(t) – 5 * cos(2 * t) – 2 * cos(3 * t) – cos(4 * t))
# 缩放坐标值，适配画布尺寸
x *= shrink_ratio
y *= shrink_ratio
# 偏移坐标，将爱心中心移至画布正中心
x += CANVAS_CENTER_X
y += CANVAS_CENTER_Y
# 转换为整数像素坐标并返回
return int(x), int(y)

def scatter_inside(x, y, beta=0.15):
# 让基础坐标点向画布中心随机扩散，生成粒子效果
# beta：扩散系数，值越小粒子越密集
ratio_x = – beta * log(random.random())
ratio_y = – beta * log(random.random())
# 计算向中心扩散的偏移量
dx = ratio_x * (x – CANVAS_CENTER_X)
dy = ratio_y * (y – CANVAS_CENTER_Y)
return x – dx, y – dy

def shrink(x, y, ratio):
# 让坐标点向中心收缩，用于生成爱心外围光晕效果
# 计算收缩力，距离中心越远收缩力越大
force = –1 / (((x – CANVAS_CENTER_X) ** 2 + (y – CANVAS_CENTER_Y) ** 2) ** 0.6)
dx = ratio * force * (x – CANVAS_CENTER_X)
dy = ratio * force * (y – CANVAS_CENTER_Y)
return x – dx, y – dy

def curve(p):
# 生成周期性正弦曲线，返回缩放比例，控制爱心跳动节奏
return 2 * (2 * sin(4 * p)) / (2 * pi)

# ===================== 爱心核心类 – 封装爱心点构建、帧计算、渲染所有逻辑 =====================
class Heart:
def __init__(self, generate_frame=20):
# 初始化：创建点集合，预计算所有帧的粒子数据
self._points = set() # 原始爱心轮廓点集合（无重复）
self._edge_diffusion_points = set() # 边缘扩散点集合（柔化边缘）
self._center_diffusion_points = set() # 中心扩散点集合（填充内部）
self.all_points = {} # 存储所有帧数据：{帧数: [(x,y,粒子大小), …]}
self.generate_frame = generate_frame # 一个跳动周期的总帧数
self.build(2000) # 构建2000个原始爱心点，值越大粒子越密集
# 预计算所有帧数据，避免实时计算卡顿
for frame in range(self.generate_frame):
self.calc(frame)

def build(self, number):
# 构建原始点、边缘扩散点、中心扩散点集合
# 1. 生成原始爱心轮廓点
for _ in range(number):
t = random.uniform(0, 2 * pi) # 随机生成0-2π弧度
x, y = heart_function(t)
self._points.add((x, y))
# 2. 生成边缘扩散点：每个原始点生成3个，小系数扩散
for _x, _y in list(self._points):
for _ in range(3):
x, y = scatter_inside(_x, _y, 0.05)
self._edge_diffusion_points.add((x, y))
# 3. 生成中心扩散点：4000个，大系数扩散，填充爱心内部
point_list = list(self._points)
for _ in range(4000):
x, y = random.choice(point_list)
x, y = scatter_inside(x, y, 0.17)
self._center_diffusion_points.add((x, y))

@staticmethod
def calc_position(x, y, ratio):
# 静态方法：根据缩放比例计算粒子新坐标，实现动态跳动
# 计算跳动力，距离中心越远，跳动幅度越大
force = 1 / (((x – CANVAS_CENTER_X) ** 2 + (y – CANVAS_CENTER_Y) ** 2) ** 0.520)
# 计算偏移量，加入轻微随机值让粒子更自然
dx = ratio * force * (x – CANVAS_CENTER_X) + random.randint(–1, 1)
dy = ratio * force * (y – CANVAS_CENTER_Y) + random.randint(–1, 1)
return x – dx, y – dy

def calc(self, generate_frame):
# 预计算指定帧数的所有粒子点数据（爱心+光晕）
ratio = 10 * curve(generate_frame / 10 * pi) # 当前帧缩放比例
# 计算当前帧光晕的半径和粒子数量，随跳动节奏变化
halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))
halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))
all_points = [] # 存储当前帧所有粒子点

# 1. 生成爱心外围光晕粒子点
heart_halo_point = set()
for _ in range(halo_number):
t = random.uniform(0, 2 * pi)
x, y = heart_function(t, shrink_ratio=11.6) # 轻微放大爱心作为光晕基础
x, y = shrink(x, y, halo_radius) # 收缩生成光晕轮廓
if (x, y) not in heart_halo_point:
heart_halo_point.add((x, y))
x += random.randint(–14, 14) # 随机偏移，增加光晕朦胧感
y += random.randint(–14, 14)
size = random.choice((1, 2, 2)) # 随机光晕粒子大小
all_points.append((x, y, size))

# 2. 生成原始爱心粒子点，按当前比例跳动
for x, y in self._points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 3)
all_points.append((x, y, size))

# 3. 生成边缘扩散粒子点，按当前比例跳动
for x, y in self._edge_diffusion_points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 2)
all_points.append((x, y, size))

# 4. 生成中心扩散粒子点，按当前比例跳动
for x, y in self._center_diffusion_points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 2)
all_points.append((x, y, size))

# 保存当前帧所有粒子点数据
self.all_points[generate_frame] = all_points

def render(self, render_canvas, render_frame):
# 将指定帧数的粒子点绘制到画布上
# 循环取帧，实现无限跳动
frame_points = self.all_points[render_frame % self.generate_frame]
# 遍历粒子点，绘制实心矩形粒子
for x, y, size in frame_points:
render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)

# ===================== 动态绘制循环 – 逐帧渲染，让爱心动起来 =====================
def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):
render_canvas.delete('all') # 清空上一帧内容，避免重叠
render_heart.render(render_canvas, render_frame) # 渲染当前帧爱心
# 160毫秒后递归调用，实现持续动态刷新
main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)

# ===================== 主程序入口 – 执行所有逻辑，启动程序 =====================
if __name__ == '__main__':
root = Tk() # 创建tkinter主窗口对象
root.title("Python动态跳动爱心 | 情人节专属") # 设置窗口标题
# 创建画布，黑色背景，指定宽高
canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
canvas.pack() # 将画布布局到主窗口，使其显示
heart = Heart() # 初始化爱心对象
draw(root, canvas, heart) # 启动动态绘制循环
root.mainloop() # 进入主事件循环，保持窗口显示

六、详细运行步骤

结合上述的环境准备和代码展示，以下是零基础手把手运行步骤，按步骤操作即可零出错运行出动态爱心效果：

七、总结

本次的动态跳动爱心案例，是Python基础语法+经典数学公式+tkinter GUI的综合入门小案例，全程仅使用Python内置标准库，无任何复杂第三方依赖，既贴合情人节热点，能通过代码制造专属浪漫，又非常适合Python零基础新手练手。

通过学习本案例，不仅能掌握random、math、tkinter三个核心内置库的基础使用方法，还能理解笛卡尔心形公式的应用、正弦曲线实现周期性动态、面向对象的代码封装思想、tkinter逐帧渲染实现动态图形等关键知识点，这些知识点可直接迁移到其他Python趣味小案例中，比如动态烟花、图形绘制、简单GUI小工具等。

本案例也是博主「Python趣味代码大全」专栏的第一篇内容，后续专栏会持续更新更多短小精悍、新手能一键运行的Python趣味代码，包括爬虫趣玩、自动化小工具、一行代码整活、数据可视化小案例等，让大家在玩代码的过程中，轻松提升Python编程能力。

如果觉得这个案例有趣、有收获，欢迎关注博主，后续更多Python趣味内容不迷路！最后提前祝大家情人节快乐，用代码书写的浪漫，永远有着独属于程序员的温度和心意～