Python — 四款表白代码送给喜欢的那个她（他）

一：无法拒绝的表白流星雨

页面效果：

Python源码

import turtle as tu  # 导入turtle模块，用于绘图  
import random as ra  # 导入random模块，用于生成随机数  
import tkinter as tk  # 导入tkinter模块，用于创建GUI界面  
import math  # 导入math模块，用于进行数学计算  

def Meteors():  
    tu.setup(1.0, 1.0)  # 设置画布窗口的大小  
    tu.screensize(1.0, 1.0)  # 设置画布大小  
    tu.bgcolor('black')  # 设置画布背景颜色为黑色  
    tu.title("流星雨")  # 设置画布标题  
    t = tu.Pen()  # 创建一个画笔对象  
    t.hideturtle()  # 隐藏画笔的箭头  

    colors = ['yellow', 'lightpink', 'cyan', 'aqua']  # 定义流星的颜色列表  

    class Star():  # 定义一个流星类  
        def __init__(self):  
            self.r = ra.randint(50,100)  # 流星的半径  
            self.t = ra.randint(1,3)  # 流星的倾斜角度  
            self.x = ra.randint(-2000,1000)  # 流星的x坐标  
            self.y = ra.randint(444, 999)  # 流星的y坐标  
            self.speed = ra.randint(5,10)  # 流星移动的速度  
            self.color = ra.choice(colors)  # 从颜色列表中随机选择流星的颜色  
            self.outline = 1  # 流星的边框宽度  

        def star(self):  # 绘制流星的方法  
            t.pensize(self.outline)  # 设置画笔的大小  
            t.penup()  # 抬起画笔  
            t.goto(self.x,self.y)  # 移动画笔到流星的坐标  
            t.pendown()  # 放下画笔  
            t.color(self.color)  # 设置画笔颜色  
            t.begin_fill()  # 开始填充颜色  
            t.fillcolor(self.color)  # 设置填充颜色  
            t.setheading(-30)  # 设置画笔的朝向  
            t.right(self.t)  # 向右转动一定角度  
            t.forward(self.r)  # 向前移动一定距离  
            t.left(self.t)  # 向左转动一定角度  
            t.circle(self.r*math.sin(math.radians(self.t)),180)  # 绘制一个圆弧  
            t.left(self.t)  # 向左转动一定角度  
            t.forward(self.r)  # 向前移动一定距离  
            t.end_fill()  # 结束填充颜色  

        def move(self):  # 移动流星的方法  
            if self.y >= -500:  # 如果流星的y坐标大于等于-500  
                self.y -= self.speed  # 流星向下移动  
                self.x += 2*self.speed  # 流星向右移动  
            else:  # 如果流星的y坐标小于-500  
                self.r = ra.randint(50,100)  # 重新设置流星的半径  
                self.t = ra.randint(1,3)  # 重新设置流星的倾斜角度  
                self.x = ra.randint(-2000,1000)  # 重新设置流星的x坐标  
                self.y = 444  # 重新设置流星的y坐标  
                self.speed = ra.randint(5,10)  # 重新设置流星的速度  
                self.color = ra.choice(colors)  # 重新设置流星的颜色  
                self.outline = 1  # 重新设置流星的边框宽度  

    Stars = []  # 创建一个列表，用于保存所有的流星对象  
    for i in range(100):  # 创建100个流星对象  
        Stars.append(Star())  

    while True:  # 开始绘制流星雨  
        tu.tracer(0)  # 关闭自动更新画面  
        t.clear()  # 清除画布上的内容  
        for i in range(100):  # 遍历所有的流星对象  
            Stars[i].move()  # 移动流星  
            Stars[i].star()  # 绘制流星  
        tu.update()  # 更新画面  
    tu.mainloop()  # 进入turtle的主循环  

