创意Python爱心代码分享：动态发光爱心动画

Python实现动态发光爱心动画

原创已于 2025-04-13 20:03:42 修改 · 1k 阅读

58 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

于 2025-04-13 19:25:18 首次发布

Python 专栏收录该内容

5 篇文章

订阅专栏

创意Python爱心代码分享：动态发光爱心动画

引言

在数字艺术和交互设计中，动态爱心图案是一种极具吸引力的视觉元素。Python凭借其丰富的可视化库（如Matplotlib和NumPy），为开发者提供了强大的工具来创建复杂的图形动画。本文将深入探讨如何利用Python实现一个动态发光爱心动画，该动画结合了主爱心轮廓、漂浮的小爱心和粒子效果，创造出梦幻般的视觉体验。

基础爱心效果实现

Python提供了多种创意爱心的实现方式，我们先来实现基础的几种效果：

ASCII实现文字爱

最简单方式可以通过ASCII字符，用逐行打印的方式生成一个文字爱心。

def print_text_heart():
    heart = [
        "    /\\  /\\",
        "   /  \\/  \\",
        "  /        \\",
        " /          \\",
        "/            \\",
        "\\            /",
        " \\          /",
        "  \\        /",
        "   \\      /",
        "    \\    /",
        "     \\  /",
        "      \\/"
    ]
    for line in heart:
        print(line)

print_text_heart()

输出效果如下：
在这里插入图片描述

有点朴素，又有点勉强

Matplotlib绘制静态爱心

下面代码使用参数方程绘制一个静态爱心图案。

import numpy as np
import matplotlib.pyplot as plt

# 参数方程
t = np.linspace(0, 2 * np.pi, 1000)
x = 16 * np.sin(t)**3
y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t)

# 绘制
plt.figure(figsize=(8, 8))
plt.plot(x, y, color='red', linewidth=2)
plt.title("Static Heart Shape", fontsize=16)
plt.axis('equal')
plt.axis('off')
plt.show()

效果如下，已经逼真很多了：
在这里插入图片描述

Matplotlib绘制渐变色

下面代码使用渐变色绘制爱心，增加视觉效果：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

# 参数方程
t = np.linspace(0, 2 * np.pi, 1000)
x = 16 * np.sin(t)**3
y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np(.cos3 * t) - np.cos(4 * t)

# 创建渐变色
colors = plt.cm.Reds(np.linspace(0.3, 1, len(x)))

plt.figure(figsize=(8, 8))
for i in range(len(x)-1):
    plt.plot([x[i], x[i+1]], [y[i], y[i+1]], color=colors[i], linewidth=2)

plt.title("Gradient Heart Shape", fontsize=16)
plt.axis('equal')
plt.axis('off')
plt.show()

在上面基础上增加了渐变效果：
在这里插入图片描述

Matplotlib 实现爱心动画

下面代码实现了矮星动画效果：

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# 创建图形和坐标轴
fig, ax = plt.subplots(figsize=(10, 8))

# 参数方程
t = np.linspace(0, 2 * np.pi, 1000)
x = 16 * np.sin(t)**3
y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t)

# 创建粒子效果
num_particles = 50
particle_x = np.random.uniform(-20, 20, num_particles)
particle_y = np.random.uniform(-20, 20, num_particles)
particle_sizes = np.random.uniform(10, 50, num_particles)

# 动画更新函数
def update(frame):
    ax.clear()
    ax.set_xlim(-20, 20)
    ax.set_ylim(-20, 20)
    ax.axis('off')
    
    # 爱心跳动效果
    scale = 1 + 0.1 * np.sin(frame * 0.1)
    glow = np.sin(frame * 0.1) * 0.3 + 0.7
    
    # 绘制主爱心
    ax.fill(x * scale, y * scale, alpha=0.3, color='pink')
    ax.plot(x * scale, y * scale, color='red', linewidth=2, alpha=glow)
    
    # 绘制粒子效果
    particle_alpha = np.abs(np.sin(frame * 0.05 + particle_sizes))
    ax.scatter(particle_x, particle_y, c='pink', s=particle_sizes, alpha=particle_alpha * 0.5)

# 创建动画
ani = animation.FuncAnimation(fig, update, frames=200, interval=50, blit=False)

plt.show()

请添加图片描述

这个爱心已经有了动效，更逼真更生动了。

3D爱心效果

下面代码使用3D参数方程绘制一个立体爱心，生成一个沿Z轴旋转的3D红色爱心：

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.colors import LinearSegmentedColormap

