Das deutsche Python-Forum

Hallo zusammen,

vorab einmal zu mir, ich heisse Stefan bin 35 Jahre alt und bin gerade am Anfang etwas Python zulernen. Also bin ein noob^^

Ich möchte gerne ein Programm schreiben, dass dem Anwender zunächst einmal durch eine Login Maske führt.

Hierfür habe ich mit dem QT Designer ein Mainwindow und ein Dialog Window gebaut.
Der Zugriff via Signals auf den Dialog funktioniert auch soweit. Allerdings habe ich nun ein kleines verständnis Problem.

Für den Zugriff auf den Dialog habe ich eine neue Klasse gebaut. Der mir via loadUi wiederrum das UI Baut.
Innerhalb des Dialoges gibt es eine ComboBox mit 4 Einträgen. Dort soll der User ein Element ausswählen.
Ebenso gibt es dort eine 3 QlineEdits (Ip Adresse, username, password).
Diese Felder sollen ausgefüllt werden.

Nun zum Problem, ich würde gerne mir im Terminal ausgeben lassen, was der User dort eingetragen hat in die QLineEdit.
Ich dachte via
.text() würde das gehen.

print(self.ip_addr.text())
print(self.user_name.text())
print(self.password.text())

Allerdings schreibt er mir den Output erstnachdem ich auf Connect gedrückt habe den Output auf den Terminal. Ich würde es gerne sofort sehen wenn dort was hineingeschrieben wird.

Wäre cool wenn ihr mir einen kleinen Denkanstoss geben könntet.

from PyQt5.QtWidgets import QMainWindow, QApplication, QPushButton, QTextEdit, QDialog, QLineEdit, QMenuBar, QComboBox
from PyQt5 import uic
from ciscoaxl import axl
import sys

class UI(QMainWindow):
def __init__(self):
super(UI, self).__init__()
self.ui = uic.loadUi("mainwindow.ui",self)
self.button = self.findChild(QPushButton, "login")
self.button.clicked.connect(self.PressButtonWrite)
#self.menuBar

def PressButtonWrite(self):
dia = Dialog()


class Dialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.ui = uic.loadUi("login.ui", self)
self.connectbtn = self.findChild(QPushButton, "connect")
self.cancelbtn = self.findChild(QPushButton, "quit")
self.ip_addr = self.findChild(QLineEdit,"cucm_ip")
self.CucmVersion = self.findChild(QComboBox,"cucm_version")
self.user_name = self.findChild(QLineEdit,"username")
self.password = self.findChild(QLineEdit,"pwd")
self.connectbtn.clicked.connect(self.connect_cucm)
self.cancelbtn.clicked.connect(self.cancelfkt)
#self.ip_addr.setText("IP Adresse")
self.exec_()
print(self.ip_addr.text())
print(self.user_name.text())
print(self.password.text())
##print(self.CucmVersion.currenText())


def connect_cucm(self):
self.close()

def cancelfkt(self):
self.close()


##def ip(self):


#u = Dialog()
#print (u)

def main():
app = QApplication(sys.argv)
w = UI()
w.show()
app.exec_()

if __name__ == '__main__':
main()



Viele Grüße,
Stefan

Bitte in Zukunft die Code-Tags benutzen, da sonst die Formatierung verloren geht. Das ist der </>-Knopf im vollstaendigen Editor.

Und du rufst self.exec_ auf. Danach laeuft der Code nicht weiter, sondern wartet auf die Beendigung des Dialogs. Erst dann kommen deine prints. Und "sofort sehen wenn dort was hineingeschrieben wird." ginge auch nur, wenn du ein entsprechendes Signal oder Event-Filter anlegst. Warum willst du das wissen? Nur zu deiner Information? Dann wuerde ich das nicht anders machen als jetzt. Oder geht es um Validierung oder so etwas? Dazu gibt es vordefinierte Funktionen, die man benutzen sollte.

Hallo,

erstmal vielen Dank für die Antwort.