def love():  
    root = tk.Tk()  # 创建一个Tk窗口对象  
    root.title('❤')  # 设置窗口标题  
    root.resizable(0, 0)  # 禁止调整窗口大小  
    root.wm_attributes("-toolwindow", 1)  # 设置窗口为工具窗口  
    screenwidth = root.winfo_screenwidth()  # 获取屏幕宽度  
    screenheight = root.winfo_screenheight()  # 获取屏幕高度  
    widths = 300  # 设置窗口宽度  
    heights = 100  # 设置窗口高度  
    x = (screenwidth - widths) / 2  # 计算窗口在屏幕中的x坐标  
    y = (screenheight - heights) / 2  # 计算窗口在屏幕中的y坐标  
    root.geometry('%dx%d+%d+%d' % (widths, heights, x, y))  # 设置窗口大小和位置  

    tk.Label(root, text='亲爱的，做我女朋友好吗？', width=37, font=('宋体', 12)).place(x=0, y=10)  # 在窗口中显示文本  

    def OK():  # 同意按钮的回调函数  
        root.destroy()  # 关闭窗口  
        # 同意后显示流星雨效果  
        Meteors()  

    def NO():  # 拒绝按钮的回调函数  
        tk.messagebox.showwarning('❤', '再给你一次机会！')  # 显示警告消息框  

    def closeWindow():  # 关闭窗口的回调函数  
        tk.messagebox.showwarning('❤', '逃避是没有用的哦')  # 显示警告消息框  

    tk.Button(root, text='好哦', width=5, height=1, command=OK).place(x=80, y=50)  # 创建并放置“好哦”按钮  
    tk.Button(root, text='不要', width=5, height=1, command=NO).place(x=160, y=50)  # 创建并放置“不要”按钮  
    root.protocol('WM_DELETE_WINDOW', closeWindow)  # 绑定关闭窗口事件  
    root.mainloop()  # 进入tkinter的主循环  

if __name__ == "__main__":  
    love()  # 运行程序

二：无法拒绝的文字表白

页面效果：

Python源码

import turtle as tu  # 导入turtle库，并简称为tu
import random as ra  # 导入random库，并简称为ra
import tkinter as tk  # 导入tkinter库，并简称为tk
import math  # 导入math库

