código de prueba
En el mundo actual orientado a los resultados, no ponga sus miras más allá de la cima. La clave es poder convertir y producir resultados reales sin importar el método que utilice. Incluso si es un programa muy simple, necesita descargar Úselo si finalmente desea generar una versión ejecutable. Mucho esfuerzo. No intentes ser una persona exitosa, intenta ser una persona valiosa.
# codificación: utf-8 importar hora de importación
aleatoria importar tkinter como tk desde tkinter importar cuadro de mensajes #Importar biblioteca de ventana emergente desde importación matemática sin, cos, pi, log, tan desde tkinter importar * ######### ## #Modificación de parámetros#################### CANVAS_WIDTH = 640 # El ancho del lienzo CANVAS_HEIGHT = 480 # La altura del lienzo CANVAS_CENTER_X = CANVAS_WIDTH / 2 # El Coordenada del eje X del centro del lienzo CANVAS_CENTER_Y = CANVAS_HEIGHT / 2 # La coordenada del eje Y del centro del lienzo IMAGE_ENLARGE = 11 # Relación de ampliación HEART_COLOR = "#e86184" # El color del corazón
WINDOWS_TITLE = 'Te amo' # Título de la ventana
HEART_CENTER_TEXT = 'Lara' # Texto medio
HEART_CENTER_TEXT_COLOR = '#FFD700' # Color del texto medio
################ Función del corazón ######################
defuntion = IMAGE_ENLARGE):
#Función básica
x = 14,6 * (sin(t) ** 3)
y = -(14,5 * cos(t) - 4 * cos(2 * t) - 2 * cos(3 * t) - 0,5 * cos(4 * t))
# Acercar
x *= reducción_ratio
y *= reducción_ratio
# Mover al centro del lienzo
x += CANVAS_CENTER_X
y += CANVAS_CENTER_Y
devolver int(x), int(y)
#################La difusión del amor en el interior #########################
Ajustar la lata beta Ajuste la
definición de difusión scatter_inside(x, y, beta=0.15):
ratio_x = - beta * log(random.random())
ratio_y = - beta * log(random.random())
dx = relación_x * (x - CANVAS_CENTER_X)
dy = relación_y * (y - CANVAS_CENTER_Y)
devolver x - dx, y - dy
#################Situación de nerviosismo########################
def encogimiento (x, y, relación ):
fuerza = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6) # Este parámetro... dx = relación *
fuerza * (x - CANVAS_CENTER_X)
dy = relación * fuerza * (y - CANVAS_CENTER_Y)
retorno x - dx, y - dy
################## Función de ritmo#######################
# https://cubic - bezier.com/ Sitio web de parámetros de Bezier, el valor de referencia es: curva (p, (.4, .5, .2, .6))
def heart_curve (p):
curva de retorno (p, (.4, .5, . 2, .6)) # Parámetros de la curva de Bézier del amor
#################función de ritmo de halo########################
# https://cubic -bezier.com/ Sitio web de parámetros de Bezier, el valor de referencia es: curva (p, (.73, .55, .59, .92))
def heart_halo_curve (p):
curva de retorno (p, (.73, .55, .59,.92)) #Parámetros de la curva de Bezier de halo
#################Ajuste del modo de batido#######################
curva def(p, b ):
t = pecado(p)
p0 = b[0]
p1 = b[1]
p2 = b[2]
p3 = b[3]
t1 = (1 - t)
t2 = t1 * t1
t3 = t2 * t1
# Modo Bessel
# r = p0 * t3 + 3 * p1 * t * t2 + 3 * p2 * t * t * t1 + p3 * ( t * * 3)
# Modo de función trigonométrica
r = 2 * (2 * sin(4 * p)) / (2 * pi)
return r
#################Crear una clase de corazón#######################
clase Corazón:
def __init__( self, generate_frame=20):
self._points = set() # Conjunto de coordenadas de amor original
self._edge_diffusion_points = set() # Conjunto de coordenadas de puntos de efecto de difusión de borde
self._center_diffusion_points = set() # Conjunto de coordenadas de puntos de efecto de difusión central self
.all_points = {} # Coordenadas de puntos dinámicos de cada cuadro
self.build(2000) # El número inicial de puntos no debe ser demasiado grande
self.generate_frame = generate_frame
para el marco en el rango (generate_frame):
self.calc (marco)
def build(self, número):
# 爱心
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))
# Difundir nuevamente
point_list = list(self._points)
for _ in range(4000):
x, y = random.choice(point_list)
x, y = scatter_inside(x, y, 0.24) #Ajustar el número de puntos de amor dispersos , valor de referencia: 0,24
self._center_diffusion_points.add((x, y))
@staticmethod
def calc_position(x, y, ratio):
# Ajusta la
fuerza de escala = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.47) # Parámetro mágico
dx = relación * fuerza * (x - CANVAS_CENTER_X) + random.randint(-1, 1)
dy = relación * fuerza * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)
devolver x - dx, y - dy
def calc(self, generate_frame):
ratio = 10 * heart_curve(generate_frame / 10 * pi) # La relación de escala del período suave
halo_radius = int(4 + 6 * (1 + heart_halo_curve(generate_frame / 10 * pi)))
halo_number = int(3000 + 4000 * abs(heart_halo_curve(generate_frame / 10 * pi) ** 2))
todos_puntos = []
#
Punto_halo_corazón = set( ) #
Punto_halo_corazón ) + 11) x, y = encoger(x, y, halo_radius) si (x, y) no está en heart_halo_point: heart_halo_point.add((x, y)) random_int_range = int(27 + heart_halo_curve(generate_frame / 10 * pi) * 4) x += random.randint(-random_int_range, random_int_range) y += random.randint(-random_int_range, random_int_range) tamaño = random.choice((1, 1, 2))
all_points.append((x, y, tamaño))
# 轮廓
para x, y en self._points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 3)
all_points.append((x, y, size))
# Utilizar
para x, y en self._edge_diffusion_points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 2)
all_points.append((x, y, size))
para x, y en self._center_diffusion_points:
x, y = self.calc_position(x, y, ratio)
tamaño = random.randint(1, 2)
all_points.append((x, y, tamaño))
self.all_points[generate_frame] = todos_puntos
def render(self, render_canvas, render_frame):
para x, y, tamaño en self.all_points[render_frame % self.generate_frame]:
render_canvas.create_rectangle(x, y, x + tamaño, y + tamaño, ancho=0, relleno= CORAZÓN_COLOR)
def frame_count(self):
devuelve self.generate_frame
#################绘制函数#########################
def dibujar (principal: Tk, render_canvas_dict: dict, render_heart: Corazón, render_frame=0):
frame_index = render_frame % render_heart.frame_count()
last_frame_index = (frame_index + render_heart.frame_count() - 1) % render_heart.frame_count()
si last_frame_index en render_canvas_dict:
render_canvas_dict[last_frame_index] .pack_forget()
si frame_index no está en render_canvas_dict:
lienzo = Lienzo(
principal,
bg='negro', # Color de fondo
alto=CANVAS_HEIGHT,
ancho=CANVAS_WIDTH
)
lienzo.pack()
render_heart.render(canvas, render_frame)
canvas.create_text(
CANVAS_CENTER_X,
CANVAS_CENTER_Y,
text=HEART_CENTER_TEXT,
fill=HEART_CENTER_TEXT_COLOR,
font=('楷体', 48, 'negrita') # 字体
)
render_canvas_dict[frame_index] = lienzo
más:
render_canvas_dict[frame_index].pack()
main.after(
10, #
sorteo del intervalo de cambio de pantalla, main, render_canvas_dict, render_heart, render_frame + 1)
def dow():
ventana = tk.Tk()
ancho = window.winfo_screenwidth()
alto = window.winfo_screenheight()
a = random.randrange(0, ancho)
b = random.randrange(0, alto)
window.title( 'Hola')
window.geometry("200x50" + "+" + str(a) + "+" + str(b))
tk.Label(window,text='我永远爱你', bg='Red' , fuente=('楷体', 17), ancho=15, alto=2).pack()
respuesta="no"
if __name__ == '__main__':
start_time = time.time()
i = 1
while respuesta == "no": # bucle while, seguirá repitiéndose cuando el valor de la respuesta sea no
# Aparece un método de llamada emergente "Ventana emergente de pregunta", el título es "Respuesta", la pregunta es "¿Eres un cerdo?" y determina el valor de retorno de este método
si messagebox.askquestion ("Pregunta", "¿Me amas?" ) == "yes": # Si el valor de retorno es "sí"
messagebox.showinfo("Yo también", "Yo también te amo"). # Aparecerá una "ventana emergente"
respuesta = "yes" # Entonces cambia el valor de respuesta a sí, que es el final del bucle (también se puede usar break directamente aquí)
else:
messagebox.showinfo("?", "¿Eres tonto? Te daré otra oportunidad.") # Aparecerá la "ventana de aviso"
i = i + 1
si i > 3:
i=i%3
messagebox.showinfo("Sang Xin", "¡Me perdiste, adiós!")
time.sleep(5)
messagebox.showinfo("Jaja", "Es broma, no tomes la decisión equivocada esta vez").
root = Tk() # Dibujar la interfaz Tk
root.title(WINDOWS_TITLE)
root.attributes("-topmost",1)
scrnW = root.winfo_screenwidth()
scrnH = root.winfo_screenheight()
ancho = root.winfo_width()
alto = root.winfo_height() # Resolución de pantalla
izquierda= (scrnW - ancho) / 2-320
top= (scrnH - alto) / 2-240
root.geometry('+%d+%d ' % (izquierda, arriba)) # Centro
canvas_dict = {}
corazón = Corazón(40) # 40 fotogramas es el mejor
sorteo (raíz, lienzo_dict, corazón) # Dibujar
end_time = time.time()
root.mainloop()