# 创建自定义的粉色渐变色彩映射
colors = [(1, 0.8, 0.9, 1), (1, 0.4, 0.6, 1)]
glowing_pink = LinearSegmentedColormap.from_list('glowing_pink', colors)

# 心形3D参数方程
def heart_3d(t, v):
    x = 16 * np.sin(t)**3
    y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t)
    z = v * (np.sin(t) + 0.5 * np.sin(2 * t))  # 优化Z轴形状
    return x, y, z

# 创建参数范围
t = np.linspace(0, 2 * np.pi, 200)  # 增加分辨率
v = np.linspace(-1.5, 1.5, 100)  # 扩大深度范围

# 创建网格
t, v = np.meshgrid(t, v)

# 计算心形表面
x, y, z = heart_3d(t, v)

# 创建底座参数
base_r = np.linspace(0, 20, 50)
base_theta = np.linspace(0, 2 * np.pi, 50)
base_r, base_theta = np.meshgrid(base_r, base_theta)
base_x = base_r * np.cos(base_theta)
base_y = base_r * np.sin(base_theta)
base_z = np.ones_like(base_x) * -2

# 设置绘图
plt.style.use('dark_background')
fig = plt.figure(figsize=(12, 12))
ax = fig.add_subplot(111, projection='3d')

# 绘制心形表面
surf = ax.plot_surface(x, y, z, cmap=glowing_pink, alpha=0.9,
                      linewidth=0, antialiased=True)

# 绘制底座
ax.plot_surface(base_x, base_y, base_z, color='pink', alpha=0.3,
                linewidth=0, antialiased=True)

# 添加环境光效果
ax.view_init(elev=20, azim=45)

# 设置视角和范围
ax.set_facecolor('#102030')
fig.patch.set_facecolor('#102030')
ax.set_xlim([-20, 20])
ax.set_ylim([-20, 20])
ax.set_zlim([-3, 3])

# 隐藏坐标轴
ax.set_axis_off()

# 显示图形
plt.show()

在这里插入图片描述

到这里可能已经是程序员的迹象了，要再实现更炫酷的效果，像下面这些已经不是代码能不能实现的问题了，而是代码我们能不能想象到的效果了：
在这里插入图片描述

在这里插入图片描述

记下来带大家实现一个炫酷的爱心效果，这次先看效果：

请添加图片描述

这里不仅有一个大爱心，还有很多小爱心动画，爱心中还有星云效果，下面就一步一步来实现吧。

核心原理

爱心的参数方程

爱心图案基于以下参数方程实现：
$x = 16 \sin^3(t) ] [ y = 13 \cos(t) - 5 \cos(2t) - 2 \cos(3t) - \cos(4t) ]$
其中 ( t ) 的范围为 $\leq t \leq 2\pi )$ 。

渐变色映射

通过自定义颜色映射（colormap），实现爱心的渐变发光效果：

colors = [(1, 0.8, 0.9, 0), (1, 0.6, 0.8, 1)]
glowing_pink = LinearSegmentedColormap.from_list('glowing_pink', colors)

动画机制

使用Matplotlib的FuncAnimation类实现动画效果，通过逐帧更新图形元素的位置和属性，模拟动态效果。

粒子效果

粒子效果通过随机生成的点集合实现，结合透明度变化和位置更新，创造出流动的视觉效果。

实现步骤

1. 创建主爱心轮廓

使用参数方程生成爱心的坐标，并绘制轮廓：

def heart_shape(t):
    x = 16 * np.sin(t)**3
    y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t)
    return x, y

t = np.linspace(0, 2 * np.pi, 1000)
x, y = heart_shape(t)

2. 创建漂浮的小爱心

定义一个类FloatingHeart，生成随机缩放和位置的小爱心，并实现向上漂浮的动画效果：

class FloatingHeart:
    def __init__(self):
        self.t = np.linspace(0, 2 * np.pi, 100)
        self.x, self.y = heart_shape(self.t)
        self.scale = np.random.uniform(0.1, 0.3)
        self.x = self.x * self.scale
        self.y = self.y * self.scale
        self.pos_x = np.random.uniform(-20, 20)
        self.pos_y = np.random.uniform(-20, 20)
        self.speed = np.random.uniform(0.1, 0.3)
        self.alpha = np.random.uniform(0.3, 0.7)

    def update(self):
        self.pos_y += self.speed
        if self.pos_y > 20:
            self.pos_y = -20
            self.pos_x = np.random.uniform(-20, 20)

