[Sqlite] Alternativer Zugriff auf Objekte ohne Indexangabe

Installation und Anwendung von Datenbankschnittstellen wie SQLite, PostgreSQL, MariaDB/MySQL, der DB-API 2.0 und sonstigen Datenbanksystemen.
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Guten Morgen,

ich benötige mal wieder euere Hilfe. Ich habe hier eine *.db - Datei bekommen und etwas Pythoncode der ein paar Maschinendaten berechnet/ausgibt. Das sollte man allerdings erweitern und dazu versuche ich gerade etwas mehr Struktur reinzubringen und den Code leserlicher zu schreiben. Ich habe allerdings nichts, das man Erfahrung in Bezug auf Datenbanken nennen könnte.

Ich zeig euch mal stark vereinfacht wie die *.db -Datei aussieht. Mit:

Code: Alles auswählen

from sqlite3 import connect
from contextlib import closing


DATABASE = "daten.db"

def main():
    with closing(connect(DATABASE)) as connection:
        with connection:
            with closing(connection.cursor()) as cursor:
                table = cursor.execute("SELECT * FROM daten;")
                for table_content in table:
                    print(table_content)



if __name__ == '__main__':
    main()
erhalte ich

Code: Alles auswählen

('Maschine', 'Ausgänge', 'Form', 'Besonderheit', 'Antriebsart')
('Maschine A', 1, 'v', 'd,e', 'Keilriemen')
Die erste Zeile beinhaltet im orignial noch viele weitere "Überschriften" und danach folgen viele weitere Maschinentypen mit ihren Eigenschaften.
Den Code den ich bekommen habe sieht so aus:

Code: Alles auswählen

verbindung = sqlite3.connect("daten.db")
zeiger = verbindung.cursor()
zeiger.execute("SELECT * FROM daten WHERE Block=?", ('Maschine A',))
for daten in zeiger:
    ausgang = daten[1]  ## Anzahl der Ausgänge
Allerdings mit einer laaaaangen 'for'-Schleife, da ja alle Index-Werte so nacheinander abgefragt werden.
Das wäre für mich vielleicht noch ok bei ein paar Indexwerten, aber es wird bis auf Index 100 zugegriffen.
Ich würde gerne die Datenbank einlesen und dann wenn ich einen Wert daraus brauche, diesen rausziehen. Ich weis nur nicht wirklich wie ich das geschickt anstellen soll.
Die erste Überlegung war, das ich eine Klasse erstelle und den Inhalt der Tabelle an sprechende Namen und 'self' binde. Aber das ist zum einen viel Schreibarbeit, ich würde immer noch den Index nutzen und wenn ich was ändern muss, ist es so unübersichtlich wie jetzt.
Ich stelle mir das wie bei einem Art Dictonary vor, das ich mit Keys auf die gewünschten Werte zugreifen kann.
Wie würdet ihr vorgehen? Wenn es sinnvoll ist, dann schreibe ich die *.db-Datei auch um. Ich möchte dass das Programm nachher so ist, das ich auch in 3 Monaten noch relativ schnell weis, was wo gemacht wird.

Ich hoffe ich habe mein Problem einigermaßen verständlich erklären können.

Vielen Dank schon einmal.

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@Dennis89: 100 Spalten ist ein bisschen viel. Kann man das nicht sinnvoll auf mehrere Tabellen aufteilen?

Das würde vor der Schleife schon sehr lang werden, denn beim SELECT sollte kein * stehen sondern die Spaltennamen die selektiert werden. Wobei das dann auch kürzer werden kann, weil da ja dann nur die Spalten stehen, deren Werte man auch tatsächlich haben will.

Ansonsten würde ich wie immer SQLAlchemy in den Raum werfen. 😎
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Was mich wundert ist, wieso Du die Spaltennamen ausgegeben bekommst, wenn Du nur den Inhalt der Tabelle ausgibst?

Die Frage mit den Index-Werten verstehe ich nicht. Auch nicht, wie eine laaaaange for-Schleife entstehen sollte.
Ich habe so ein Gefühl, dass Du Sachen nachprogrammieren willst, die eigentlich eine Datenbank erledigen sollte, also Filtern und Aggregieren.
Man hat ja eine konkrete Fragestellung, die man gerne beantwortet haben möchte, und dafür schreibt man eine konkrete SQL-Abfrage, die im Idealfall die Information schon so liefert, wie man sie braucht.