def Main():
    tu.setup(1.0, 1.0)  # 设置画布大小为全屏
    tu.screensize(1.0, 1.0)  # 设置画布大小
    tu.bgcolor('black')  # 设置画布背景颜色为黑色
    tu.title("❤")  # 设置窗口标题
    t = tu.Pen()  # 创建一个画笔对象
    t.ht()  # 隐藏画笔，使画笔不可见
    words = ["我爱你",
             "I Love You!",
             "永远爱你",
             "七夕快乐",
             "一生一世一双人",
             "余生我陪你走",
             "陪你到来生",
             "三生有幸来日方长",
             "夜很长;幸有你",
             "爱你的全部",
             "顶峰相见",
             "等你下课",
             "往后余生",
             "Missing You!",
             "做我女朋友好么",
             "你已经在我的未来里了",
             "白头偕老",
             "我喜欢你",
             "好想好想你",
             "想你想你想你",
             "你是我的唯一"
             ]  # 定义表白话语列表

    class Love():  # 定义一个表示表白话语的类
        def __init__(self):  # 初始化方法
            self.x = ra.randint(-1000, 1000)  # 随机生成话语的横坐标
            self.y = ra.randint(-500, 500)  # 随机生成话语的纵坐标
            self.f = ra.uniform(-3, 3)  # 随机生成话语左右移动的频率
            self.speed = ra.uniform(2, 5)  # 随机生成话语移动的速度
            self.word = ra.choice(words)  # 随机选择一句表白话语
            self.color = "#%02x%02x%02x" % (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))  # 随机生成话语的颜色

        def draw(self):  # 绘制话语的方法
            t.penup()  # 提笔
            t.goto(self.x, self.y)  # 移动到指定位置
            t.pendown()  # 落笔
            t.color(self.color)  # 设置画笔颜色
            t.write(self.word, align="center", font=("Comic Sans MS", 24, "bold"))  # 写入话语

        def move(self):  # 话语移动的方法
            if self.y <= 500:  # 如果话语还在画布中
                self.y += self.speed  # 向上移动
                self.x -= self.speed * math.sin(self.f)  # 左右移动
            else:  # 如果话语超出了画布
                self.x = ra.randint(-1000, 1000)  # 重新生成横坐标
                self.y = -500  # 重新生成纵坐标
                self.f = ra.uniform(-3.14, 3.14)  # 重新生成左右移动频率
                self.speed = ra.uniform(2, 5)  # 重新生成移动速度
                self.word = ra.choice(words)  # 重新选择表白话语
                self.color = "#%02x%02x%02x" % (
                ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))  # 重新生成话语颜色

    class Ball():  # 定义一个表示彩色球的类
        def __init__(self):  # 初始化方法
            self.r = ra.uniform(2, 5)  # 随机生成球的半径
            self.x = ra.randint(-1000, 1000)  # 随机生成球的横坐标
            self.y = ra.randint(-500, 500)  # 随机生成球的纵坐标
            self.speed = ra.uniform(2, 10)  # 随机生成球移动的速度
            self.color = "#%02x%02x%02x" % (ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))  # 随机生成球的颜色
            self.outline = 10  # 设置球的边框宽度

        def draw(self):  # 绘制球的方法
            t.pensize(self.outline)  # 设置画笔宽度
            t.penup()  # 提笔
            t.goto(self.x, self.y)  # 移动到指定位置
            t.pendown()  # 落笔
            t.color(self.color)  # 设置画笔颜色
            t.begin_fill()  # 开始填充颜色
            t.fillcolor(self.color)  # 设置填充颜色
            t.circle(self.r)  # 绘制圆形

        def move(self):  # 球移动的方法
            if self.y >= -500:  # 如果球还在画布中
                self.y -= self.speed  # 向下移动
            else:  # 如果球超出了画布
                self.r = ra.uniform(2, 3)  # 重新生成半径
                self.x = ra.randint(-1000, 1000)  # 重新生成横坐标
                self.y = 500  # 重新生成纵坐标
                self.speed = ra.uniform(2, 10)  # 重新生成移动速度
                self.color = "#%02x%02x%02x" % (
                ra.randint(0, 255), ra.randint(0, 255), ra.randint(0, 255))  # 重新生成球的颜色
                self.outline = 10  # 重新设置边框宽度

    Loves = []  # 创建一个列表，用于保存所有的话语和球对象
    for i in range(595):  # 创建595个对象
        Loves.append(Love())
        Loves.append(Ball())
        Loves.append(Ball())
    while True:  # 开始绘制
        tu.tracer(0)  # 关闭自动更新画面
        t.clear()  # 清除画面
        for i in range(199):  # 绘制前199个对象（话语和球）
            Loves[i].move()  # 移动对象
            Loves[i].draw()  # 绘制对象
        tu.update()  # 更新画面
    tu.mainloop()  # 保持窗口运行


# 主函数
if __name__ == '__main__':
    root = tk.Tk()  # 创建一个tkinter窗口
    root.title('❤')  # 设置窗口标题
    root.resizable(0, 0)  # 禁止改变窗口大小
    screenwidth = root.winfo_screenwidth()  # 获取屏幕宽度
    screenheight = root.winfo_screenheight()  # 获取屏幕高度
    widths = 300  # 设置窗口宽度
    heights = 100  # 设置窗口高度
    x = (screenwidth - widths) / 2  # 计算窗口居中时的横坐标
    y = (screenheight - heights) / 2 - 66  # 计算窗口居中时的纵坐标
    root.geometry('%dx%d+%d+%d' % (widths, heights, x, y))  # 设置窗口大小和位置

    tk.Label(root, text='亲爱的，做我女朋友好吗？', width=37, font=('宋体', 12)).place(x=0, y=10)  # 在窗口中添加标签


    def OK():  # 同意按钮的回调函数
        root.destroy()  # 关闭tkinter窗口
        Main()  # 显示全屏飘字表白效果


    def NO():  # 拒绝按钮的回调函数
        tk.messagebox.showwarning('❤', '再给你一次机会！')  # 显示警告信息


    def closeWindow():  # 窗口关闭事件的回调函数
        tk.messagebox.showwarning('❤', '逃避是没有用的哦')  # 显示警告信息


    tk.Button(root, text='好哦', width=5, height=1, command=OK).place(x=80, y=50)  # 创建同意按钮
    tk.Button(root, text='不要', width=5, height=1, command=NO).place(x=160, y=50)  # 创建拒绝按钮
    root.protocol('WM_DELETE_WINDOW', closeWindow)  # 绑定窗口关闭事件
    root.mainloop()  # 保持窗口运行

