Das deutsche Python-Forum

Hallo zusammen,

für ein Semesterprojekt habe ich als Thema eine grafische Benutzeroberfläche zu erstellen.

Die Funktion des Codes soll wie folgt aussehen:

1. Werte werden in Eingabefelder eingegeben (x-Wert, y-Wert)
2. Beim bestätigen dieser Werte, werden diese in Listen gespeichert
3. Aus diesen Listen bzw. Daten soll eine Regressionsfunktion berechnet werden (linear, polynomial)
4. Die Regressionsfunktion soll grafisch dargestellt werden

Die Punkte 3 und 4 scheitern. Es wird im Terminal ein Dimensionsfehler angezeigt. Diesen Fehler schaffe ich als Anfänger nicht zu beseitigen. Wäre für eine effektive Hilfe sehr Dankbar.

Hier der code:

import tkinter as tk
from tkinter import ttk
from tkinter import *
from tkinter import filedialog
from tkinter import messagebox

import pandas as pd
from scipy import stats

import numpy

from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)

global count

count = 0

s = "Abzissenwert"
t = "Ordinatenwert"
x = []
y = []

def input_record():
global count

table.insert(parent='', index='end', iid=count, text='',
values=(x_wert_entry.get(), y_wert_entry.get()))
count += 1

a = x_wert_entry.get()
b = y_wert_entry.get()

x.append(a)
y.append(b)
print(x)
print(y)

global parameter
parameter = [a, b]


def Anzeigefeld_löschen():
x_wert_entry.delete(0, tk.END)
y_wert_entry.delete(0, tk.END)


if len(x) != 0:

slope, intercept, r, p, std_err = stats.linregress(x, y)

def funktion(x):
return slope * x + intercept # Geradenfunktion

Schaubild_linear= list(map(funktion, x))


def plot_linear():
fig = Figure(figsize=(5, 5), dpi=100)

plot1 = fig.add_subplot(111)

plot1.scatter(x, y)

plot1.plot(x, Schaubild_linear)
canvas = FigureCanvasTkAgg(fig, master=main)
canvas.draw()

canvas.get_tk_widget().pack()

toolbar = NavigationToolbar2Tk(canvas, main)
toolbar.update()

canvas.get_tk_widget().pack()


if len(x) != 0:

mymodel = numpy.poly1d(numpy.polyfit(x, y, 3))

myline = numpy.linspace(1, 22, 100)

def plot_poly():
fig = Figure(figsize=(5, 5), dpi=100)

plot1 = fig.add_subplot(111)

plot1.scatter(x,y)

plot1.plot(myline, mymodel(myline))

canvas = FigureCanvasTkAgg(fig, master=main)
canvas.draw()

canvas.get_tk_widget().pack()

toolbar = NavigationToolbar2Tk(canvas, main)
toolbar.update()

canvas.get_tk_widget().pack()


"""
Hauptfenster erstellt
"""

main = tk.Tk()
main.title("Ausgeleichsgeradenrechner")
main.geometry("600x600")
main.minsize(width=500, height=500)

"""
Datei-Menüleiste erzeugt
"""

menubar = Menu(main)

filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Speichern", command = "save")
filemenu.add_command(label="Speichern unter", command = "save")

filemenu.add_separator()

filemenu.add_command(label="Daten importieren", command = "save")

filemenu.add_separator()

filemenu.add_command(label="Programm beenden", command = main.destroy)

menubar.add_cascade(label="Datei", menu=filemenu)

"""
Tabellen-Methode aus tkk herausgeholt
"""

table = ttk.Treeview(main)
table.pack()

"""
Tabellenspalten definiert
"""

table["columns"] = s, t #Spaltendefinition
table.column("#0", width=0, stretch=NO)
table.column(s, anchor="center", width=100)
table.column(t, anchor="center", width=100)

"""
Spaltenüberschriften definiert
"""

table.heading("#0", text="", anchor="center")
table.heading(s, text="Abzissenwert", anchor="center")
table.heading(t, text="Ordinatenwert", anchor="center")