Grundlegend geht es mir darum natürlich Python zulernen. Generell verstehe ich noch nicht ganz, wie ich Eingabewerte Klassenübergreifend übergebe.
Ebenso bin ich mir nicht sicher ob der Aufruf des Dialoges der richtige Weg über den Methodenaufruf.
Denn ich würde auch gerne meine UIs die ich mit den QDesigner entsprechend via loadUI lade. Allerdings finde ich da keine "kleinen Beispiele im Inet und bin mir daher irgendwie unsicher.

Ein weitere Thema was ich gerne einfach verstehen würde.
Wenn ich zum Beispiel in der Klasse Dialog() folgenden Text mitgebe.

#self.ip_addr.setText("IP Adresse")

Dann steht Qline Feld intial "IP Adresse" soweit so gut. Nun lösche ich das Textfeld IpAdresse und beende den Dialog wieder und rufe ihn danach wieder auf. Dann steht wieder "Ip Adresse". Ich hätte gerne den Wert übernommen, was der User eingegeben hat.

Du willst also eine Art Settings haben? Dafuer gibt es schon QSettings, und wenn du das benutzt, dann sollte das funktionieren.

Grundsaetzlich gilt aber: ein neues Objekt ist ein neues Objekt. Nur weil du mal ein anderes Objekt gleichen Typs erzeugt hattest, uebermitteln sich ja keine Inhalte. Wenn du und die Liebe deines Lebens das gleiche Automodell fahren, das ihr nacheinander gekauft hat, dann finden sich deine dreckigen Sportsachen von letztem Abend ja auch nicht im anderen Auto wieder.

Um solche GUIs zu schreiben geht es in meinen Augen (und denen der erfahreneren User hier) nicht ohne eine wirklich solides Verstaendis von objektorienterter Programmierung. Hast du das Thema drauf?

Hallo,

scheinbar hast du meinen initialen Beitrag zumindest vom geschriebenen nicht wirklich gelesen.
Nein ich bin neu im programmier Umfeld und würde gerne lernen. -> Hobby.

Aus deinem Beitrag ist nicht ersichtlich, welche Kenntnisse du bereits hast oder nicht. Anfangen ist ein weites Feld.

Das eine Frage danach, ob OO dazu gehoert, dann gleich zur Unterstellung fuehrt, ich haette das nicht gelesen - tja. Dann spare ich mir weitere Fragen. Viel Erfolg mit dem neuen Hobby.

Viel spass beim mimimi .... Und vielen Dank!

@ylly: Ein guter Startpunkt ist das offizielle Tutorial in der Python Dokumentation. Aus eigener Erfahrung: Stell alles, was mit GUI zu tun zurück, bist du die Python-Grundlagen, Objektorientierte Programmierung und die Ereignisbasierung von grafischen Oberfläschen verstanden hast.

Danke für den tipp.

Ich wollte eigentlich nur Wissen ob der methoden- bzw. klassen- übergreifende Zugriff auf die LoadUI funktion sinnvoll ist oder nicht.

Genauso hätte ich gerne gewusst ob die variablen übergabe aus einer Methode zu einem Modul funktioniert oder nicht. Da bin ich mir gerade unsicher. Aber wahrscheinlich funktioniert das.

@ylly: Ich verstehe deine Fragen nicht.

Was ist ein "*-übergreifender Zugriff auf die LoadUI"? loadUI ist eine Funktion, die man aufruft, um eine Oberfläche zu laden, die man vorher im Designer erstellt hat. Die lädt man in eine Klasse und entsprechend kann man dort ebenso zugreifen wie auf alle anderen Klassen auch. Eben das ist Objektorientierte Programmierung - und es wurde dir bereits nahe gelegt, dir das anzuschauen, bevor du versuchst grafische Oberflächen zu verwenden. Jede nichttriviale Anwendung einer Benutzeroberfläche benötigt OOP.

Was ist denn eine "variable Übergabe aus ener Methode in ein Modul"? Ein Modul ist eine Python-Datei. Man übergibt Funktionen Parameter und auf Modulebene sollten nur Konstanten definiert sein - und die heißen Konstanten, weil sie konstant sein sollen - falls du das meinst.

Ich wiederhole das Mantra: Lerne die Grundlagen - verstehe OOP.