详细讲解用Python绘制跳动爱心，附带详细源码

原创 已于 2025-11-26 16:38:50 修改 · 874 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言 #开源 #经验分享 #c语言 #课程设计

于 2025-11-22 01:42:18 首次发布

当数学函数遇上编程，便能创造出令人心动的浪漫效果。本文将带你深入解析一个用Python实现的动态跳动爱心程序，揭秘其背后的数学原理和编程技巧。

程序概览

这段代码使用Python的tkinter库创建了一个图形界面，通过数学函数生成爱心形状，并添加了动态跳动效果和光影特效。最终呈现出一个在黑色背景上跳动、带有光晕效果的粉色爱心，中间还显示着浪漫的文字告白。

运行效果

在这里插入图片描述
添加文字后，效果如图：
在这里插入图片描述

环境要求

  • Python 3.6 或更高版本
  • 需要安装tkinter图形界面库

tkinter库下载，命令行运行

python -m pip install tk

代码结构解析

1. 基础配置参数

CANVAS_WIDTH = 840   # 画布宽度
CANVAS_HEIGHT = 680  # 画布高度
CANVAS_CENTER_X = CANVAS_WIDTH / 2  # 画布中心X坐标
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2  # 画布中心Y坐标
IMAGE_ENLARGE = 11   # 图像放大比例
HEART_COLOR = "#EEAEEE"  # 爱心颜色（浅粉色）
TEXT_COLOR = "#FF1493"   # 文字颜色（深粉色）

这些参数控制了爱心的显示大小、位置和颜色，通过调整这些值可以改变爱心的外观效果。

2. 核心数学函数：爱心形状生成

def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
    x = 17 * (sin(t) ** 3)
    y = -(16 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(3 * t))
    
    x *= IMAGE_ENLARGE
    y *= IMAGE_ENLARGE
    x += CANVAS_CENTER_X
    y += CANVAS_CENTER_Y
    
    return int(x), int(y)

这是整个程序的核心——爱心参数方程。这个著名的数学公式通过三角函数组合，能够生成完美的心形曲线：

  • x坐标：17 * sin³(t) 控制心形的水平轮廓
  • y坐标：复杂的余弦函数组合控制心形的垂直轮廓和凹陷部分

参数t在0到2π之间变化，通过描点法绘制出完整的心形。最后的放大和平移操作将数学坐标转换为画布上的实际像素坐标。

3. 特效函数

内部扩散效果
def scatter_inside(x, y, beta=0.15):
    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

这个函数模拟了物理上的"力场"效果，距离中心越远的点受到的"吸引力"越大，从而在爱心跳动时产生自然的形变。

4. 心跳曲线函数

def curve(p):
    return 2 * (2 * sin(4 * p)) / (2 * pi)

这个正弦函数控制爱心的跳动节奏，通过调整频率和振幅来模拟真实的心跳效果。

Heart类：程序的核心引擎

初始化与点集构建

class Heart:
    def __init__(self, generate_frame=20):
        self._points = set()  # 原始爱心坐标
        self._edge_diffusion_points = set()  # 边缘扩散点
        self._center_diffusion_points = set()  # 中心扩散点
        self.all_points = {}  # 所有帧的点坐标
        self.build(2000)

Heart类管理三个点集：

  • _points：基础爱心轮廓点
  • _edge_diffusion_points：边缘附近的随机点，增加细节
  • _center_diffusion_points：中心区域的随机点，增强填充效果

动态计算与渲染

def calc(self, generate_frame):
    ratio = 15 * curve(generate_frame / 10 * pi)
    # ... 计算每一帧的点位置

calc方法为每一帧计算爱心的形状，通过curve函数控制跳动的幅度，实现动态效果。

render方法负责将计算好的点绘制到画布上，使用小矩形来模拟像素化的效果。

动画循环与文字显示

def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):
    render_canvas.delete('all')
    render_heart.render(render_canvas, render_frame)
    
    # 添加文字
    render_canvas.create_text(
        CANVAS_CENTER_X, CANVAS_CENTER_Y,
        text="宝宝大人~我爱你~永永远远！",
        fill=TEXT_COLOR,
        font=("楷体", 12, "bold")
    )
    
    main.after(1, draw, main, render_canvas, render_heart, render_frame + 1)

draw函数是动画的主循环，每一帧都清空画布、重新渲染爱心、添加文字，然后通过after方法调度下一帧，实现流畅的动画效果。

数学原理深度解析

爱心函数的数学本质

爱心函数实际上是极坐标方程的变形。标准的爱心极坐标方程为：

r = a(1 - sinθ)

但代码中使用的是更复杂的参数方程形式，能够产生更加优美和对称的心形。这种方程的优势在于：

  1. 精确控制心形的凹陷深度
  2. 保持完美的左右对称
  3. 便于计算和渲染

物理模拟原理

程序中的跳动效果模拟了真实的物理现象：

  • 弹性形变：通过距离相关的力函数模拟
  • 阻尼振动：正弦曲线提供自然的振动衰减
  • 粒子系统：大量随机点模拟光晕和填充效果

