Calculadora de costos simple de Python usando Tkinter GUI

Explicación del código

Este programa Python utiliza la biblioteca Tkinter para crear una interfaz gráfica de usuario (GUI) simple para una calculadora de costos. El programa define dos constantes, bprice y pprice, que almacenan los precios de por libro y por lápiz respectivamente. El usuario puede introducir el número de libros y lápices en dos cuadros de texto. El programa tiene un botón "Calcular costo total" que cuando se hace clic, activa una función llamada "calculate_total_cost".

La función calculate_total_cost recupera el número de libros y lápices de los cuadros de texto, los multiplica por los precios respectivos y los suma para calcular el costo total. A continuación, la función utiliza el módulo de cuadro de mensajes de la biblioteca Tkinter para mostrar el costo total en un cuadro de mensaje. El bucle de eventos main se inicia llamando al método mainloop() en el objeto Tk(), lo que permite que la GUI permanezca abierta y responda a la entrada del usuario hasta que el usuario cierre la ventana.

Proceso paso a paso

Aquí hay un proceso paso a paso para crear una calculadora de costos simple de Python usando Tkinter GUI:

Importar módulos necesarios: Importe los módulos necesarios para crear una GUI, como Tkinter y ttk.

Importar TKINTER como TK

Desde TKINTER Import TTK

Crear una ventana de Tkinter: Cree una ventana principal para la GUI y establezca sus propiedades, como el título y el tamaño.

raíz = tk. Tk()

root.title("Calculadora de costos")

root.geometry("400x200")

Crear elementos GUI: Cree los elementos de la GUI como Etiquetas, Campos de entrada y Botones utilizando los diversos widgets de Tkinter.

# Crear etiquetas

label_item = ttk. label(root, text="Nombre del elemento:")

label_price = ttk. Label(root, text="Precio del artículo:")

label_quantity = ttk. Label(root, text="Cantidad de artículo:")

# Crear campos de entrada

entry_item = ttk. Entrada(raíz)

entry_price = ttk. Entrada(raíz)

entry_quantity = ttk. Entrada(raíz)

# Botón Crear

button_calculate = ttk. Button(root, text="Calcular")

Agregar elementos GUI a la ventana: Coloque los elementos GUI en la ventana principal usando el administrador de diseño de cuadrícula de Tkinter.

# Agregar etiquetas a la ventana

label_item.grid(row=0, column=0, padx=5, pady=5)

label_price.grid(row=1, column=0, padx=5, pady=5)

label_quantity.grid(row=2, column=0, padx=5, pady=5)

# Agregar campos de entrada a la ventana

entry_item.grid(row=0, column=1, padx=5, pady=5)

entry_price.grid(row=1, column=1, padx=5, pady=5)

entry_quantity.grid(row=2, column=1, padx=5, pady=5)

# Agregar botón a la ventana

button_calculate.grid(row=3, column=1, padx=5, pady=5)

Definir una función para calcular el coste total: cree una función para calcular el coste total en función del precio del artículo y la cantidad introducida por el usuario.

def calculate_costo():

    item_price = float(entry_price.get())

    item_quantity = float(entry_quantity.get())

    total_cost = item_price * item_quantity

tk.messagebox.showinfo(title="Costo total", message=f"Costo total: ${total_cost:.2f}")

Conectar el botón a la función calcular: conecte el botón calcular a la función creada en el paso 5 utilizando el atributo command.

button_calculate = ttk. Button(root, text="Calculate", command=calculate_cost)

Ejecute la GUI: Finalmente, inicie la GUI y ejecútela en el bucle principal usando el método mainloop de Tkinter.

root.mainloop()

¡Eso es todo! Con estos pasos, puede crear una calculadora de costos simple de Python usando Tkinter GUI.

Cómo crear una calculadora científica en lenguaje Python:

Aquí está el código fuente completo para una calculadora científica simple en Python usando Tkinter GUI:

import math import tkinter 

as  tk from  tkinter import ttk

# Create a Tkinter window root   =  tk



. Tk()



root.title("Calculadora
científica")

root.geometry("350x400")# Crear campo de entrada
para mostrar los resultadosentry_display =
ttk. Entry(root, 



width=

50)

entry_display.grid(row=0, column=0, columnspan=5,
padx=5     , pady=5)# Crear función para
eventos de clic de botóndef button_click (número):

  actual = entry_display.get()

  entry_display.delete(0, tk. END) entry_display.insert(0, str(current) + str(number))



def 

button_clear(): 

  entry_display.delete(0,  

  tk. END)def
button_add(): first_number =
entry_display.get() global f_num   global  math_operation math_operation
= "adición"  f_num 

  = float(



first_number)

  entry_display.delete(0, 

  tk. END)def




button_subtract(): first_number =
entry_display.get() global f_num   global  math_operation math_operation
= "substra"

  f_num 

  = 

float(first_number)

  entry_display.delete(0

, 

  tk. END)def
button_multiply(): first_number =
entry_display.get() global f_num   global  math_operation math_operation
= "



multiplication"  f_num 

  = float(

first_number)

  entry_display.delete(

0, 

  tk. END)

def button_divide():
first_number = entry_display.get() global f_num   global  math_operation math_operation
= "division"  f_num



  = float(first_number)

  entry_display.delete(

0, 



  tk. END)def
button_square_root(): first_number =
entry_display.get() global f_num 

 
global  math_operation math_operation = "square_root"  f_num  = float(



first_number)

  entry_display.delete(0, 



  tk. END) result = 



  math.sqrt(f_num)
entry_display.insert(0, result)

def button_power():
first_number = 

  entry_display.get() global f_num
  global math_operation

  math_operation  = "power"



  f_num = float  

  (first_number)



  entry_ display.delete(0

, tk. END)def button_equal(

):

  second_number = entry_display.get()

  entry_display.delete(0, tk.END)  if  math_operation == "suma": resultado = f_num +
float(second_number) elif math_operation == "resta":
resultado = f_num - float(second_number) elif math_operation
==  "multiplicación"



:

  resultado 

  = f_num 

  * 

float(

second_number)  elif    math_operation == 

"división": resultado = f_num / float(second_number)   elif math_operation ==
  "potencia": resultado = 

  math.pow(f_num, float(



second_number))

  entry_display.insert(0, resultado)# Crear botones
para números y operaciones básicas 

  

button_1 = ttk. Button(root, text="1", command=

lambda:
button_click(1))button_2 

= ttk. Button(root, text="2

", command=lambda: button_click(2

))

button_3 = ttk. Button(root, text="3", command

=lambda:
button_click(3))

button_4 = ttk. Button(root, text="4", command=



lambda

: button_click(4))

button_5 = ttk. Button(root, text="5", command=lambda: button_click(5))

button_6 = ttk. Button(root, text="6", command=lambda: button_click(6))

button_7 = ttk. Button(root, text="7", command=lambda: button_click(7))

button_8 = ttk. Button(root, text="8", command=lambda: button_click(8))

button_0 = ttk. Button(root, text="0", command=lambda: button_click(0))

button_add = ttk. Button(root, text="+", command=button_add)

button_subtract = ttk. Button(root, text="-", command=button_subtract)

button_multiply = ttk. Button(root, text="*", command=button_multiply)

button_divide = ttk. Button(root, text="/", command=button_divide)

button_equal = ttk. Button(root, text="=", command=button_equal)

button_clear = ttk. Button(root, text="C", command=button_clear)

button_square_root = ttk. Button(root, text="√", command=button_square_root)

button_power = ttk. Button(root, text="xⁿ", command=button_power)