Kannst Du die Frage beantworten, welche konkrete Information Du aus der Datenbank ziehen möchtest?
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Danke für eure Antworten.
@__blackjack__ die Aufteilung in mehrere Tabellen wäre möglich, da ich pro Berechnung immer nur ein "paar" Zusammenhängende Informationen brauche. So könnte ich mehrere Tabellen aufbauen.
Nach dem ich in deinen Beiträgen immer wieder SQLAlchemy gelesen habe, wollte ich mir das tatsächlich mal anschauen, hatte aber noch nie Verwendung dafür. Das könnte ich jetzt ändern.

@Sirius3 Ich vermute, dass das keine ordentliche aufgebaute Datenbank ist und ich deswegen die Spaltennamen bekomme. Wie die Datenbank entstanden ist, weis ich leider nicht.
Mit der langen 'for'-Schleife meinte ich folgendes. Den Codeausschnitt den ich gepostet habe, der setzt sich in der 'for'-Schleife so wie mit 'ausgabe=...' angegeben fort. Sprich es werden weitere Namen an aufsteigende Indexwerte gebunden.
Ja ich weis welche Daten ich für welche Berechnung aus der Datenbank haben möchte.

Zusammengefasst heißt das, ich muss zum einen eine Datenbank mit "richtigen" Spaltennamen erstellen, lernen wie SQL-Abfragen gemacht werden und geschickter geht das mit SQLAlchemy?

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Ich vermute mal, dass er die Spaltennamen bekommt, weil jemand die DB als CSV missbraucht hat, und sie einfach als erste Zeile mitimportiert hat.

Ein moegliches Vorgehen hier: statt gezielter Abfragen kann man aus jeder Zeile ein dict machen, auf das man dann per Schluessel zugreift. Manche DB-Adapter koennen das von Haus aus, SQLite scheint es nicht zu koennen, aber es gibt einen Workaround: https://stackoverflow.com/questions/330 ... lite-query
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Es gibt bei Datenbanken keine "erste Zeile". Du mußt also immer dafür sorgen, dass solche Zeilen herausgefiltert werden, oder die Datenbank nochmal sauber aufsetzen.

Wenn ich Dich jetzt richtig verstanden habe, suchst Du einfach nur Tuple-Unpacking:

Code: Alles auswählen

zeiger.execute("SELECT Form, Ausgang FROM daten WHERE Block=?", ('Maschine A',))
for form, ausgang in zeiger:
    ...
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Danke für die weiteren Antworten.

@__deets__ das teste ich mal aus und schaue wie übersichtlich das wird.

@Sirius3 Ja das wäre eine Lösung und deckt sich mit der Aussage von @__blackjack__ dass der '*' durch Spaltennamen ersetzt werden sollte. Auch das versuche ich mal.

Als erstes schaue ich jetzt mal, wie ich aus der Datenbank eine ordentliche Datenbank erstellen kann, so damit Spaltennamen dann auch wirklich welche sind.

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Benutzeravatar
noisefloor
User
Beiträge: 3843
Registriert: Mittwoch 17. Oktober 2007, 21:40
Wohnort: WW
Kontaktdaten:

Hallo,

wenn die DB wirklich als CSV "missbraucht" wurde, macht es ggf. Sinn, die Daten in Pandas zu laden und dann da neu zu strukturieren. Kann, muss aber nicht sinnvoll sein.
Als erstes schaue ich jetzt mal, wie ich aus der Datenbank eine ordentliche Datenbank erstellen kann,
Heißt " ordentlichen Datenbank", dass du die Möglichkeit hast, die Daten umzustrukturieren, also auf mehrere Tabellen und dann Relationen zu setzen? Das macht bei relationalen Datenbanken nämlich Sinn. Wenn nicht wäre ggf. noch die Frage, ob ein RDBMS wie SQLite überhaupt die richtige DB ist.

Bzgl. SQL und SQLAlchemy: IMHO ist es sehr hilfreich, dass man ein Grundwissen SQL hat, wenn man mit SQLAlchemy (oder ein anderes ORM) nutzen will. Damit man überhaupt eine Idee hat, was SQLAlchemy überhaupt im Hintergrund veranstaltet. "Grundwissen SQL" würde ich mit CRUD Operationen, Fremdschlüssel und einfache Joins über zwei Tabellen beschreiben. Also Sachen, die man sich in wenigen Stunden anlesen kann.

Gruß, noisefloor
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

danke für deine Antwort.

Ja ich habe die *.db-Datei (eine Kopie davon) und kann theoretisch damit machen was ich will bzw. eine andere erstellen und diese dann benutzen. Wichtig ist eigentlich nur, dass das Ergebnis der Berechnungen noch stimmt und das ein strukturierter Code dabei rauskommt (so gut ich es eben hinbekomme), den man auch erweitern kann.

Die SQl-Grundlagen werde ich mir erarbeiten.

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

ich denke gerade über die Gestaltung der Datenbank nach. Ich kann je nach Berechnung Tabellen mit den benötigten Werten anlegen, also zum Beispiel eine Tabelle mit der ich auftretende Kräfte berechnen kann und in der zweiten Tabelle sind Werte mit der ich zum Beispiel Geschwindigkeiten berechnen kann. All diese Tabellen haben dann den Maschinentyp für den berechnet wird gemeinsam.
Ich sehe jetzt gerade keinen Vorteil darin, den ich kann ja aus der "großen" Tabelle auch immer die Daten ziehen, die ich aktuell brauche. Das war in meinem ersten Beitrag vielleicht auch von mir doof dargestellt. Das war zwar in dem Code so gemacht, dass da soviel ausgelesen wird, aber das war an der Stelle nicht notwendig. Ich lasse mich aber gerne über die Vorteile von mehreren Tabellen überzeugen.

Wenn ich nach SQl Platzhalter suche, dann bekomme ich hunterte von Beispielen für den "WHERE"-Teil. Ich will aber in "SELECT" nicht händisch die Spalten eintragen und dass man *keine* f-Strings oder so an SQL übergibt habe ich hier schon sehr oft gelesen.
Gestern Abend habe ich hier ziemlich viel Zeit verbracht und mich in SQL eingelesen, aber dazu nichts gefunden.

Heute morgen habe ich mich noch etwas mit pandas beschäftigt und bin da auch auf ein Fragezeichen gestoßen.
Mein überlegtes Vorgehen orientiert sich an dieser Seite: https://datatofish.com/pandas-dataframe-to-sql/

Ich würde jetzt wie in @__deets__ Links beschrieben ein Dictonary aus der Datenbank machen. Und dann wie beschrieben ein DataFrame erstellen und daraus dann eine neue Datenbank erstellen. War das so oder so ähnlich gedacht?


Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Benutzeravatar
noisefloor
User
Beiträge: 3843
Registriert: Mittwoch 17. Oktober 2007, 21:40
Wohnort: WW
Kontaktdaten:

Hallo,
Wenn ich nach SQl Platzhalter suche, dann bekomme ich hunterte von Beispielen für den "WHERE"-Teil. Ich will aber in "SELECT" nicht händisch die Spalten eintragen...
Paltzhalter für die SELECT Klausel sind eigentlich nicht vorgesehen, also die Python DB API unterstützt das nicht (jedenfalls nicht, dass ich wüßte). Eigentlich braucht man das auch nicht, WENN die Datenbank vernünftig strukturiert / normalisiert ist. Gut, das ist bei dir ja nicht der Fall, was dann ggf. mehr Tipparbeit ist.

Bzgl. Pandas: wenn du eine große Tabelle mit allen Daten hast, dann kannst du die Tabelle doch direkt einlesen: pandas.read_sql_table.

Gruß, noisefloor
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Guten Morgen,

danke für die Antwort.

Ich glaube ich habe einen weiteren Hinweis darauf gefunden, das mit der *.db-Datei etwas nicht stimmt. Ich habe 'read_sql_table' versucht:

Code: Alles auswählen

from sqlalchemy import create_engine
import pandas as pd


DATABASE = "daten.db"

def main():
    connection = create_engine(f'sqlite:///{DATABASE}').connect()
    table = pd.read_sql_table('daten', connection)
    print(table)


if __name__ == '__main__':
    main()
Das ergibt:

Code: Alles auswählen

ValueError: invalid literal for int() with base 10: 'Ausgänge'
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

Maschine VARCHAR(30),
Ausgänge  INTEGER,
Da "Maschine", "Ausgänge" etc. nicht als Spaltennamen definiert sind, will pandas aus dem String "Ausgänge" ein Integer machen? Das führt natürlich zu der Fehlermeldung.
Kann ich die Datenbank noch irgendwie retten?

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
einfachTobi
User
Beiträge: 491
Registriert: Mittwoch 13. November 2019, 08:38

Du kannst dir bequem mit dem DB Browser for SQLite einen Überblick verschaffen und die erforderlichen Änderungen durchführen.
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Das was Du da siehst, ist der interne Aufbau der Datenbank. Was Du lesen kannst, ist die Definition der Tabelle, die bei SQLite als lesbarer Text gespeichert wird, und dort siehst Du, dass die Tabelle die Felder Maschine und Ausgänge hat, wobei das eine Feld ein String ist und das andere eine Ganzzahl.
SQLite erlaubt es aber, beliebige Typen zu speichern (ähnlich wie Python gibt es keine Typprüfung). Pandas nimmt aber die Definition heran. Und nicht alle Werte im Feld Ausgänge sind Ganzzahlen. Das kommt wohl daher, dass irgendwer auch die Tabellenüberschrift als Datensatz geschrieben hat. Deshalb mußt Du diese Felder erst einmal löschen.

Und Du willst jetzt gar keine Datenbank benutzen, sondern einfach nur alle Daten nach Pandas importieren. Dann schmeiß die Datenbank am besten weg und arbeite nur mit csv-Dateien. Denn so eine Datenbank zu misbrauchen, macht die Sache nur kompliziert.

Alternativ kannst Du ja mal anfangen, hier zu erzählen, wie die Daten wirklich aussehen und was Du wirklich damit machen willst, dann kann man Dir viel besser bei Lösungen helfen.
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Okay vielen Dank.

Die Daten sehen so aus, wie ich es dargelegt habe. Anstatt "Maschine A" steht da halt die tatsächliche Typenbezeichnung. Dann folgen Spalten die die Maschine beschreiben, da steht zum Beispiel ein "e" für einstufig drin und der Großteil der Spalten besteht aus technischen Daten, mit denen man überprüfen kann ob die Maschine für die gewünschten Anforderungen genutzt werden kann.

Also das Programm, dass da entstanden ist, erwartet vom Benutzer dass eine gewünschte Maschine gewählt wird. Anschließend gibt der Benutzer seine Anforderungen ein und das Programm berechnet damit und mit den Daten der Datenbank wirkende Kräfte, Drücke, Temperaturen, Geschwindigkeiten. Dann kann man erkennen, ob die Maschine für die Anforderung verwendet werden kann oder ob man die Maschine oder die Anforderungen anpassen muss.

Ob ich den Code veröffentlichen darf weis ich nicht, ob sich da jemand von euch durcharbeiten will glaube ich aber auch nicht denn es sind 8 Dateien:
1. Datei : ca 1300 Zeilen
2. Datei: ca 150 Zeilen
3. Datei: ca. 1700 Zeilen
4. Datei: ca. 1300 Zeilen
5. Datei: ca. 600 Zeilen
6. Datei: ca. 100 Zeilen
7. Datei: ca. 1700 Zeilen
8. Datei: ca 500 Zeilen

Aus denen zwei Gründen muss ich dieses mal soviel Text um mein Problem schreiben und kann es nicht sauber in Code darstellen. Meiner Meinung nach sind selbst Codeausschnitte aktuell nichtssagen, da das so chaotisch ist.

Wenn es hilft, dann könnte ich allerdings mal ein kleines Beispielprogramm schreiben, in dem die Art und Weise, wie das Programm arbeiten soll illustriert wird?

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Auf dieses Problem will ich aufmerksam machen. Wenn Du nicht in klaren Worten beschreiben kannst, was gemacht werden soll, ist es auch schwierig sauberen Code zu schreiben.
Du hast also viele Daten zu einer Maschine und möchtest für diese EINE Maschine verschiedene Dinge ausrechnen.
Dann hilft Dir pandas ja nichts, weil das dann gut funktioniert wenn viele Datensätze (Maschinen) miteinander verarbeitet werden sollen.

Das Programm-Design sehe ich daher so: es gibt eine Klasse Maschine, die mit vielen Daten gefüttert wird (aus welcher Quelle ersteinmal unwichtig), und die dann die nötigen Berechnungen über Methoden durchführen kann.
Wenn es sehr viele Werte sind, dann wäre es günstig, wenn man nur Untereinheiten definieren könnte (also alles was zu Kräfte gehört in eine eigene Klasse, alles was zu Drücken gehört in eine andere, usw.). Ob das so funktioniert, kannst nur Du beurteilen, wenn es möglich ist, dann aber die starke Empfehlung, das auch zu tun.

Unabhängig davon mußt Du nur noch eine Funktion schreiben, die einen Datensatz aus der Datenbank liest und so ein Maschinen-Klasse insanziieren.
Wenn es möglich ist, die Daten zu unterteilen, dann ist das auch für die Datenbank in mehrere Tabellen
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Ja genau, mich interessieren immer nur die Daten einer Maschine.

Vielleicht habe ich das falsch verstanden, ich dachte pandas soll ich nur nutzen um die Datenbank zu "retten" bzw. ordentlich aufzubauen. Aber das stelle ich jetzt vorerst mal hinten an.
Dann werde ich jetzt mal ein Grundgerüst schreiben, das so aufgebaut ist wie du es beschrieben hast. Dann habe ich auch Code den ich hier zeigen kann und wenn die Grundstruktur passt, dann packe ich die vorhandenen Rechnungen rein.

Vielen Dank für die Hilfe. Ich melde mich dann mit etwas Code zurück.

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

ich glaube dass das mit mehr Klassen Sinn machen könnte. Gerade überlege ich wie ich die Grundstruktur aufbauen könnte. War das von dir so gedacht?

Code: Alles auswählen

from contextlib import closing
from sqlite3 import connect


DATABASE = "daten.db"


class Machine:
    def __init__(self, machine_type, inlet_gas_temperature):
        self.thermodynamic_properties = Thermodynamic(
            machine_type, inlet_gas_temperature
        )
        self.kinetics_properties = Kinetics(machine_type)


class Thermodynamic:
    def __init__(self, machine_type, inlet_gas_temperature):
        self.inlet_gas_temperature = inlet_gas_temperature
        self.volume_in = None
        self.volume_out = None
        self.outlet_gas_temperature = None
        self.read_database(machine_type)
        self.calculate_gas_temperature()

    def read_database(self, machine_type):
        with closing(connect(DATABASE)) as connection:
            with connection:
                with closing(connection.cursor()) as cursor:
                    cursor.execute(
                        "SELECT volume_in, volume_out FROM thermodynamic WHERE=?",
                        (machine_type,),
                    )
                    for volume_in, volume_out in cursor:
                        self.volume_in = volume_in
                        self.volume_out = volume_out

    def calculate_gas_temperature(self):
        self.outlet_gas_temperature = (
            self.volume_out * self.inlet_gas_temperature / self.volume_in
        )


class Kinetics:
    def __init__(self, machine_type):
        pass


def main():
    machine = Machine("Maschine A", 20)
    print(machine.thermodynamic_properties.outlet_gas_temperature)


if __name__ == "__main__":
    main()
Also nur von der Struktur/Programm-Design her? Wenn ich das ausbaue, trifft dass dann deine Beschreibung? Ich würde dann auch die Datenbank in entsprechende Tabellen aufteilen, falls es denn eine Datenbank-Datei bleibt. (Das sollten wir dann klären, wenn der Rest mal steht)

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Es ist ungewöhnlich, das ein Objekt so tief unten die Datenbank selbst öffnet. Stattdessen öffnet man eine Verbindung & reicht die im Zweifel rein. Ich würde die Objekte auch sofort mit ihren werten befüllen. Nicht erstmal dummy Werte anlegen. Dein problem hier erfordert nicht, dass du die Werte bei bedarf einliest.
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@Dennis89: Ergänzend zur Anmerkung von __deets__ würde ich auch das erstellen von einem Objekt nicht von einen Datenbankzugriff abhängig machen. Das bedeutet das man zum Beispiel für Tests keine Objekte erstellen kann, ohne eine Datenbank zu haben und die eventuell auch noch mit speziellen Testwerten füllen zu müssen.

Code: Alles auswählen

#!/usr/bin/env python3
import sqlite3
from contextlib import closing

DATABASE = "daten.db"


class Kinetics:
    def __init__(self, machine_type):
        self.machine_type = machine_type


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 thermodynamic"
                    " 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):
        return cls(
            Thermodynamic.from_database(
                connection, machine_type, inlet_gas_temperature
            ),
            Kinetics(machine_type),
        )


def main():
    with closing(
        sqlite3.connect(DATABASE, detect_types=sqlite3.PARSE_DECLTYPES)
    ) as connection:
        machine = Machine.from_database(connection, "Maschine A", 20)

    print(machine.thermodynamic_properties.outlet_gas_temperature)


if __name__ == "__main__":
    main()
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
Antworten