Projekterstellung mit GUI

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

Hallo,

ich habe hier jetzt noch mal meinen aktuellen Code.
Ich habe einen Teil von dem zuletzt geposteten übernommen und die o.g. Dinge angepasst.
Dazu habe ich eine Funktion eingebaut, wenn der User bereits für den heutigen Tag eine Registrierung hat bzw sich noch nicht vom alten Stand ausgelogt hat. Soll das Skript ihm das sagen und abbrechen.
Schöner wäre hier aber, das main() von vorne beginnt und dem User eine Meldung ausgibt.

Da wäre ich dann sicherlich bei

Code: Alles auswählen

while True 
oder?
Dann wäre mir noch lieb, wenn ich diese Auswahl angezeigt bekomme, wo der User die ID des Standes eingibt, das er nur die aktuell gezeigten eingeben kann, sonst Fehlermeldung und Aufforderung zur neueingabe

Master Frage! Wie baue ich das alles so um das es eine Grafische Oberfläche wird?

Code: Alles auswählen

#!/usr/bin/python3
import sys
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 = "XXXX"


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_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID) 
                        INNER JOIN (tbl_Stand INNER JOIN (tbl_Kaliber INNER JOIN tbl_Schiesstand ON tbl_Kaliber.ID = tbl_Schiesstand.KaliberID) 
                        ON tbl_Stand.ID = tbl_Schiesstand.StandID) ON tbl_Benutzer.ID = tbl_Schiesstand.UserID
                        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)
            main()
        else:
            pass



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, tbl_Stand.Standlang
            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.")
            
def main():
    os.system('clear')
    print("Schiessbuch")
    print()
    print("Bitte erfasse deine Daten!")
    print()
    db = connect()

    benutzer_anzeigen(db)
    user_id = input_int("Bitte deine User ID eingeben: ")
    
    benutzer_registriert(db, user_id)
    
    
    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)

if __name__ == '__main__':
    main()


matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

Hallo,

ich habe noch mal bissl was probiert, dazu versucht den Teil mit dem RFID einlesen einzubauen.

Habt ihr die Möglichkeit da mal drüber zusehen?

im main()

habe ich ein try / except KeyboardInterrupt eingebunden. in der Hoffnung das ich dann das Skript beenden kann.

Habe aber das Gefühl das es dass nicht so ist.

Die db schliesse ich nach dem letzten Insert. Gehört doch aber auch woanders hin?

Code: Alles auswählen

#!/usr/bin/python3
import sys
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"


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_Benutzer INNER JOIN tbl_Karten ON tbl_Benutzer.ID = tbl_Karten.UserID) 
                        INNER JOIN (tbl_Stand INNER JOIN (tbl_Kaliber INNER JOIN tbl_Schiesstand ON tbl_Kaliber.ID = tbl_Schiesstand.KaliberID) 
                        ON tbl_Stand.ID = tbl_Schiesstand.StandID) ON tbl_Benutzer.ID = tbl_Schiesstand.UserID
                        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)
            main()
        else:
            pass



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, tbl_Stand.Standlang
            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()
        cursor.close()
        db.close()
        
    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()
            readcontinue_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 kartenIUd_UserID(db):
    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():
    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, kartenIUd_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()
        

if __name__ == '__main__':
    main()


Vielen Dank und Liebe Grüße
Benutzeravatar
__blackjack__
User
Beiträge: 13007
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@matze1708: Wie kommt das Gefühl denn zustande? Vielleicht durch einen `NameError` weil `GPIO` nicht definiert ist? Und das `GPIO.cleanup()` möchte man nicht nur aufrufen wenn der Benutzer das Programm abgebrochen hat, sondern *immer* wenn das Programm beendet wird. Also beispielsweise auch wenn eine andere Ausnahme zum Programmende führt. Das gehört also in einen ``finally``-Block.

Das schliessen der Datenbankverbindung ist in der Funktion mit dem INSERT in der Tat schlecht aufgehoben. Warum sollte das ausgerechnet von der Funktion zum Anlegen eines Schützen eine Nebeneffekt sein? Die weiss doch gar nicht ob das Programm mit der Datenbank durch ist, oder die noch gebraucht wird. Das weiss die Hauptfunktion, wann sie am Ende ist. Und da kann man dann auch ``with`` und `closing()` verwenden.