三：无限弹窗式表白代码

页面效果

Python源码

import tkinter as tk  # 导入Tkinter库，用于创建GUI界面
import random as ra  # 导入random库，用于生成随机数
import threading as td  # 导入threading库，用于创建线程
import time as ti  # 导入time库，用于控制时间

def Love():  # 定义一个名为Love的函数，用于创建并显示“我爱你”的小窗口
    root = tk.Tk()  # 创建一个Tkinter窗口对象
    width = 200  # 设置窗口的宽度
    height = 50  # 设置窗口的高度
    screenwidth = root.winfo_screenwidth()  # 获取屏幕的宽度
    screenheight = root.winfo_screenheight()  # 获取屏幕的高度
    x = ra.randint(0, screenwidth)  # 生成一个随机数，用于设置窗口的x坐标
    y = ra.randint(0, screenheight)  # 生成一个随机数，用于设置窗口的y坐标
    root.title("❤")  # 设置窗口的标题
    root.geometry("%dx%d+%d+%d" % (width, height, x, y))  # 设置窗口的大小和位置
    tk.Label(root, text='I LOVE YOU!', fg='white', bg='pink', font=("Comic Sans MS", 15), width=30,
             height=5).pack()  # 创建一个标签，显示“我爱你”，并设置字体、颜色等
    root.mainloop()  # 启动Tkinter事件循环

def Heart():  # 定义一个名为Heart的函数，用于创建并显示心形符号的窗口
    root = tk.Tk()  # 创建一个Tkinter窗口对象
    screenwidth = root.winfo_screenwidth()  # 获取屏幕的宽度
    screenheight = root.winfo_screenheight()  # 获取屏幕的高度
    width = 600  # 设置窗口的宽度
    height = 400  # 设置窗口的高度
    x = (screenwidth - width) // 2  # 计算窗口的x坐标，使窗口居中
    y = (screenheight - height) // 2  # 计算窗口的y坐标，使窗口居中
    root.title("❤")  # 设置窗口的标题
    root.geometry("%dx%d+%d+%d" % (screenwidth, screenheight, 0, 0))  # 设置窗口的大小和位置，使其全屏
    tk.Label(root, text='❤', fg='pink', bg='white', font=("Comic Sans MS", 500), width=300,
             height=20).pack()  # 创建一个标签，显示心形符号，并设置字体、颜色等
    root.mainloop()  # 启动Tkinter事件循环


t = td.Thread(target=Heart)  # 创建一个线程，目标函数是Heart
t.setDaemon(True)  # 设置线程为守护线程，即主线程结束时，该线程也会结束
t.start()  # 启动线程
for i in range(50):  # 循环50次
    t = td.Thread(target=Love)  # 创建一个线程，目标函数是Love
    t.setDaemon(True)  # 设置线程为守护线程
    ti.sleep(0.1)  # 等待0.1秒
    t.start()  # 启动线程

四：无法拒绝的爱心表白

页面效果：

Python源码

import tkinter as tk
import tkinter.messagebox
import random
from math import sin, cos, pi, log
from tkinter.constants import *