编程技巧亮点

  1. 面向对象设计：将爱心相关的数据和操作封装在Heart类中
  2. 函数式编程：使用纯函数进行坐标变换，避免副作用
  3. 动画优化：预计算所有帧的数据，渲染时直接调用
  4. 随机化艺术：通过可控的随机数生成自然的效果

扩展与改进建议

想要进一步个性化这个爱心动画？可以考虑：

  1. 颜色渐变：让爱心颜色随时间变化
  2. 交互功能：添加鼠标跟随或点击效果
  3. 音乐同步：让心跳节奏与背景音乐同步
  4. 3D效果：使用透视变换增加立体感
  5. 多爱心系统：创建多个跳动频率不同的爱心

源代码

import random
from math import sin, cos, pi, log
from tkinter import *

CANVAS_WIDTH = 840  # 画布的宽
CANVAS_HEIGHT = 680  # 画布的高
CANVAS_CENTER_X = CANVAS_WIDTH / 2  # 画布中心的X轴坐标
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2  # 画布中心的Y轴坐标
IMAGE_ENLARGE = 11  # 放大比例

HEART_COLOR = "#EEAEEE"  # 爱心颜色
TEXT_COLOR = "#FF1493"  # 文字颜色


def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
    """
    "爱心函数生成器"
    :param shrink_ratio: 放大比例
    :param t: 参数
    :return: 坐标
    """
    # 基础函数
    x = 17 * (sin(t) ** 3)
    y = -(16 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(3 * t))

    # 放大
    # x *= shrink_ratio
    # y *= shrink_ratio
    x *= IMAGE_ENLARGE
    y *= IMAGE_ENLARGE
    # 移到画布中央
    x += CANVAS_CENTER_X
    y += CANVAS_CENTER_Y

    return int(x), int(y)


def scatter_inside(x, y, beta=0.15):
    """
    随机内部扩散
    :param x: 原x
    :param y: 原y
    :param beta: 强度
    :return: 新坐标
    """
    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):
    """
    抖动
    :param x: 原x
    :param y: 原y
    :param ratio: 比例
    :return: 新坐标
    """
    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):
    """
    自定义曲线函数，调整跳动周期
    :param p: 参数
    :return: 正弦
    """
    # 可以尝试换其他的动态函数，达到更有力量的效果（贝塞尔？）
    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 = {}  # 每帧动态点坐标
        self.build(2000)

        self.random_halo = 1000

        self.generate_frame = generate_frame
        for frame in range(generate_frame):
            self.calc(frame)

    def build(self, number):
        # 爱心
        for _ in range(number):
            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口
            x, y = heart_function(t)
            self._points.add((x, y))

        # 爱心内扩散
        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))

        # 爱心内再次扩散
        point_list = list(self._points)
        for _ in range(10000):
            x, y = random.choice(point_list)
            x, y = scatter_inside(x, y, 0.27)
            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.420)  # 魔法参数

        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 = 15 * 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 = []

        # 光环
        heart_halo_point = set()  # 光环的点坐标集合
        for _ in range(halo_number):
            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口
            x, y = heart_function(t, shrink_ratio=-15)  # 魔法参数
            x, y = shrink(x, y, halo_radius)
            if (x, y) not in heart_halo_point:
                # 处理新的点
                heart_halo_point.add((x, y))
                x += random.randint(-60, 60)
                y += random.randint(-60, 60)
                size = random.choice((1, 1, 2))
                all_points.append((x, y, size))
                all_points.append((x + 20, y + 20, size))
                all_points.append((x - 20, y - 20, size))
                all_points.append((x + 20, y - 20, size))
                all_points.append((x - 20, y + 20, size))

        # 轮廓
        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))

        # 内容
        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))

        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: Canvas, render_frame):
        for x, y, size in self.all_points[render_frame % self.generate_frame]:
            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)

    # 在爱心中间添加文字
    #
    text_content = "宝宝大人~我爱你~永永远远！"  # 不需要可以进行删除
    render_canvas.create_text(
        CANVAS_CENTER_X,
        CANVAS_CENTER_Y,
        text=text_content,
        fill=TEXT_COLOR,
        font=("楷体", 12, "bold"),
        justify=CENTER
    )

    main.after(1, draw, main, render_canvas, render_heart, render_frame + 1)


if __name__ == '__main__':
    root = Tk()
    root.title("清澈的爱~只属于你~")  # 添加窗口标题
    canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
    canvas.pack()
    heart = Heart()
    draw(root, canvas, heart)
    root.mainloop()

常见问题解决

Q: 运行程序时出现"ModuleNotFoundError: No module named ‘tkinter’"错误
A: 使用提供的安装脚本自动安装，或参考手动安装说明。

Q: 程序运行但窗口不显示
A: 可能是tkinter安装不完整，尝试重新安装Python或tkinter。

Q: 动画运行缓慢
A: 减少Heart类初始化时的点数，或调整generate_frame参数。

结语

这个跳动爱心程序完美展现了编程与数学结合的魅力。通过简单的三角函数和物理模拟，我们创造出了充满生命力的数字艺术品。无论是用于浪漫告白，还是作为学习计算机图形学的入门项目，这都是一段值得深入研究和欣赏的代码。

数学的严谨与编程的创造力在此交汇，正如爱心所象征的情感一样——既有精确的规律，又有无限的可能。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员春至

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值