`sys` wird importiert, aber nicht verwendet.

Den Terminalinhalt löschen, und das dann auch noch mit nicht portablen Systemprogrammen ist keine gute Idee.

`benutzer_registriert()` ruft rekursiv `main()` auf – das ist falsch. Und trägt vielleicht auch zu Deinem Eindruck bei das der Benutzer das Programm mit Strg+C nicht abbrechen kann, denn falls so ein rekursiver Aufruf existiert, führt ein Abbruch in `main()` ja dazu das der Rest des vorherigen Aufrufs von `main()` abgearbeitet wird. Die Funktion sollte einen Wahrheitswert zurückgeben der aussagt ob der Benutzer bereits registriert ist oder nicht, und der Aufrufer reagiert dann entsprechend darauf.

In der Funktion wird ein Wert per Zeichenkettenoperation in eine SQL-Anweisung hinein formatiert – das sollte man nie selbst machen. Machst Du an anderen Stellen ja auch nicht selbst, sondern überlässt das dem Datenbankmodul.

``else: pass`` ist überflüssig und kann weg.

In `kaliber_anzeigen()` steht `StandLang` im SELECT, wird im Code aber nicht verwendet.

Die vier Funktionen zwischen `schuetze_anlegen()` und `main()` werden nirgends verwendet.

`continue_reading` in `karte_erkennen()` wird nicht wirklich verwendet.

Das erste ``if`` auf `status` gibt zwar etwas aus, aber der Rest des Codes wird auch ausgeführt wenn der Status nicht in Ordnung war. Das ist sicher nicht so gewollt.

Der Rückgabewert der Funktion ist falsch weil es passieren kann das unterschiedliche RFID-Tags zum gleichen Wert führen. Man muss die Komponenten entweder eindeutig trennen, oder dafür sorgen das alle die gleiche Breite/Zahl von Zeichen haben.

`cardread()` ist überflüssig, das ist effektiv ja nur ein anderer Name für `karte_erkennen()`.

`kartenIUd_UserID()` ist sehr komisch. Angefangen beim Namen, weiter beim Versuch Zeichenkettenformatierung auf den *Rückgabewert* der `execute()`-Methode anzuwenden, und dann kommt ein ``return`` in einer Schleife das bedingungslos ausgeführt wird.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
Sirius3
User
Beiträge: 17712
Registriert: Sonntag 21. Oktober 2012, 17:20

In `benutzer_registriert` ist mir die SQL-Anweisung viel zu kompliziert. Die vielen verschachtelten JOINs versteht ja niemand.
Warum wird da tbl_Benutzer, tbl_Karten, tbl_Stand und tbl_Kaliber eingebunden, da die Tabellen doch gar nicht benutzt werden?
`tbl_Schiesstand.Ende` solltest Du auf NULL prüfen.
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

Sirius3 hat geschrieben: Dienstag 19. März 2019, 13:49 In `benutzer_registriert` ist mir die SQL-Anweisung viel zu kompliziert. Die vielen verschachtelten JOINs versteht ja niemand.
Warum wird da tbl_Benutzer, tbl_Karten, tbl_Stand und tbl_Kaliber eingebunden, da die Tabellen doch gar nicht benutzt werden?
`tbl_Schiesstand.Ende` solltest Du auf NULL prüfen.
Hast du recht, habe ich mal gekürzt. Ich will ja nur schauen ob die User ID die ich eingebe auch zur aktuellen Zeit da ist.

Code: Alles auswählen

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))

@blackJack

ich muss das grade alles noch mal durcharbeiten.
Benutzeravatar
__blackjack__
User
Beiträge: 13007
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@matze1708: Kann man also an einen Schiessstand nur einmal am Tag? Also nicht einmal vormittags und einmal nachmittags weil man gerne Mittagspause machen möchte?
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

