Tkinter Application Returns Random Values

I made a Python application using Tkinter for an electromagnetics assignment. It is a magnitude calculator for a 3-dimensional vector. The code: from tkinter import * root = Tk()

Solution 1:

Well the code structure was a bit too harsh on me, so I had to think of other logical ways but ended up getting a hacky way around.

I've commented the code so as to make the understand easier on-the-go:

from tkinter import *

root = Tk()
root.title("Calculator")

coordinates = [] # making empty list to hold all the numbers
xi,yi,zi = [],[],[] #making empty list to hold only the corresponding numbers

n = 0#initial value of n

X = Entry(root)
X.grid(row=0, column=0, columnspan=3, padx=12, pady=15)

Y = Entry(root)
Y.grid(row=1, column=0, columnspan=3, padx=12, pady=15)

Z = Entry(root)
Z.grid(row=2, column=0, columnspan=3, padx=12, pady=15)

defx():
    global n
    n = 1defy():
    global n
    n = 2defz():
    global n
    n = 3defS(m):
    if n == 1: #if n is 1
        X.insert(END,str(m)) #then insert the clicked number to the end of the corresponding entry box 
        coordinates.append(X.get()) #append to the main list of all numbers if n == 2:
        Y.insert(END,str(m)) #doing same as above for y
        coordinates.append(Y.get())
    if n == 3:
        Z.insert(END,str(m)) #doing same as above for z
        coordinates.append(Z.get())

defclear():
    #removing all the entry widget 
    X.delete(0,END)
    Y.delete(0,END)
    Z.delete(0,END)

    #clearing all the lists
    coordinates.clear()
    xi.clear()
    yi.clear()
    zi.clear()
    
defequal():
    xi.append(coordinates[len(X.get())-1]) #get the last entered value from the entire list of numbers for x
    yi.append(coordinates[len(Y.get())+len(X.get())-1]) #get the last entered value from the entire list of numbers for y
    zi.append(coordinates[len(Z.get())+len(X.get())+len(Y.get())-1]) #get the last entered value from the entire list of numbers for z
    final_coordinates = xi+yi+zi #make a new final list that has the cordinates only

    sq = 0for d in final_coordinates:
        e = float(d)
        sq = sq + e**2 
    mag = sq**0.5
    val.config(text=f"The magnitude of the vector is: {round(mag,3)}") #doing this to get rid of overwriting of labels
    val.grid(row=3, column=0, columnspan=4, padx=12, pady=15)
    
b1 = Button(root, text="1", padx=30, pady=15, command=lambda: S(1))
b2 = Button(root, text="2", padx=30, pady=15, command=lambda: S(2))
b3 = Button(root, text="3", padx=30, pady=15, command=lambda: S(3))
b4 = Button(root, text="4", padx=30, pady=15, command=lambda: S(4))
b5 = Button(root, text="5", padx=30, pady=15, command=lambda: S(5))
b6 = Button(root, text="6", padx=30, pady=15, command=lambda: S(6))
b7 = Button(root, text="7", padx=30, pady=15, command=lambda: S(7))
b8 = Button(root, text="8", padx=30, pady=15, command=lambda: S(8))
b9 = Button(root, text="9", padx=30, pady=15, command=lambda: S(9))
b0 = Button(root, text="0", padx=30, pady=15, command=lambda: S(0))
bx = Button(root, text="x", padx=30, pady=15, command=x)
by = Button(root, text="y", padx=30, pady=15, command=y)
bz = Button(root, text="z", padx=30, pady=15, command=z)
bclear = Button(root, text="Clear", padx=19, pady=15, command=clear)
bequal = Button(root, text="=", padx=29, pady=15, command=equal)

b1.grid(row=6, column=0)
b2.grid(row=6, column=1)
b3.grid(row=6, column=2)
b4.grid(row=5, column=0)
b5.grid(row=5, column=1)
b6.grid(row=5, column=2)
b7.grid(row=4, column=0)
b8.grid(row=4, column=1)
b9.grid(row=4, column=2)
b0.grid(row=7, column=1)
bx.grid(row=8, column=0)
by.grid(row=8, column=1)
bz.grid(row=8, column=2)
bclear.grid(row=7, column=2)
bequal.grid(row=7, column=0)

val = Label(root) #declaring here, so that label can be configured later 

root.mainloop()