# 设置窗口的宽度和高度
width = 888
height = 500
# 设置爱心的中心点坐标
heartx = width / 2
hearty = height / 2
# 设置爱心图案的缩放比例
side = 11
# 设置爱心的颜色
heartcolor = "red"
# 设置想要显示的文字
word = "I Love You!"

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(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 - heartx) ** 2 + (y - hearty) ** 2) ** 0.520)
        dx = ratio * force * (x - heartx) + random.randint(-1, 1)
        dy = ratio * force * (y - hearty) + 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 = []
        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))
                # 处理原始点、边缘扩散点、中心扩散点的动态位置
        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, 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=heartcolor)

        # 爱心图案的数学函数

def heart_function(t, shrink_ratio: float = side):
    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 += heartx
    y += hearty
    return int(x), int(y)

# 生成边缘扩散效果点的函数
def scatter_inside(x, y, beta=0.15):
    ratio_x = - beta * log(random.random())
    ratio_y = - beta * log(random.random())
    dx = ratio_x * (x - heartx)
    dy = ratio_y * (y - hearty)
    return x - dx, y - dy

# 生成中心扩散效果点的函数
def shrink(x, y, ratio):
    force = -1 / (((x - heartx) ** 2 + (y - hearty) ** 2) ** 0.6)
    dx = ratio * force * (x - heartx)
    dy = ratio * force * (y - hearty)
    return x - dx, y - dy

# 生成光环效果点的辅助函数
def curve(p):
    return 2 * (2 * sin(4 * p)) / (2 * pi)

# 动态渲染函数
def draw(main: tk.Tk, render_canvas: tk.Canvas, render_heart: Heart, render_frame=0):
    render_canvas.delete('all')
    render_heart.render(render_canvas, render_frame)
    main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)

# 显示爱心图案的函数
def love():
    root = tk.Tk()
    screenwidth = root.winfo_screenwidth()
    screenheight = root.winfo_screenheight()
    x = (screenwidth - width) // 2
    y = (screenheight - height) // 2 - 66
    root.geometry("%dx%d+%d+%d" % (width, height, x, y))
    root.title("❤")
    canvas = tk.Canvas(root, bg="black", width=width, height=height)
    canvas.pack()
    heart = Heart()
    draw(root, canvas, heart)
    tk.Label(root, text=word, bg="black", fg="cyan", font="Helvetic 25 bold").place(relx=.5, rely=.5, anchor=CENTER)
    root.mainloop()

# 主函数
if __name__ == '__main__':
    root = tk.Tk()
    root.title('❤')
    root.resizable(0, 0)
    screenwidth = root.winfo_screenwidth()
    screenheight = root.winfo_screenheight()
    widths = 300
    heights = 100
    x = (screenwidth - widths) / 2
    y = (screenheight - heights) / 2 - 66
    root.geometry('%dx%d+%d+%d' % (widths, heights, x, y))
    tk.Label(root, text='亲爱的，做我女朋友好吗？', width=37, font=('宋体', 12)).place(x=0, y=10)

    def OK():  # 定义一个名为OK的函数，用于处理用户点击“好哦”按钮的事件
        root.destroy()  # 关闭当前的窗口
        love()  # 调用love函数，假设这个函数用于显示跳动的爱心

    def NO():  # 定义一个名为NO的函数，用于处理用户点击“不要”按钮的事件
        tk.messagebox.showwarning('❤', '再给你一次机会！')  # 显示一个警告消息框

    def closeWindow():  # 定义一个名为closeWindow的函数，用于处理用户尝试关闭窗口的事件
        tk.messagebox.showwarning('❤', '逃避是没有用的哦')  # 显示一个警告消息框

    # 创建一个按钮
    tk.Button(root, text='好哦', width=5, height=1, command=OK).place(x=80,y=50)  
    # 创建另一个按钮
    tk.Button(root, text='不要', width=5, height=1, command=NO).place(x=160,y=50)  
    root.protocol('WM_DELETE_WINDOW', closeWindow)  # 绑定关闭窗口的事件到closeWindow函数
    root.mainloop()  # 进入Tkinter的主事件循环，等待用户事件。

仅以此篇文章，祝愿轻舟所有的读者得遇良人；七夕快乐