__blackjack__ hat geschrieben: Dienstag 19. März 2019, 14:40 @matze1708: Kann man also an einen Schiessstand nur einmal am Tag? Also nicht einmal vormittags und einmal nachmittags weil man gerne Mittagspause machen möchte?
Man kann auch am Tag auf mehreren Ständen schießen, jedoch sollte sich der Schütze dann erst abmelden weil er ja physisch den Stand verlässt.

Ich habe hier Stand und Platz unterschieden. Stand wäre das Gebäude in dem die Schießplätze drin sind.
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

__blackjack__ hat geschrieben: Dienstag 19. März 2019, 13:03 @matze1708: Wie kommt das Gefühl denn zustande? Vielleicht durch einen `NameError` weil `GPIO` nicht definiert ist? Und das `GPIO.cleanup()` möchte man nicht nur aufrufen wenn der Benutzer das Programm abgebrochen hat, sondern *immer* wenn das Programm beendet wird. Also beispielsweise auch wenn eine andere Ausnahme zum Programmende führt. Das gehört also in einen ``finally``-Block.

Das schliessen der Datenbankverbindung ist in der Funktion mit dem INSERT in der Tat schlecht aufgehoben. Warum sollte das ausgerechnet von der Funktion zum Anlegen eines Schützen eine Nebeneffekt sein? Die weiss doch gar nicht ob das Programm mit der Datenbank durch ist, oder die noch gebraucht wird. Das weiss die Hauptfunktion, wann sie am Ende ist. Und da kann man dann auch ``with`` und `closing()` verwenden.

`sys` wird importiert, aber nicht verwendet.

Den Terminalinhalt löschen, und das dann auch noch mit nicht portablen Systemprogrammen ist keine gute Idee.

`benutzer_registriert()` ruft rekursiv `main()` auf – das ist falsch. Und trägt vielleicht auch zu Deinem Eindruck bei das der Benutzer das Programm mit Strg+C nicht abbrechen kann, denn falls so ein rekursiver Aufruf existiert, führt ein Abbruch in `main()` ja dazu das der Rest des vorherigen Aufrufs von `main()` abgearbeitet wird. Die Funktion sollte einen Wahrheitswert zurückgeben der aussagt ob der Benutzer bereits registriert ist oder nicht, und der Aufrufer reagiert dann entsprechend darauf.

In der Funktion wird ein Wert per Zeichenkettenoperation in eine SQL-Anweisung hinein formatiert – das sollte man nie selbst machen. Machst Du an anderen Stellen ja auch nicht selbst, sondern überlässt das dem Datenbankmodul.

``else: pass`` ist überflüssig und kann weg.

In `kaliber_anzeigen()` steht `StandLang` im SELECT, wird im Code aber nicht verwendet.

Die vier Funktionen zwischen `schuetze_anlegen()` und `main()` werden nirgends verwendet.

`continue_reading` in `karte_erkennen()` wird nicht wirklich verwendet.

Das erste ``if`` auf `status` gibt zwar etwas aus, aber der Rest des Codes wird auch ausgeführt wenn der Status nicht in Ordnung war. Das ist sicher nicht so gewollt.

Der Rückgabewert der Funktion ist falsch weil es passieren kann das unterschiedliche RFID-Tags zum gleichen Wert führen. Man muss die Komponenten entweder eindeutig trennen, oder dafür sorgen das alle die gleiche Breite/Zahl von Zeichen haben.

`cardread()` ist überflüssig, das ist effektiv ja nur ein anderer Name für `karte_erkennen()`.

`kartenIUd_UserID()` ist sehr komisch. Angefangen beim Namen, weiter beim Versuch Zeichenkettenformatierung auf den *Rückgabewert* der `execute()`-Methode anzuwenden, und dann kommt ein ``return`` in einer Schleife das bedingungslos ausgeführt wird.

Ich habe mal versucht den deine Hilfe etwas umzusetzten soweit wie ich es verstehe. Daraus ergibt sich die Frage, ob ich das nun so richtig verstanden habe.

Ich habe eine variable ablaufaktiv eingebaut.

Im Main habe ich dann ein while eingebaut. was schaut ob die variable True ist.

Aber was hindert dann den Ablauf daran das er stoppt? Bei Benutzer registriert ist jetzt zwar ein ablaufaktiv False drin.
Aber wie läuft der Code wieder von neuem los? Das wollte ich mir dem main() in dem if erreichen.

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)
            ablaufaktiv = 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 kartenIUd_UserID(db):
    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, kartenIUd_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()