Explanation:

Imagine, we entered 123 in the x box, 852 in the y box and 369 in the z box, so the final list, coordinates, after appending all x, y, z is

['1', '12', '123', '8', '85', '852', '3', '36', '369']

So now the length of entry on x is 3, and that is our 3rd item on the list. Similarly, the length of the entry on y is 3, that is the 6th item on the list(which is length of x + length of y), same applies to z too. Now since we are indexing it, we will go 1 down(subtract 1) always, because indexing starts from 0, whereas our counting starts from 1.

Also, I removed the placeholders from inside the entry box as it can cause inefficiency, maybe just put a label on top of each entry, stating whats the purpose of the entry widget. Also I have used round(mag,3) to round the digit upto 3 decimal values, since I gets awkward after that(for me), you could just get rid of it and have the entire numbers spit out.

Hope this gets the job done, but do let me know if any doubts.

Solution 2:

Here is a simple example of a vector calculator that gets rid of the number buttons, and:

• separates the vector calculations from the GUI. The class Vector is the "Model" that can be used with or without a GUI.
• isolates the various components of the GUI in their own reusable classes: here one class for the entry fields, and one for the output.

You can use this skeletton as a base to add more operations, and polish the use to make it able to chain operations in a smoother manner.

import tkinter as tk


classVector:
    def__init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def__add__(self, other):
        return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
    defdot(self, other):
        returnsum(s*o for s, o inzip(self, other))
    defmag(self):
        return self.dot(self)**.5def__iter__(self):
        for elt in self.x, self.y, self.z:
            yield elt
    def__str__(self):
        returnf'Vector({self.x}, {self.y}, {self.z})'classVecEntry(tk.Frame):
    def__init__(self, master):
        self.master = master
        super().__init__(master)
        tk.Label(self, text='x coord').grid(column=0, row=0)
        self.x_entry = tk.Entry(self)
        self.x_entry.grid(column=1, row=0)
        
        tk.Label(self, text='y coord').grid(column=0, row=1)
        self.y_entry = tk.Entry(self)
        self.y_entry.grid(column=1, row=1)
        
        tk.Label(self, text='z coord').grid(column=0, row=2)
        self.z_entry = tk.Entry(self)
        self.z_entry.grid(column=1, row=2)
        
    defget_coords(self):
        x = float(self.x_entry.get())
        y = float(self.y_entry.get())
        z = float(self.z_entry.get())
        return x, y, z

    
classVecOut(tk.Frame):
    def__init__(self, master, vector):
        self.master = master
        super().__init__(master)
        self.vector = vector
        
        tk.Label(self, text='x coord').grid(column=0, row=0)
        tk.Label(self, text=str(self.vector.x)).grid(column=1, row=0)

        tk.Label(self, text='y coord').grid(column=0, row=1)
        tk.Label(self, text=str(self.vector.y)).grid(column=1, row=1)
   
        tk.Label(self, text='z coord').grid(column=0, row=2)
        tk.Label(self, text=str(self.vector.z)).grid(column=1, row=2)
        
        tk.Label(self, text='mag: ').grid(column=0, row=3)
        tk.Label(self, text=str(self.vector.mag())).grid(column=1, row=3)
                
        
classVectorCalc(tk.Tk):
    def__init__(self):
        super().__init__()
        self.vecentry_1 = VecEntry(self)
        self.vecentry_1.pack(anchor=tk.NE)
        self.vecentry_2 = VecEntry(self)
        self.vecentry_2.pack(anchor=tk.NE)
        self.add = tk.Button(self, text='+', command=self.add_vectors)
        self.add.pack(side=tk.RIGHT)
        self.vecout = Nonedefadd_vectors(self):
        v0 = Vector(*self.vecentry_1.get_coords())
        v1 = Vector(*self.vecentry_2.get_coords())
        result = v0 + v1
        print(f'{v0} + {v1} = {result}')
        print(f'the magnitude of the resultant vector is: {result.mag()}')
        self.vecout = VecOut(self, result)
        self.vecout.pack()
        
        
        
VectorCalc().mainloop()

Console Output:

Vector(4.0, 4.0, 4.0) + Vector(5.0, 5.0, 5.0) = Vector(9.0, 9.0, 9.0)
the magnitude of the resultant vector is: 15.588457268119896

GUI aspect: