Projekterstellung mit GUI

[matze1708]

Nochmal in komplett

Code: Alles auswählen

#!/usr/bin/python3

import os
import RPi.GPIO as gpio
import MFRC522
import MySQLdb
import MySQLdb.cursors
from contextlib import closing
import time

DB_HOST = "XXX"
DB_USER = "XXX"
DB_PASSWORD = "XXX"

ablaufaktiv = True

def connect():
    return MySQLdb.connect(host=DB_HOST, port=3307,
        user=DB_USER , passwd=DB_PASSWORD, db="Schiessbuch",
        cursorclass=MySQLdb.cursors.DictCursor)

def benutzer_anzeigen(db):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""Select tbl_Benutzer.ID, tbl_Benutzer.UName, tbl_Benutzer.UVorname
            FROM tbl_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID""")
        for row in cursor:
           print( row["ID"], row["UName"], row["UVorname"])


def benutzer_registriert(db, user_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Schiesstand.UserID
                        FROM tbl_Schiesstand
                        Where  tbl_Schiesstand.UserID = %d AND  (DATE(tbl_Schiesstand.Beginn) = CURDATE() AND NOT DATE(tbl_Schiesstand.Ende) = CURDATE())""" % (user_id))
        
        if cursor.fetchone():
            print("Du bist bereits registriert")
            time.sleep(5)
            return False
            
        


def stand_anzeigen(db):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("Select ID, StandLang From tbl_Stand") 
        for row in cursor:
            print( row["ID"], row["StandLang"])

def kaliber_anzeigen(db, stand_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""Select tbl_Kaliber.ID, tbl_Kaliber.KaliberLang
            From tbl_Stand INNER JOIN tbl_Kaliber ON tbl_Stand.ID = tbl_Kaliber.StandID
            Where tbl_Stand.ID = %s""", (stand_id,))
        for row in cursor:
            print( row["ID"], row["KaliberLang"])



def schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht):
    print()
    with closing(db.cursor()) as cursor:
        sql_query = """INSERT INTO `tbl_Schiesstand` (`UserID`, `StandID`, `Platz`, `KaliberID`, `Beginn`, `Standaufsicht`) VALUES (%s, %s, %s, %s, NOW(), %s)"""
        data = (user_id, stand_id, platz, kaliber_id, standaufsicht) 
        cursor.execute(sql_query, data) 
        db.commit()
        
        
    print("Du wurdest erfolgreich registriert") 

def input_int(prompt):
    while True:
        try:
            print()
            return int(input(prompt))
        except ValueError:
            print("Fehler: Keine Zahl eingegeben.")
            
#Funktion für die RFID Karten zulesen

def karte_erkennen():
    continue_reading = True
    MIFAREReader = MFRC522.Reader(0, 0, 22)

    # This loop keeps checking for chips. If one is near it will get the UID and authenticate
    while continue_reading:
        # Scan for cards
        (status, TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)

        # If a card is found
        if status == MIFAREReader.MI_OK:
            print("Card detected")

        # Get the UID of the card
        (status, uid) = MIFAREReader.MFRC522_Anticoll()

        # If we have the UID, continue
        if status == MIFAREReader.MI_OK:
            # Print UID
            print("Card read UID: " + str(uid[0]) + "," + str(uid[1]) + "," + str(uid[2]) + "," + str(uid[3])+ "," + str(uid[4]))
            MIFAREReader.AntennaOff()
            continue_reading=False
            return str(uid[0])+str(uid[1])+str(uid[2])+str(uid[3])+str(uid[4])


def Gpio():
    # Show no warnings
    GPIO.setwarnings(False)
    # Use GPIO pin numbers
    GPIO.setmode(GPIO.BOARD)        

def cardread():
    cardId=karte_erkennen()
    return cardId


def kartenid_Userid(db, cardID):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Benutzer.ID
                            FROM tbl_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID
                            WHERE tbl_Karten.KartenNummer=%s """) %(cardID)
        for row in cursor:
            print( row["ID"])
            return row["ID"]



def main():
   while ablaufaktiv:
        try:
            os.system('clear')
            print("Schiessbuch")
            print()
            print("Bitte erfasse deine Daten!")
            #print()
            #print("Bitte Scanne deine Karte!")
            db = connect()


            #cardread()

            benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
            
            benutzer_registriert(db, user_id)
           # benutzer_registriert(db, kartenid_Userid)
            
            stand_anzeigen(db)
            stand_id = input_int("Bitte Stand eingeben: ")
            
            kaliber_anzeigen(db, stand_id)
            kaliber_id = input_int("Bitte Kaliber eingeben: ")
            
            platz = input_int("Auf welchem Stand schiesst du?: ")
            
            standaufsicht = 0
            schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht)
        
        except KeyboardInterrupt:
            print("Abbruch")
            #GPIO.cleanup()
            db.connect(close)
        finally: 
           # GPIO.cleanup()
            db.connect(close)
        
        

if __name__ == '__main__':
    main()

EDIT:
Bei der kartenid_Userid mag ich eigentlich nur die UserId aus der Tabelle tbl_Benutzer haben. Damit ich diesen Wert weiter in der tbl_Schiesstand eintragen kann.

[Sirius3]

`benutzer_registriert` liefert False, falls der Benutzer registriert ist, sonst None. Als Leser des Funktionsnamens würde ich etwas anderes erwarten.
In `main` mußt Du doch irgendwie darauf reagieren, ob der Benutzer bereits registriert ist, oder nicht.

[matze1708]

Ah,
Dann mache ich ein if in das main rein?

[matze1708]

Ich muss da nochmal einsteigen.

im Prinzip müsste der part

Code: Alles auswählen

benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
            
            benutzer_registriert(db, user_id)

Ja nur solange wiederholt werden, wenn benutzer_registriert nicht false ist oder?

Aber wie stelle ich das in dem main part an?

Code: Alles auswählen

def main():
   while ablaufaktiv:
        try:
            os.system('clear')
            print("Schiessbuch")
            print()
            print("Bitte erfasse deine Daten!")
            #print()
            #print("Bitte Scanne deine Karte!")
            db = connect()


            #cardread()

            benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
            
            benutzer_registriert(db, user_id)
           # benutzer_registriert(db, kartenid_Userid)
            
            stand_anzeigen(db)
            stand_id = input_int("Bitte Stand eingeben: ")
            
            kaliber_anzeigen(db, stand_id)
            kaliber_id = input_int("Bitte Kaliber eingeben: ")
            
            platz = input_int("Auf welchem Stand schiesst du?: ")
            
            standaufsicht = 0
            schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht)
        
        except KeyboardInterrupt:
            print("Abbruch")
            #GPIO.cleanup()
            db.connect(close)
        finally: 
           # GPIO.cleanup()
            db.connect(close)
        
        

if __name__ == '__main__':
    main()

[__blackjack__]

@matze1708: Um etwas zu wiederholen gibt es Schleifen. Der Teil der wiederholt werden soll, muss in eine Schleife die so lange ausgeführt wird, bis die Abbruchbedingung eintritt.

Da Python keine eigene Syntax für eine nachprüfende Schleife besitzt, nimmt man dafür eine ”Endlosschleife” (``while True:``) die abgebrochen wird, sobald man feststellt, das die Abbruchbedingung erfüllt ist (``if`` und ``break``).

``db.connect(close)``? Weder hat `db` eine `connect()`-Methode, noch wäre `close` irgendwo definiert.

Wenn `GPIO.cleanup()` und `db.close()` sowohl im ``except``-Zweig, als auch im ``finally``-Zweig stehen, werden die beiden Anweisungen im Falle eines Abbruchs per Strg+C zweimal ausgeführt. Das gehört also nur in den ``finally``-Zweig. Wäre ja auch blöd wenn man alle Aufräumarbeiten in jeden dieser Zweige schreiben müsste.

Das `db.close()` könnte man wie schon gesagt auch mit einem ``with`` und `closing()` erledigen.

[matze1708]

Das `db.close()` könnte man wie schon gesagt auch mit einem ``with`` und `closing()` erledigen.

das wiederrum habe ich dann offensichtlich nicht verstanden. Habe ja in den ganzen Funktionen dieses closing drin. Heißt das dann, dass ich die die db Connection gar nicht mehr schliessen muss?

Ich überlege gerade wie ich diese Schleife und die passende Kondition dazu baue.....


Mit dem
gut das cleanup nehme ich aus dem except raus. da es im finally abgearbeitet wird.

[__blackjack__]

@matze1708: In den Funktionen erstellst und schliesst Du Cursor-Objekte und verwendest zum deterministischen schliessen `closing()` und ``with``. In der Hauptfunktion erstellst und schliesst Du die Verbindung zur Datenbank. Dort verwendest Du zum deterministischen schliessen ``finally`` und einen expliziten Aufruf der `close()`-Methode auf der Verbindung. Das kann man natürlich auch machen, musste man sogar bevor es die ``with``-Anweisung gab. Mit ``with`` wird aber die Lebensdauer der Verbindung deutlicher, weil man sehr leicht sehen kann wo der Anfang und wo das Ende ist, weil es sich um einen eingerückten Block extra für diesen Zweck handelt.

[matze1708]

Danke für die Hilfe,

ich habe den MySQldb.connection.close in die def connect unter ein finally: gepackt.
Unten in der main() bin ich noch nicht Glücklich. Scheinbar muss in dem finally block der main() was drin stehen, sonst spinnt die rum.

Für die Prüfung ob der User bereits einen Eintrag hat, habe ich grade noch keine Lösung.


Auch der except KeyBoardInterrrupt ist noch am falschen Ort....

Code: Alles auswählen

#!/usr/bin/python3

import os
import RPi.GPIO as gpio
import MFRC522
import MySQLdb
import MySQLdb.cursors
from contextlib import closing
import time

DB_HOST = "XXX"
DB_USER = "XX"
DB_PASSWORD = "XXX"

ablaufaktiv = True

def connect():
        try:
            return MySQLdb.connect(host=DB_HOST, port=3307,
            user=DB_USER , passwd=DB_PASSWORD, db="Schiessbuch",
            cursorclass=MySQLdb.cursors.DictCursor)
        finally:
            MySQLdb.connection.close

def benutzer_anzeigen(db):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""Select tbl_Benutzer.ID, tbl_Benutzer.UName, tbl_Benutzer.UVorname
            FROM tbl_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID""")
        for row in cursor:
           print( row["ID"], row["UName"], row["UVorname"])


def benutzer_registriert(db, user_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Schiesstand.UserID
                        FROM tbl_Schiesstand
                        Where  tbl_Schiesstand.UserID = %d AND  (DATE(tbl_Schiesstand.Beginn) = CURDATE() AND NOT DATE(tbl_Schiesstand.Ende) = CURDATE())""" % (user_id))
        
        if cursor.fetchone():
            print("Du bist bereits registriert")
            time.sleep(5)
            return False
        else: 
            return True
            
        


def stand_anzeigen(db):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("Select ID, StandLang From tbl_Stand") 
        for row in cursor:
            print( row["ID"], row["StandLang"])



def kaliber_anzeigen(db, stand_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""Select tbl_Kaliber.ID, tbl_Kaliber.KaliberLang
            From tbl_Stand INNER JOIN tbl_Kaliber ON tbl_Stand.ID = tbl_Kaliber.StandID
            Where tbl_Stand.ID = %s""", (stand_id,))
        for row in cursor:
            print( row["ID"], row["KaliberLang"])



def schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht):
    print()
    with closing(db.cursor()) as cursor:
        sql_query = """INSERT INTO `tbl_Schiesstand` (`UserID`, `StandID`, `Platz`, `KaliberID`, `Beginn`, `Standaufsicht`) VALUES (%s, %s, %s, %s, NOW(), %s)"""
        data = (user_id, stand_id, platz, kaliber_id, standaufsicht) 
        cursor.execute(sql_query, data) 
        db.commit()
        
        
    print("Du wurdest erfolgreich registriert") 
    time.sleep(5)
    
    

def input_int(prompt):
    while True:
        try:
            print()
            return int(input(prompt))
        except ValueError:
            print("Fehler: Keine Zahl eingegeben.")
            
#Funktion für die RFID Karten zulesen

def karte_erkennen():
    continue_reading = True
    MIFAREReader = MFRC522.Reader(0, 0, 22)

    # This loop keeps checking for chips. If one is near it will get the UID and authenticate
    while continue_reading:
        # Scan for cards
        (status, TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)

        # If a card is found
        if status == MIFAREReader.MI_OK:
            print("Card detected")

        # Get the UID of the card
        (status, uid) = MIFAREReader.MFRC522_Anticoll()

        # If we have the UID, continue
        if status == MIFAREReader.MI_OK:
            # Print UID
            print("Card read UID: " + str(uid[0]) + "," + str(uid[1]) + "," + str(uid[2]) + "," + str(uid[3])+ "," + str(uid[4]))
            MIFAREReader.AntennaOff()
            continue_reading=False
            return str(uid[0])+str(uid[1])+str(uid[2])+str(uid[3])+str(uid[4])


def Gpio():
    # Show no warnings
    GPIO.setwarnings(False)
    # Use GPIO pin numbers
    GPIO.setmode(GPIO.BOARD)        

def cardread():
    cardId=karte_erkennen()
    return cardId


def kartenid_Userid(db, cardID):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Benutzer.ID
                            FROM tbl_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID
                            WHERE tbl_Karten.KartenNummer=%s """) %(cardID)
        for row in cursor:
            print( row["ID"])
            return row["ID"]



def main():
   while ablaufaktiv:
        try:
            os.system('clear')
            print("Schiessbuch")
            print()
            print("Bitte erfasse deine Daten!")
            #print()
            #print("Bitte Scanne deine Karte!")
            db = connect()


            #cardread()
            
            
            benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
                
            benutzer_registriert(db, user_id)
            #benutzer_registriert(db, kartenid_Userid)
            
            stand_anzeigen(db)
            stand_id = input_int("Bitte Stand eingeben: ")
            
            kaliber_anzeigen(db, stand_id)
            kaliber_id = input_int("Bitte Kaliber eingeben: ")
            
            platz = input_int("Auf welchem Stand schiesst du?: ")
            
            standaufsicht = 0
            schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht)
        
        except KeyboardInterrupt:
            print("Abbruch")
            
        finally: 
            print("Ende")
       
        
        

if __name__ == '__main__':
    main()

Den Keyboard Interput habe ich mal so zusammen kopiert:

Code: Alles auswählen

def keyboardInterruptHandler(signal, frame):
    print("Abbruch durch Benutzer (ID: {}) wurde gedrückt.".format(signal))
    exit(0)

signal.signal(signal.SIGINT, keyboardInterruptHandler)

[matze1708]

Habe eine Idee:

Code: Alles auswählen

ef main():
   while ablaufaktiv:
        try:
            os.system('clear')
            print("Schiessbuch")
            print()
            print("Bitte erfasse deine Daten!")
            #print()
            #print("Bitte Scanne deine Karte!")
            db = connect()


            #cardread()
            
            
            benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
                
          if not benutzer_registriert(db, user_id):
            #benutzer_registriert(db, kartenid_Userid)
            
                continue
            
            stand_anzeigen(db)
            stand_id = input_int("Bitte Stand eingeben: ")
            
            kaliber_anzeigen(db, stand_id)
            kaliber_id = input_int("Bitte Kaliber eingeben: ")
            
            platz = input_int("Auf welchem Stand schiesst du?: ")
            
            standaufsicht = 0
            schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht)
        
        except KeyboardInterrupt:
            print("Abbruch")
            
        finally: 
            print("Ende")
       

[__blackjack__]

@matze1708: Jetzt schliesst Du die Verbindung gar nicht mehr. In der `connect()`-Funktion machst Du im ``finally``-Zweig effektiv nichts. Du hast da einen Ausdruck der zur ungebundenen Methode `close` von `mysql.connection` ausgewertet wird, was keinen Sinn macht.

Und natürlich muss in jedem Block etwas stehen, weil die Python-Grammatik das verlangt. Aber man muss ja keinen ``finally``-Zweig hinschreiben wenn man den nicht braucht.

Die Ausgabe „Du bist bereits registriert“ und die 5-sekündige Pause gehören nicht in die Funktion die testet ob der Benutzer angemeldet ist oder nicht. Das ist Benutzerinteraktion, die von diesem Test unabhängig ist.

Du formatierst dort immer noch einen Wert in die SQL-Abfrage als Zeichenkette hinein.

Die Bedingung zu `Beginn` und `Ende` in der Datenbank sieht unsinnig bis falsch aus. Wenn der Benutzer immer nur einmal irgendwo angemeldet sein darf, also nur eine offene Endzeit existieren darf, dann ist die Bedingung einfach nur ob `Ende` den Wert NULL hat.

[matze1708]

@matze1708: Jetzt schliesst Du die Verbindung gar nicht mehr. In der `connect()`-Funktion machst Du im ``finally``-Zweig effektiv nichts. Du hast da einen Ausdruck der zur ungebundenen Methode `close` von `mysql.connection` ausgewertet wird, was keinen Sinn macht.

Und natürlich muss in jedem Block etwas stehen, weil die Python-Grammatik das verlangt. Aber man muss ja keinen ``finally``-Zweig hinschreiben wenn man den nicht braucht.

Die Ausgabe „Du bist bereits registriert“ und die 5-sekündige Pause gehören nicht in die Funktion die testet ob der Benutzer angemeldet ist oder nicht. Das ist Benutzerinteraktion, die von diesem Test unabhängig ist.

Du formatierst dort immer noch einen Wert in die SQL-Abfrage als Zeichenkette hinein.

Die Bedingung zu `Beginn` und `Ende` in der Datenbank sieht unsinnig bis falsch aus. Wenn der Benutzer immer nur einmal irgendwo angemeldet sein darf, also nur eine offene Endzeit existieren darf, dann ist die Bedingung einfach nur ob `Ende` den Wert NULL hat.

Ich habe bereits den Print Befehl und das sleep runter in die Main in das if not gezogen.

Wie muss das in dem connect finally aussehen? Dachte ich habe das so geschlossen.... mhmm


Die Formatierung schaue ich mir nochmal an. War da auch der Meinung das es passt. Weil es auch geht.
In der Spalte Ende steht immer ein 0000-00-00 00:00:00 wert von DB Modell her drine. Kein NULL. Könnte ich aber DB seitig auch anpassen.
Dann müsste ich schauen ob der User aktuell KEIN Ende Wert hat. Aber Heute gestartet ist ?! Eigentlich reicht Ende ist leer oder 0 oder NULL.

Code: Alles auswählen

def main():
   while ablaufaktiv:
        try:
            os.system('clear')
            print("Schiessbuch")
            print()
            print("Bitte erfasse deine Daten!")
            #print()
            #print("Bitte Scanne deine Karte!")
            db = connect()


            #cardread()
            
            
            benutzer_anzeigen(db)
            user_id = input_int("Bitte deine User ID eingeben: ")
                
            if not benutzer_registriert(db, user_id):
            #benutzer_registriert(db, kartenid_Userid)
                print("Du bist bereits registriert")
                time.sleep(5)
                continue
            
            stand_anzeigen(db)
            stand_id = input_int("Bitte Stand eingeben: ")
            
            kaliber_anzeigen(db, stand_id)
            kaliber_id = input_int("Bitte Kaliber eingeben: ")
            
            platz = input_int("Auf welchem Stand schiesst du?: ")
            
            standaufsicht = 0
            schuetze_anlegen(db, user_id, stand_id, platz, kaliber_id, standaufsicht)
        
        except KeyboardInterrupt:
            print("Abbruch")
            
        finally: 
            print("Ende")

[matze1708]

Das prüfen auf NULL ist geändert und auch der Standardwert in der DB Tabelle.

Aber am SQL String bin ich noch dran. da weiss ich grade nicht was falsch ist.

Code: Alles auswählen

def benutzer_registriert(db, user_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Schiesstand.UserID
                        FROM tbl_Schiesstand
                        Where  tbl_Schiesstand.UserID = %d AND  tbl_Schiesstand.Ende IS NULL""" % (user_id))

[__blackjack__]

@matze1708: Du benutzt Zeichenkettenformatierung mit dem ``%``-Operator. Bei den anderen `execute()`-Aufrufen machst Du das doch richtig.

[matze1708]

Bei dem connect kann ich es mir nur so aktuell denken

Code: Alles auswählen

def connect():
        try:
            conn = MySQLdb.connect(host=DB_HOST, port=3307,
            user=DB_USER , passwd=DB_PASSWORD, db="Schiessbuch",
            cursorclass=MySQLdb.cursors.DictCursor)
            return conn
        finally:
            conn.close

bei den anderen execute habe ich ein %s drin stehen.

das %d ist doch für Zahlen. Oder immer noch Holzweg?

[matze1708]

Ach eben!!!

Du meintest das % hinter dem String? vor (Card_ID) jetzt habe ich das gesehen.

Code: Alles auswählen

def benutzer_registriert(db, user_id):
    print()
    with closing(db.cursor()) as cursor:
        cursor.execute("""SELECT tbl_Schiesstand.UserID
                        FROM tbl_Schiesstand
                        Where  tbl_Schiesstand.UserID = %s AND  tbl_Schiesstand.Ende IS NULL""", (user_id,))

[matze1708]

Ich frage mich ja immer noch, wie ich das ganze dann auf eine Grafische Oberfläche bekomme....

Wenn es mal einigermaßen geht.....

[__blackjack__]

@matze1708: Auch hier hat der Ausdruck im ``finally``-Zweig keinen Effekt. Das gehört da ja auch überhaupt nicht hin. Das ist ja die Funktion in der die Verbindung aufgebaut wird. Die dort in einem ``finally`` gleich wieder zu schliessen wäre unsinnig.

Für eine grafische Oberfläche ist bei einigen Funktionen die Trennung zwischen Programmlogik und Benutzerinteraktion noch nicht sauber genug. `benutzer_anzeigen()` beispielsweise hat ja die Abfrage und die Ausgabe der Daten in einer Funktion. Die Abfrage wäre auch für eine GUI die gleiche, aber der Teil zum Anzeigen läuft dort anders.

[matze1708]

@matze1708: Auch hier hat der Ausdruck im ``finally``-Zweig keinen Effekt. Das gehört da ja auch überhaupt nicht hin. Das ist ja die Funktion in der die Verbindung aufgebaut wird. Die dort in einem ``finally`` gleich wieder zu schliessen wäre unsinnig.

Wo muss das dann stehen?

Für eine grafische Oberfläche ist bei einigen Funktionen die Trennung zwischen Programmlogik und Benutzerinteraktion noch nicht sauber genug. `benutzer_anzeigen()` beispielsweise hat ja die Abfrage und die Ausgabe der Daten in einer Funktion. Die Abfrage wäre auch für eine GUI die gleiche, aber der Teil zum Anzeigen läuft dort anders.

Wie muss diese Funktion dann getrennt sein? Quasi das Ergbniss der Abfrage an eine andere Funktion übergeben und von dieser dann die Anzeige gestalten?

[matze1708]

Was für mich auch noch interessant wäre, ich würde gerne den User Input soweit einschränken das er nur die Wahl hat zwischen den angezeigten Möglichkeiten.
Bsp Kaliber... dann soll er nur die Auswahl haben, von dem was gezeigt wird.
Oder bei Platz. da müsste ich vor selektireren welche Plätze auf dem aktuellen Stand belegt sind.
auf der GUI würde ich dafür Buttons nehmen und die dann ausblenden oder sperren die belegt sind.

Lässt sich das jetzt hier schon mit den vorhandnen eingaben machen?
Die Stand Rückgabe müsste ich sicherlich als Tupel machen?! in der Funktion dann Return XXX

[__blackjack__]

@matze1708: Das schliessen der Datenbankverbindung muss da stehen wo Du weisst das Du sie nicht mehr brauchst. Und wenn man ``with`` verwendet, üblicherweise in der Funktion/Methode in der die Verbindung auch hergestellt wird. Du hattest es ja dort bereits in einem ``finally`` stehen.

Die Abfrage der Benutzerdaten von der Datenbank wäre eine eigene Funktion. Denn das ist ja der Teil der bei Terminal und GUI gleich bleibt. Die Anzeige selbst ist unterschiedlich. Beim Terminal verwendet man ``print()`` dafür. Bei einer GUI könnte man die Daten beispielsweise in einem Drop-Down-Menü zur Auswahl zur Verfügung stellen.

Wenn Du die Benutzereingabe auf gültige Werte einschränken möchtest, müsstest Du Funktionen bereit stellen die Dir die Möglichkeiten von der Datenbank abfragen und entsprechen die Eingabe überprüfen. Du machst das ja jetzt bereits zum Teil, nämlich ob die Eingabe eine Zahl ist. Da muss dann noch dazu kommen ob es eine Zahl aus einer Menge von vorgegebenen Zahlen ist. Und die bekommst Du ja mit der Abfrage der Kaliber.

Bei den Rückgaben von den Funktionen kannst Du Listen mit den Datenbankergebnissen zurück geben, oder Du fängst an hier zwischen der Datenhaltung und Objekten im Programm zu trennen und die Ergebnisse ”umzupacken”, beispielsweise in `collections.namedtuple` oder Klassen, damit das alles mehr nach Python aussieht und man nicht die Wörterbücher mit den unpytonischen Schlüsselnamen von der Datenbank hat. Alternativ könnte man die Spaltennamen in der Datenbank an die Python-Konventionen anpassen und die Ergebnisse in `addict.Dict`-Objekte verpacken. Oder sich mit dem SQLAlchemy-ORM beschäftigen.