Sirius3
User
Beiträge: 17712
Registriert: Sonntag 21. Oktober 2012, 17:20

Genau, falls das was Du Dir da gedacht hast funktionieren, hast Du jetzt das genaue Gegenteil von dem, was Du möchtest erreicht.
Du willst, dass die Funktion `benutzer_registriert` True oder False zurückgibt, und je nachdem führst Du die weiteren Anweisungen in main aus oder nicht.
Damit hast Du in main ein ablaufaktiv, das nicht gebraucht wird, in `karte_erkennen` hast Du immer noch ein `continue_reading` was nicht gebraucht wird, in Gpio (das nirgends aufgerufen wird) hast Du ein setwarnings, was nicht da sein sollte, cardread ist immer noch überflüssig.
Das `except KeyboardInterrupt` möchtest Du vielleicht außerhalb der while-Schleife haben.
`kartenIUd_UserID` (was nicht verwendet wird) hat ein `return` innerhalb einer for-Schleife, was irgendwie falsch aussieht. Das `cursor.execute` ist auch falsch, weil ein Parameter verwendet wird, der nicht angegeben ist und weil der Rückgabewert (None) mit dem %-Operator verknüpft wird. `kartenIUd_UserID` ist ein seltsamer Name, Funktionen sollten immer nach Tätigkeiten benannt werden.
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

Sirius3 hat geschrieben: Dienstag 19. März 2019, 15:28 Genau, falls das was Du Dir da gedacht hast funktionieren, hast Du jetzt das genaue Gegenteil von dem, was Du möchtest erreicht.
Du willst, dass die Funktion `benutzer_registriert` True oder False zurückgibt, und je nachdem führst Du die weiteren Anweisungen in main aus oder nicht.
Damit hast Du in main ein ablaufaktiv, das nicht gebraucht wird, in `karte_erkennen` hast Du immer noch ein `continue_reading` was nicht gebraucht wird, in Gpio (das nirgends aufgerufen wird) hast Du ein setwarnings, was nicht da sein sollte, cardread ist immer noch überflüssig.
Das `except KeyboardInterrupt` möchtest Du vielleicht außerhalb der while-Schleife haben.
`kartenIUd_UserID` (was nicht verwendet wird) hat ein `return` innerhalb einer for-Schleife, was irgendwie falsch aussieht. Das `cursor.execute` ist auch falsch, weil ein Parameter verwendet wird, der nicht angegeben ist und weil der Rückgabewert (None) mit dem %-Operator verknüpft wird. `kartenIUd_UserID` ist ein seltsamer Name, Funktionen sollten immer nach Tätigkeiten benannt werden.
Ich muss mich durch arbeiten.

Also muss es sowas sein:

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  (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
Aber wie starte ich neu?

Dieses continue_reading wird in der Funktion karte erkennen einmal auf True gesetzt und unten wenn die Karte erkannt ist und die Kartennummer geschrieben, wird der Wert auf False gesetz.
Da war aber ein Tippfehler im ersten Code.

Code: Alles auswählen

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])
            
Für was das Gpio ist habe ich noch nicht raus, das ist aus einem Code Schnipsel
cardread könnte nach meinem Verständnis ggf. weg, weil es ja nur den return Wert von karte_erkennen() zurückgibt. Doppelt gemoppelt

dieses kartenIUd habe ich umbennant

Code: Alles auswählen

def kartenid_Userid(db):
    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"]
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

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
User
Beiträge: 17712
Registriert: Sonntag 21. Oktober 2012, 17:20

`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
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

Ah,
Dann mache ich ein if in das main rein?
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

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()
Benutzeravatar
__blackjack__
User
Beiträge: 13007
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@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.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

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.
Benutzeravatar
__blackjack__
User
Beiträge: 13007
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@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.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
matze1708
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

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
User
Beiträge: 112
Registriert: Dienstag 12. März 2019, 11:49

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")
       
Benutzeravatar
__blackjack__
User
Beiträge: 13007
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@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.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
Antworten