3. 创建粒子效果

生成随机分布的粒子，并通过透明度变化实现流动效果：

particle_count = 1000
particle_x = np.random.normal(0, 5, particle_count)
particle_y = np.random.normal(0, 5, particle_count)
particle_sizes = np.random.uniform(1, 50, particle_count)

4. 动画更新函数

在每一帧中更新主爱心的发光强度、粒子的透明度以及漂浮小爱心的位置：

def update(frame):
    ax.clear()
    ax.set_xlim(-20, 20)
    ax.set_ylim(-20, 20)
    ax.axis('off')
    
    # 绘制主爱心轮廓
    glow = np.sin(frame * 0.1) * 0.3 + 0.7
    ax.scatter(x, y, c='pink', s=30, alpha=glow, zorder=2)
    
    # 绘制粒子效果
    particle_alpha = np.abs(np.sin(frame * 0.05 + particle_sizes))
    ax.scatter(particle_x, particle_y, c='pink', s=particle_sizes, alpha=particle_alpha * 0.5, zorder=1)
    
    # 更新和绘制漂浮的小爱心
    for heart in floating_hearts:
        heart.update()
        ax.plot(heart.x + heart.pos_x, heart.y + heart.pos_y, 'pink', alpha=heart.alpha, zorder=3)

5. 创建动画

使用FuncAnimation启动动画：

floating_hearts = [FloatingHeart() for _ in range(10)]
anim = FuncAnimation(fig, update, frames=200, interval=50, blit=False)
plt.show()

7. 完整代码效果

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.colors import LinearSegmentedColormap

# 创建自定义的粉色渐变色彩映射
colors = [(1, 0.8, 0.9, 0), (1, 0.6, 0.8, 1)]
glowing_pink = LinearSegmentedColormap.from_list('glowing_pink', colors)

# 主爱心形状函数
def heart_shape(t):
    x = 16 * np.sin(t)**3
    y = 13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t)
    return x, y

# 创建小爱心的类
class FloatingHeart:
    def __init__(self):
        self.t = np.linspace(0, 2 * np.pi, 100)
        self.x, self.y = heart_shape(self.t)
        self.scale = np.random.uniform(0.1, 0.3)
        self.x = self.x * self.scale
        self.y = self.y * self.scale
        self.pos_x = np.random.uniform(-20, 20)
        self.pos_y = np.random.uniform(-20, 20)
        self.speed = np.random.uniform(0.1, 0.3)
        self.alpha = np.random.uniform(0.3, 0.7)

    def update(self):
        self.pos_y += self.speed
        if self.pos_y > 20:
            self.pos_y = -20
            self.pos_x = np.random.uniform(-20, 20)

# 设置图形
plt.style.use('dark_background')
fig, ax = plt.subplots(figsize=(10, 10))
ax.set_facecolor('#102030')
fig.patch.set_facecolor('#102030')

# 创建主爱心
t = np.linspace(0, 2 * np.pi, 1000)
x, y = heart_shape(t)

# 创建漂浮的小爱心
floating_hearts = [FloatingHeart() for _ in range(10)]

# 创建粒子效果
particle_count = 1000
particle_x = np.random.normal(0, 5, particle_count)
particle_y = np.random.normal(0, 5, particle_count)
particle_sizes = np.random.uniform(1, 50, particle_count)

# 动画更新函数
def update(frame):
    ax.clear()
    ax.set_xlim(-20, 20)
    ax.set_ylim(-20, 20)
    ax.axis('off')
    
    # 绘制主爱心轮廓
    glow = np.sin(frame * 0.1) * 0.3 + 0.7
    ax.scatter(x, y, c='pink', s=30, alpha=glow, zorder=2)
    
    # 绘制粒子效果
    particle_alpha = np.abs(np.sin(frame * 0.05 + particle_sizes))
    ax.scatter(particle_x, particle_y, c='pink', s=particle_sizes, alpha=particle_alpha * 0.5, zorder=1)
    
    # 更新和绘制漂浮的小爱心
    for heart in floating_hearts:
        heart.update()
        ax.plot(heart.x + heart.pos_x, heart.y + heart.pos_y, 'pink', alpha=heart.alpha, zorder=3)

# 创建动画
anim = FuncAnimation(fig, update, frames=200, interval=50, blit=False)
plt.show()