Jetzt muss ich die Werte zwei mal einlesen(?). Ich benötige im "Eingabebildschirm" alle Werte aus der "Maschine_type"-Spalte und erst wenn wenn in dem Drop-Down-Menü eine Maschine ausgewählt wurde, kann ich die benötigten Werte für die Berechnungen auslesen.
Code: Alles auswählen
#!/usr/bin/env python3
import sqlite3
from contextlib import closing
import tkinter as tk
from functools import partial
DATABASE = "database.db"
class CalculationApp(tk.Frame):
def __init__(self, master, connection):
tk.Frame.__init__(self, master)
self.frames = {}
home_page = Home(self)
home_page.grid(row=0, column=0, sticky=tk.NSEW)
entry_page = Entry(self)
entry_page.grid(row=0, column=0, sticky=tk.NSEW)
result_page = Result(self, connection)
result_page.grid(row=0, column=0, sticky=tk.NSEW)
self.frames["Home"] = home_page
self.frames["Entry"] = entry_page
self.frames["Result"] = result_page
self.show_page("Home")
def show_page(self, page_name):
self.frames[page_name].tkraise()
def get_page(self, page_name):
return self.frames[page_name]
class Home(tk.Frame):
def __init__(self, controller):
tk.Frame.__init__(self)
self.controller = controller
headline = tk.Label(self, text="Hier gehts zur Berechnung")
headline.grid(row=0, column=1)
go_to_entry_page = tk.Button(
self, text=">>", command=partial(self.controller.show_page, "Entry")
)
go_to_entry_page.grid(row=1, column=3)
class Entry(tk.Frame):
def __init__(self, controller, machine_types):
tk.Frame.__init__(self)
self.controller = controller
self.machine_types = machine_types
tk.Label(self, text="Bitte Maschine auswählen").grid(row=0, column=1)
machine_choice = tk.OptionMenu(self, "", *self.machine_types)
machine_choice.grid(row=1, column=0)
tk.Label(self, text="Bitte Fläche eingeben").grid(row=2, column=1)
self.area = tk.Entry(self)
self.area.grid(row=3, column=1)
tk.Label(self, text="Bitte Gastemperatur eingeben").grid(row=4, column=1)
self.inlet_gas_temperature = tk.Entry(self)
self.inlet_gas_temperature.grid(row=5, column=1)
tk.Button(
self, text="Berechne", command=partial(self.controller.show_page, "Result")
).grid(row=3, column=3)
tk.Button(
self, text="<<", command=partial(self.controller.show_page, "Home")
).grid(row=3, column=0)
@classmethod
def from_database(cls, connection):
with closing(connection.cursor()) as cursor:
cursor.execute("SELECT MACHINE_TYPE" " FROM KINETICS")
machine_types = cursor.fetchall()
print(machine_types)
return cls(machine_types)
class Result(tk.Frame):
def __init__(self, controller, connection):
tk.Frame.__init__(self)
self.controller = controller
self.outlet_gas_temperature = tk.Label(
self, text=machine.thermodynamic_properties
)
self.outlet_gas_temperature.grid(row=0, column=1)
self.force = tk.Label(self, text=machine.kinetics_properties)
self.force.grid(row=1, column=1)
button = tk.Button(
self, text="Startseite", command=partial(controller.show_page, "Home")
)
button.grid(row=2, column=1)
class Kinetics:
def __init__(self, area, force):
self.area = area
self.force = force
@property
def pressure(self):
return self.force / self.area
@classmethod
def from_database(cls, connection, machine_type, area):
with closing(connection.cursor()) as cursor:
cursor.execute(
("SELECT FORCE" " FROM KINETICS" " WHERE machine_type=?"),
[machine_type],
)
force = cursor.fetchone()[0]
return cls(area, force)
class Thermodynamic:
def __init__(self, inlet_gas_temperature, volume_in, volume_out):
self.inlet_gas_temperature = inlet_gas_temperature
self.volume_in = volume_in
self.volume_out = volume_out
@property
def outlet_gas_temperature(self):
return self.volume_out * self.inlet_gas_temperature / self.volume_in
@classmethod
def from_database(cls, connection, machine_type, inlet_gas_temperature):
with closing(connection.cursor()) as cursor:
cursor.execute(
(
"SELECT volume_in, volume_out"
" FROM THERMODYNAMICS"
" WHERE machine_type=?"
),
[machine_type],
)
volume_in, volume_out = cursor.fetchone()
return cls(inlet_gas_temperature, volume_in, volume_out)
class Machine:
def __init__(self, thermodynamic_properties, kinetics_properties):
self.thermodynamic_properties = thermodynamic_properties
self.kinetics_properties = kinetics_properties
@classmethod
def from_database(cls, connection, machine_type, inlet_gas_temperature, area):
return cls(
Thermodynamic.from_database(
connection, machine_type, inlet_gas_temperature
),
Kinetics.from_database(connection, machine_type, area),
)
def main():
root = tk.Tk()
root.title("Berechnungsprogramm")
app = CalculationApp(root)
app.mainloop()
if __name__ == "__main__":
main()
Code: Alles auswählen
#!/usr/bin/env python3
import sqlite3
from contextlib import closing
import tkinter as tk
from functools import partial
DATABASE = "database.db"
class CalculationApp(tk.Frame):
def __init__(self, master, connection):
tk.Frame.__init__(self, master)
self.frames = {}
home_page = Home(self)
home_page.grid(row=0, column=0, sticky=tk.NSEW)
entry_page = Entry(self, connection)
entry_page.grid(row=0, column=0, sticky=tk.NSEW)
result_page = Result(self)
result_page.grid(row=0, column=0, sticky=tk.NSEW)
self.frames["Home"] = home_page
self.frames["Entry"] = entry_page
self.frames["Result"] = result_page
self.show_page("Home")
def show_page(self, page_name):
self.frames[page_name].tkraise()
def get_page(self, page_name):
return self.frames[page_name]
class Home(tk.Frame):
def __init__(self, controller):
tk.Frame.__init__(self)
self.controller = controller
headline = tk.Label(self, text="Hier gehts zur Berechnung")
headline.grid(row=0, column=1)
go_to_entry_page = tk.Button(
self, text=">>", command=partial(self.controller.show_page, "Entry")
)
go_to_entry_page.grid(row=1, column=3)
class Entry(tk.Frame):
def __init__(self, controller, connection):
tk.Frame.__init__(self)
self.controller = controller
self.connection = connection
self.machine_types = self.from_database()
self.machine_choice = tk.StringVar()
tk.Label(self, text="Bitte Maschine auswählen").grid(row=0, column=1)
machine_choice = tk.OptionMenu(self, self.machine_choice, *self.machine_types)
machine_choice.grid(row=1, column=0)
tk.Label(self, text="Bitte Fläche eingeben").grid(row=2, column=1)
self.area = tk.Entry(self)
self.area.grid(row=3, column=1)
tk.Label(self, text="Bitte Gastemperatur eingeben").grid(row=4, column=1)
self.inlet_gas_temperature = tk.Entry(self)
self.inlet_gas_temperature.grid(row=5, column=1)
tk.Button(self, text="Berechne", command=self.show_result).grid(row=3, column=3)
tk.Button(
self, text="<<", command=partial(self.controller.show_page, "Home")
).grid(row=3, column=0)
def from_database(self):
with closing(self.connection.cursor()) as cursor:
cursor.execute("SELECT MACHINE_TYPE" " FROM KINETICS")
return cursor.fetchone()
def show_result(self):
machine = Machine.from_database(
self.connection,
self.machine_choice.get(),
int(self.inlet_gas_temperature.get()),
int(self.area.get()),
)
self.controller.get_page("Result").outlet_gas_temperature.config(
text=machine.thermodynamic_properties.outlet_gas_temperature
)
self.controller.get_page("Result").force.config(
text=machine.kinetics_properties.pressure
)
self.controller.show_page("Result")
class Result(tk.Frame):
def __init__(self, controller):
tk.Frame.__init__(self)
self.controller = controller
self.outlet_gas_temperature = tk.Label(self, text="")
self.outlet_gas_temperature.grid(row=0, column=1)
self.force = tk.Label(self, text="")
self.force.grid(row=1, column=1)
button = tk.Button(
self, text="Startseite", command=partial(controller.show_page, "Home")
)
button.grid(row=2, column=1)
class Kinetics:
def __init__(self, area, force):
self.area = area
self.force = force
@property
def pressure(self):
return self.force / self.area
@classmethod
def from_database(cls, connection, machine_type, area):
with closing(connection.cursor()) as cursor:
cursor.execute(
(
"SELECT FORCE"
" FROM KINETICS"
" WHERE machine_type=?"
),
[machine_type],
)
force = cursor.fetchone()[0]
return cls(area, force)
class Thermodynamic:
def __init__(self, inlet_gas_temperature, volume_in, volume_out):
self.inlet_gas_temperature = inlet_gas_temperature
self.volume_in = volume_in
self.volume_out = volume_out
@property
def outlet_gas_temperature(self):
return self.volume_out * self.inlet_gas_temperature / self.volume_in
@classmethod
def from_database(cls, connection, machine_type, inlet_gas_temperature):
with closing(connection.cursor()) as cursor:
cursor.execute(
(
"SELECT volume_in, volume_out"
" FROM THERMODYNAMICS"
" WHERE machine_type=?"
),
[machine_type],
)
volume_in, volume_out = cursor.fetchone()
return cls(inlet_gas_temperature, volume_in, volume_out)
class Machine:
def __init__(self, thermodynamic_properties, kinetics_properties):
self.thermodynamic_properties = thermodynamic_properties
self.kinetics_properties = kinetics_properties
@classmethod
def from_database(cls, connection, machine_type, inlet_gas_temperature, area):
return cls(
Thermodynamic.from_database(
connection, machine_type, inlet_gas_temperature
),
Kinetics.from_database(connection, machine_type, area),
)
def main():
with closing(
sqlite3.connect(DATABASE, detect_types=sqlite3.PARSE_DECLTYPES)
) as connection:
root = tk.Tk()
root.title("Berechnungsprogramm")
app = CalculationApp(root, connection)
app.mainloop()
if __name__ == "__main__":
main()
Code: Alles auswählen
class Entry(tk.Frame):
def __init__(self, controller, connection):
tk.Frame.__init__(self)
self.controller = controller
self.connection = connection
self.machine_types = self.get_machine_types()
self.machine_choice = tk.StringVar()
tk.Label(self, text="Bitte Maschine auswählen").grid(row=0, column=1)
machine_choice = tk.OptionMenu(self, self.machine_choice, *self.machine_types)
machine_choice.grid(row=1, column=0)
tk.Label(self, text="Bitte Fläche eingeben").grid(row=2, column=1)
self.area = tk.Entry(self)
self.area.grid(row=3, column=1)
tk.Label(self, text="Bitte Gastemperatur eingeben").grid(row=4, column=1)
self.inlet_gas_temperature = tk.Entry(self)
self.inlet_gas_temperature.grid(row=5, column=1)
tk.Button(self, text="Berechne", command=self.show_result).grid(row=3, column=3)
tk.Button(
self, text="<<", command=partial(self.controller.show_page, "Home")
).grid(row=3, column=0)
def get_machine_types(self):
with closing(self.connection.cursor()) as cursor:
cursor.execute("SELECT MACHINE_TYPE FROM KINETICS")
machine_types = cursor.fetchall()
return machine_typesIch fürchte, Du bist da auf eines der ganz grundsätzliche Probleme mit SQLite gestoßen. Im Gegensatz zu richtigen Datenbanken ist das nämlich nicht typsicher und läßt es daher zu, daß String-Werte in Integer-Spalten eingetragen werden. Eine richtige Datenbank würde das nicht zulassen -- und außerdem hat offensichtlich derjenige, der die SQLite-Datei erstellt hat, falsche Werte darin eingetragen, und die Integrität der Daten damit zumindest aufs Spiel gesetzt.Dennis89 hat geschrieben: ↑Freitag 22. Juli 2022, 07:02 Das ergibt:Ich habe keinen Editor mit dem ich die *.db-Datei öffnen kann. Aber ich habe sie mal mit dem Windows Standard-Editor geöffnet und mal abgesehen von vielen Sonderzeichen finde ich sowas:Code: Alles auswählen
ValueError: invalid literal for int() with base 10: 'Ausgänge'Code: Alles auswählen
Maschine VARCHAR(30), Ausgänge INTEGER,
Tabellen sind doch auch nach Möglichkeit im Arbeitsspeicher wie Indizes auch. Ich bin auch überrascht was die Statistiken über Indizes angehen soll. Postgres ist doch sehr bekannt dafür eben nicht zu entscheiden was im Arbeitsspeicher gehalten werden soll und was nicht. Die Nutzung von mmap statt direct IO ist doch einer der großen Nachteile die Postgres, im Vergleich zu kommerziellen Lösungen, hat.LukeNukem hat geschrieben: ↑Dienstag 6. September 2022, 16:06 Ich bin mir auch nicht ganz sicher, ob Du den Begriff "Index" in diesem Kontext korrekt benutzt. Das Wort "Index" bezeichnet in der Datenbankwelt üblicherweise eine nach Möglichkeit im Arbeitsspeicher vorgehaltene Datenstruktur mit häufig abgefragten Spalten, um den Zugriff auf die Datenbankinhalte zu beschleunigen. Solche Indizes richten sich üblicherweise nach den typischen Zugriffsmustern auf die Datenbank, kosten aber beim Einfügen oder Updaten der Datenbankinhalte ein bisschen mehr Zeit. Manche Datenbank-Admins machen es daher so, daß sie die Indizes für Masseneintragungen oder -Updates deaktivieren und nach deren erfolgreichem Abschluß wieder aktivieren, wodurch die Indizes mit den aktualisierten Daten neu erzeugt werden. Datenbanksysteme wie PostgreSQL führen sogar eigens Statistiken über ihre Indizes, um im Zweifelsfall entscheiden zu können, welche Indizes im Arbeitsspeicher gehalten werden können und welche auf ein Persistierungsmedium ausgelagert werden können.
Dieses "nach Möglichkeit" trifft natürlich nur bei Datenmengen zu, die problemlos in den freien Arbeitsspeicher passen -- und das auch nur dann, wenn die Software so konfiguriert ist, daß sie den freien Speicher nutzen darf.
Benutzung, Cache Hits und -Misses... Siehe dazu auch [1] und die erste Antwort unter [2].
Wenn der Arbeitsspeicher eng wird, muß jedes speicherintensive Software entscheiden, welche Strukturen sie im Arbeitsspeicher hält und welche nicht. Da sind RDBMS und natürlich auch PostgreSQL keine Ausnahme.DasIch hat geschrieben: ↑Dienstag 6. September 2022, 19:37 Postgres ist doch sehr bekannt dafür eben nicht zu entscheiden was im Arbeitsspeicher gehalten werden soll und was nicht. Die Nutzung von mmap statt direct IO ist doch einer der großen Nachteile die Postgres, im Vergleich zu kommerziellen Lösungen, hat.
Da ich nicht mit Excel arbeite, habe ich keine Idee, was das in Bezug auf die Datenmenge aussagt. Soweit ich weiß, speichern moderne Excel-Versionen die Daten in einem komprimierten XML-Format -- und da sich Textdat(ei)en wie diese meistens mit einer Rate von 90 Prozent komprimieren lassen, gehe ich mal davon aus, daß das keine 10 MB an Rohdaten sind. Wenn das stimmt, ist es jedenfalls eine ziemlich überschaubare Datenmenge, und damit erübrigen sich weitere Erwägungen hinsichtlich des Datenspeichersystems zumindest so lange, wie mehrere Prozesse gleichzeitig schreibend auf die Daten zugreifen sollen.Dennis89 hat geschrieben: ↑Mittwoch 7. September 2022, 06:48 Ja ich habe sehr wenig von der Datenbank gezeigt und bewusst den Namen 'daten' gewählt, weil das nicht meine Daten sind. Es sind Firmendaten und die werde ich nicht einfach so ins Netz stellen. Die gezeigte Tabelle hat im originalen noch mehr Spalten. Aber groß im Sinne vom Speicherplatz ist sie nicht. Ich hatte die mir ausgelesen und in eine Excel-Datei geschrieben und diese Datei hat 64KB.
SQLAlchemy ist eine großartige Software, insofern schließe ich mich der Empfehlung von __blackjack__ an dieser Stelle ausdrücklich an. Allerdings habe ich die Erfahrung gemacht, daß SQLObject von Ian "Effbot" Bicking bei GUI-Software manchmal angenehmer ist und weniger Konfiguration bedarf. Wenn Du Dich aber nur in einen OR-Mapper einarbeiten möchtest, ist SQLAlchemy vermutlich die bessere Wahl.Dennis89 hat geschrieben: ↑Mittwoch 7. September 2022, 06:48 Aktuell versuche ich in SQLAlchemy einzusteigen, das wird ja öfters von @__blackjack__ empfohlen. Das wird dann wohl noch etwas dauern bis ich sagen kann, ob ich mit der Art von Datenbank, wie ich sie jetzt habe und auch aufgeteilt habe, sinnvoll für die Berechnungen ist. Oder ihr mir, wenn ich damit auf Probleme stoße.
Hupsi, Du hast Recht... ich werde alt. Danke für die Richtigstellung.__deets__ hat geschrieben: ↑Donnerstag 8. September 2022, 16:48 Ian Bicking ist nicht Effbot. Das ist Fredrick Lundh. https://www.linkedin.com/in/effbot/
Cool, vielen Dank!
Ach, ich weiß nicht... die Dokumentation von SQLAlchemy finde ich immer noch unübersichtlich, wenngleich die von SQLObject leider auch nicht immer das Gelbe vom Ei ist.