"""
Einen Eingaberahmen erzeugt
"""

input_frame = Frame(main)
input_frame.pack()

"""
Spaltenüberschriften der Eingabetabelle definiert
"""

x_wert = Label(input_frame, text=s)
x_wert.grid(row=0, column=1)

y_wert = Label(input_frame, text=t)
y_wert.grid(row=0, column=2)

"""
Eingabefenster für die Messwerte geschaffen
"""

x_wert_entry = ttk.Entry(input_frame)
x_wert_entry.grid(row=1, column=1)

y_wert_entry = ttk.Entry(input_frame)
y_wert_entry.grid(row=1, column=2)

"""
Button zum Zwischenspeichern erzeugt
"""

speicher_button = ttk.Button(main)
speicher_button["text"] = "Eingabe speichern und anwenden"
speicher_button["width"] = 40
speicher_button["command"]= input_record
speicher_button.pack()

"""
Lineare Funktion plotton
"""

linear_button = ttk.Button(main)
linear_button["text"] = "Lineare Funktion ausgeben"
linear_button["width"] =40
linear_button["command"] =plot_linear
linear_button.pack()

"""
Polynomfkt plotten
"""

poly_button = ttk.Button(main)
poly_button["text"] = "Polynomiale Funktion ausgeben"
poly_button["width"]=40
poly_button["command"]= plot_poly
poly_button.pack()

"""
Einen Löschbutton erzeugt
"""

delete_button = ttk.Button(main)
delete_button["text"] = "Eingabewert Löschen"
delete_button["width"] = 40
delete_button["command"] = Anzeigefeld_löschen
delete_button.pack()

"""
Button um das Programm zu beenden
"""

quit_button = ttk.Button(main)
quit_button["text"] = "Programm beenden"
quit_button["width"] = 40
quit_button["command"] = main.destroy
quit_button.pack()

for item in table.keys(): # So kann man nachsehen welche Schlüsselwörter für ein label verwendet wurden und was drin steht
print(item, ": ", table[item])


main.config(menu=menubar)
main.mainloop()

Bitte die Code-Tags beim posten von Code benutzen, damit der Code eingerueckt und damit verstaendlich bleibt. Und auch bitte die vollstaendige Fehlermeldung (ebenfalls in code tags) posten.

*-Importe benutzt man nicht, weil man sich damit unkontrolliert Namen in den eigenen Namensraum schaufelt. `filedialog` und `messagebox` werden importiert, aber gar nicht benutzt. `pandas` wird importiert, aber nicht benutzt.
`global` darf man nicht benutzen, weil globaler Zustand ein Programm unwartbar macht. So wie Du das benutzt, ist es auch nicht richtig. Globale Variablen verwendet man nicht, alles was eine Funktion braucht, muß sie über ihre Argumente bekommen. Bei GUI-Programmen läuft das zwangsläufig auf Klassen-Definitionen hinaus. Wenn Du das noch nicht verinnerlicht hast, gehe nocheinmal ein paar Schritte zurück und lerne erst das.
Auf oberster Ebene darf kein Programmcode stehen, sondern der muß auch in Funktionen wandern, üblicherweise definiert man sich eine Funktion main die das Hauptprogramm enthält.

Dann hast Du noch ein grundsätzliches Verständnisproblem, wie GUIs funktionieren. Du versuchst Dinge sofort zu berechnen, die erst Sinn machen, wenn der Nutzer Gelegenheit hatte etwas einzugeben. Diese Berechnungen müssen in `plot_linear` oder `plot_poly` stattfinden.

Mehrzeilige Literale Zeichenketten sind keine Kommentare. Für Kommentare gibt es #. Viele Deiner Kommentare verwirren aber mehr, als dass sie dem Leser verständlich machen, warum da was im Code steht.
Die Optionen gibt man direkt per Keyword-Argumente beim Erzeugen von Buttons, Labels, etc. an, und setzt sie nicht erst hinherher.

Vielen Dank für deine Kritikpunkte und Hilfe.