Portierung eines Beispielprogramms von Tkinter nach PyQt5

Python und das Qt-Toolkit, erstellen von GUIs mittels des Qt-Designers.
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Freitag 16. November 2018, 16:13

@__blackjack__: In meinem Beispielprogramm müsste ich demnach die Werte vom Objekt `main_window` an die Funktion `show_concentration_test_window` übergeben, die sie ihrerseits an die `__init__`-Methode des Objekts `concentration_test_window` weiterleitet. Hast du das mit Übergeben gemeint?

Aktueller, aber nicht lauffähiger Code:

Code: Alles auswählen

import sys, time
from random import choice
#from statistics import mean

from PyQt5.QtWidgets import QApplication, QMainWindow, QDialog
from PyQt5.uic import loadUi
from PyQt5 import QtCore


class MainWindow(QMainWindow):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)

        self.COLORS = {"Schwarz": QtCore.Qt.black,
                  "Blau": QtCore.Qt.blue,
                  "Cyan": QtCore.Qt.cyan,
                  "Grün": QtCore.Qt.green,
                  "Magenta": QtCore.Qt.magenta,
                  "Rot": QtCore.Qt.red,
                  "Gelb": QtCore.Qt.yellow} # 1

        self.designated_color = QtCore.Qt.red  # 2
        self.switch_time = 1000  # 3

        loadUi("mainwindow.ui", self)
        self.pushButton_start_test.clicked.connect(self.window_switched.emit)
        self.comboBox_designated_color.addItems(self.COLORS)


class ConcentrationTestWindow(QMainWindow):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, COLORS, designated_color, switch_time, parent=None):
        super().__init__(parent)
        self.showFullScreen()

        self.COLORS = COLORS
        self.designated_color = designated_color
        self.switch_time = switch_time

        self.color = None
        self.reaction_times = []
        self.false_positives = 0
        self.color_missed = 0
        self.key_too_often_pressed = 0
        self.stop_test = False
        self.color_locked = False
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.change_screen_color)

        self.pal = self.palette()
        self.setAutoFillBackground(True)



    def change_screen_color(self, color_locked=True):
        if self.stop_test:
            self.window_switched.emit()

        if not self.color_locked and self.color == self.designated_color:
            self.color_missed += 1

        self.color_locked = color_locked
        current_color = self.color

        while self.color == current_color:
            self.color = choice(list(self.colors.values()))

        self.pal.setColor(self.backgroundRole(), self.color)
        self.setPalette(self.pal)
        self.start_time = time.monotonic()  # Ereignis Timer

        self.timer.start(self.switch_time)


    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_Escape:
            self.window_switched.emit()

        if event.key() == QtCore.Qt.Key_Space:
            if self.color == self.designated_color:
                if self.color_locked:
                    self.key_too_often_pressed += 1
                else:
                    reaction_time = time.monotonic() - self.start_time
                    self.reaction_times.append(reaction_time)
                    self.color_locked = True
            else:
                self.false_positives += 1


class ResultsWindow(QDialog):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)
        loadUi("resultswindow.ui", self)
        self.stop_test = True
        self.pushButton_OK.clicked.connect(self.window_switched.emit)




def show_concentration_test_window():
    concentration_test_window = ConcentrationTestWindow()
    concentration_test_window.window_switched.connect(show_results_window)
    concentration_test_window.show()
    concentration_test_window.change_screen_color()

def show_results_window():
    results_window = ResultsWindow()
    concentration_test_window.close()
    results_window.window_switched.connect(results_window.reject)
    results_window.show()



def main():
    app = QApplication(sys.argv)

    main_window = MainWindow()
    main_window.window_switched.connect(show_concentration_test_window)
    main_window.show()

    sys.exit(app.exec_())


if __name__ == "__main__":
    main()
Gruß
Atalanttore
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Samstag 17. November 2018, 17:12

Mit dem mehrmaligen Wert übergeben und Rückgabewert hatte ich keine Freude. Die Konstanten zu `COLORS` und weitere Attribute habe ich nun kurzerhand zur Klasse `Controller` hinzugefügt und sie damit zu einer aus OOP-Sicht richtigen Klasse gemacht.

Irgendwie müsste ich die folgende Anweisung nun erweitern/umbauen/ersetzen, um die Werte aus `comboBox_designated_color` und `spinBox_switch_time` an den `controller` übergeben zu können, der damit ein Objekt der Klasse `ConcentrationTestWindow` instanziiert.

Code: Alles auswählen

self.pushButton_start_test.clicked.connect(self.window_switched.emit)
Meine Versuche mit Lambda-Ausdrücken sind leider alle gescheitert. Unter anderem habe ich folgendes probiert und einen SyntaxError ausgelöst:

Code: Alles auswählen

        self.pushButton_start_test.clicked.connect(lambda self.get_designated_color(), self.get_switch_time(): self.window_switched.emit)

Aktueller Code:

Code: Alles auswählen

import sys, time
from random import choice
#from statistics import mean

from PyQt5.QtWidgets import QApplication, QMainWindow, QDialog
from PyQt5.uic import loadUi
from PyQt5 import QtCore



class MainWindow(QMainWindow):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, COLORS, parent=None):
        super().__init__(parent)
        self.COLORS = COLORS

        loadUi("mainwindow.ui", self)
        self.comboBox_designated_color.addItems(self.COLORS)

        self.pushButton_start_test.clicked.connect(self.window_switched.emit)

    def get_designated_color(self):
        return self.COLORS[self.comboBox_designated_color.currentText()]

    def get_switch_time(self):
        return self.spinBox_switch_time.value()


class ConcentrationTestWindow(QMainWindow):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, COLORS, designated_color, switch_time, parent=None):
        super().__init__(parent)
        self.showFullScreen()

        self.colors = COLORS
        self.designated_color = designated_color
        self.switch_time = switch_time

        self.color = None
        self.reaction_times = []
        self.false_positives = 0
        self.color_missed = 0
        self.key_too_often_pressed = 0
        self.stop_test = False
        self.color_locked = False
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.change_screen_color)

        self.pal = self.palette()
        self.setAutoFillBackground(True)



    def change_screen_color(self, color_locked=True):
        if self.stop_test:
            self.window_switched.emit()

        if not self.color_locked and self.color == self.designated_color:
            self.color_missed += 1

        self.color_locked = color_locked
        current_color = self.color

        while self.color == current_color:
            self.color = choice(list(self.colors.values()))

        self.pal.setColor(self.backgroundRole(), self.color)
        self.setPalette(self.pal)
        self.start_time = time.monotonic()  # Ereignis Timer

        self.timer.start(self.switch_time)


    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_Escape:
            self.window_switched.emit()

        if event.key() == QtCore.Qt.Key_Space:
            if self.color == self.designated_color:
                if self.color_locked:
                    self.key_too_often_pressed += 1
                else:
                    reaction_time = time.monotonic() - self.start_time
                    self.reaction_times.append(reaction_time)
                    self.color_locked = True
            else:
                self.false_positives += 1


class ResultsWindow(QDialog):

    window_switched = QtCore.pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)
        loadUi("resultswindow.ui", self)
        self.stop_test = True
        self.pushButton_OK.clicked.connect(self.window_switched.emit)



class Controller:

    def __init__(self):
        self.COLORS = {"Schwarz": QtCore.Qt.black,
                       "Blau": QtCore.Qt.blue,
                       "Cyan": QtCore.Qt.cyan,
                       "Grün": QtCore.Qt.green,
                       "Magenta": QtCore.Qt.magenta,
                       "Rot": QtCore.Qt.red,
                       "Gelb": QtCore.Qt.yellow}

        self.designated_color = QtCore.Qt.green # Nur zu Testzwecken bis das Auslesen aus dem Widget funktioniert.
        self.switch_time = 500 # Nur zu Testzwecken bis das Auslesen aus dem Widget funktioniert.

    def show_main_window(self):
        self.main_window = MainWindow(self.COLORS)
        self.main_window.window_switched.connect(self.show_concentration_test_window)
        self.main_window.show()

    def show_concentration_test_window(self):
        self.concentration_test_window = ConcentrationTestWindow(self.COLORS, self.designated_color, self.switch_time)
        self.concentration_test_window.window_switched.connect(self.show_results_window)
        self.concentration_test_window.show()
        self.concentration_test_window.change_screen_color()

    def show_results_window(self):
        self.results_window = ResultsWindow()
        self.concentration_test_window.close()
        self.results_window.window_switched.connect(self.results_window.reject)
        self.results_window.show()



def main():
    app = QApplication(sys.argv)
    controller = Controller()
    controller.show_main_window()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()
Gruß
Atalanttore
__deets__
User
Beiträge: 6178
Registriert: Mittwoch 14. Oktober 2015, 14:29

Samstag 17. November 2018, 18:24

Was hast du denn erreichen wollen mit

Code: Alles auswählen

        self.pushButton_start_test.clicked.connect(lambda self.get_designated_color(), self.get_switch_time(): self.window_switched.emit)
?

lambdas sind syntaktischer Zucker fuer

Code: Alles auswählen

lamdba argliste: expr <==>
def f(argliste):
        return expr
Wenn du diese Transformation also auf deinen oben gezeigte Lamda-Ausdruck anwendest - was kommt dabei rum, und warum ist das nicht richtig?
Sirius3
User
Beiträge: 10343
Registriert: Sonntag 21. Oktober 2012, 17:20

Samstag 17. November 2018, 20:43

Das mit dem Controller hat immer noch keinen Mehrwert, auch wenn Du ein Attribut fälschlicherweise da reinschiebst. Was sinn macht, ist das M von MVC, völlig ungetestet:

Code: Alles auswählen

import sys
import time
from random import choice

from PyQt5.QtWidgets import QApplication, QMainWindow, QDialog
from PyQt5.uic import loadUi
from PyQt5 import QtCore

class ConcentrationTest(object):
    def __init__(self, colors, designated_color, switch_time):
        self.colors = colors
        self.designated_color = designated_color
        self.switch_time = switch_time
        self.start_time = None
        self.color = None
        self.color_locked = True
        self.reaction_times = []
        self.false_positives = 0
        self.color_missed = 0
        self.key_too_often_pressed = 0

    def space_pressed(self):
        if self.color == self.designated_color:
            if self.color_locked:
                self.key_too_often_pressed += 1
            else:
                reaction_time = time.monotonic() - self.start_time
                self.reaction_times.append(reaction_time)
                self.color_locked = True
        else:
            self.false_positives += 1

    def next_round(self):
        if not self.color_locked and self.color == self.designated_color:
            self.color_missed += 1
        self.color_locked = False
        current_color = self.color
        while self.color == current_color:
            self.color = choice(list(self.colors.values()))
        self.start_time = time.monotonic()  # Ereignis Timer
        return self.color


class MainWindow(QMainWindow):
    COLORS = {"Schwarz": QtCore.Qt.black,
        "Blau": QtCore.Qt.blue,
        "Cyan": QtCore.Qt.cyan,
        "Grün": QtCore.Qt.green,
        "Magenta": QtCore.Qt.magenta,
        "Rot": QtCore.Qt.red,
        "Gelb": QtCore.Qt.yellow}

    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        loadUi("mainwindow.ui", self)
        self.concentration_test = concentration_test
        self.comboBox_designated_color.addItems(self.COLORS)
        self.pushButton_start_test.clicked.connect(self.show_concentration_test_window)

    def get_designated_color(self):
        return self.COLORS[self.comboBox_designated_color.currentText()]

    def get_switch_time(self):
        return self.spinBox_switch_time.value()

    def show_concentration_test_window(self):
        concentration_test = ConcentrationTest(self.colors, self.get_designated_color(), self.get_switch_time())
        concentration_test_window = ConcentrationTestWindow(concentration_test)
        concentration_test_window.show()
        concentration_test_window.change_screen_color()


class ConcentrationTestWindow(QMainWindow):
    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        self.showFullScreen()
        self.concentration_test = concentration_test
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.change_screen_color)
        self.pal = self.palette()
        self.setAutoFillBackground(True)

    def change_screen_color(self):
        color = self.concentration_test.next_round()
        self.pal.setColor(self.backgroundRole(), color)
        self.setPalette(self.pal)
        self.timer.start(self.switch_time)

    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_Escape:
            self.show_result()

        if event.key() == QtCore.Qt.Key_Space:
            self.concentration_test.space_pressed()

    def show_result(self)
        self.close()
        ResultsWindow(self.concentration_test).show()


class ResultsWindow(QDialog):
    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        loadUi("resultswindow.ui", self)
        self.concentration_test = concentration_test
        # TODO: show results?
        self.pushButton_OK.clicked.connect(self.reject)


def main():
    app = QApplication(sys.argv)
    main_window = MainWindow(app)
    main_window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Sonntag 18. November 2018, 20:51

@Sirius3: Vielen Dank für deine Änderungen. Nach einem Klick auf "Test starten" im Hauptfenster erscheint nach deinen Änderungen am Code folgender Fehler:

Code: Alles auswählen

Traceback (most recent call last):
  File "/home/ata/Farbkonzentrationstest/main.py", line 67, in show_concentration_test_window
    concentration_test = ConcentrationTest(self.colors, self.get_designated_color(), self.get_switch_time())
AttributeError: 'MainWindow' object has no attribute 'colors'
Ich habe versucht den Fehler selbst zu beheben (sehr lehrreich). Eine Fehlermeldung kommt jetzt nicht mehr. Allerdings erscheint nach einem Klick auf "Test starten" auch kein Fenster. :roll:

Der Code sieht aktuell so aus:

Code: Alles auswählen

import sys
import time
from random import choice

from PyQt5.QtWidgets import QApplication, QMainWindow, QDialog
from PyQt5.uic import loadUi
from PyQt5 import QtCore


class ConcentrationTest(object):
    def __init__(self, COLORS, designated_color):
        self.COLORS = COLORS
        self.designated_color = designated_color
        self.start_time = None
        self.color = None
        self.color_locked = True
        self.reaction_times = []
        self.false_positives = 0
        self.color_missed = 0
        self.key_too_often_pressed = 0

    def space_pressed(self):
        if self.color == self.designated_color:
            if self.color_locked:
                self.key_too_often_pressed += 1
            else:
                reaction_time = time.monotonic() - self.start_time
                self.reaction_times.append(reaction_time)
                self.color_locked = True
        else:
            self.false_positives += 1

    def next_round(self):
        if not self.color_locked and self.color == self.designated_color:
            self.color_missed += 1
        self.color_locked = False
        current_color = self.color
        while self.color == current_color:
            self.color = choice(list(self.COLORS.values()))
        self.start_time = time.monotonic()  # Ereignis Timer
        return self.color


class MainWindow(QMainWindow):
    COLORS = {"Schwarz": QtCore.Qt.black,
        "Blau": QtCore.Qt.blue,
        "Cyan": QtCore.Qt.cyan,
        "Grün": QtCore.Qt.green,
        "Magenta": QtCore.Qt.magenta,
        "Rot": QtCore.Qt.red,
        "Gelb": QtCore.Qt.yellow}

    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        loadUi("mainwindow.ui", self)
        self.concentration_test = concentration_test
        self.comboBox_designated_color.addItems(self.COLORS)
        self.pushButton_start_test.clicked.connect(self.show_concentration_test_window)

    def get_designated_color(self):
        return self.COLORS[self.comboBox_designated_color.currentText()]

    def get_switch_time(self):
        return self.spinBox_switch_time.value()

    def show_concentration_test_window(self):
        concentration_test = ConcentrationTest(self.COLORS, self.get_designated_color())
        concentration_test_window = ConcentrationTestWindow(concentration_test, self.get_switch_time())
        concentration_test_window.show()
        concentration_test_window.change_screen_color()


class ConcentrationTestWindow(QMainWindow):
    def __init__(self, concentration_test, switch_time, parent=None):
        super().__init__(parent)
        self.showFullScreen()
        self.concentration_test = concentration_test
        self.switch_time = switch_time
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.change_screen_color)
        self.pal = self.palette()
        self.setAutoFillBackground(True)

    def change_screen_color(self):
        color = self.concentration_test.next_round()
        self.pal.setColor(self.backgroundRole(), color)
        self.setPalette(self.pal)
        self.timer.start(self.switch_time)

    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_Escape:
            self.show_result()

        if event.key() == QtCore.Qt.Key_Space:
            self.concentration_test.space_pressed()

    def show_result(self):
        self.close()
        ResultsWindow(self.concentration_test).show()


class ResultsWindow(QDialog):
    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        loadUi("resultswindow.ui", self)
        self.concentration_test = concentration_test
        # TODO: show results?
        self.pushButton_OK.clicked.connect(self.reject)


def main():
    app = QApplication(sys.argv)
    main_window = MainWindow(app)
    main_window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()
Zum Code hätte ich ein paar Fragen:
  1. Warum erscheint nach einem Klick auf "Test starten" kein Vollbild-Fenster?
  2. Warum hast du Teile der Klasse `ConcentrationTestWindow` in die Klasse `ConcentrationTest` ausgegliedert?
  3. Warum erbt die Klasse `ConcentrationTest` von der Klasse `object`?

Gruß
Atalanttore
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Samstag 24. November 2018, 21:03

Frage 1 mit dem Problem des nicht erscheinenden Vollbild-Fensters ist mittlerweile gelöst. Nach einem Hinweis hat mir wohl zum ersten Mal der Garbage Collector Probleme bereitet.

Inzwischen habe ich mein Beispielprogramm vervollständigt.
  1. Was haltet ihr von dem folgenden Code?
  2. Warum bleiben die Elemente im dictionary `self.COLORS` stets in der selben Reihenfolge geordnet, obwohl ein dictionary doch ungeordnet sein soll?
  3. Im Qt Designer hatte der Rahmen des Hauptfensters noch einen gewissen Abstand zu den Widgets, aber im fertigen Programm reichen die Widgets bis zum Rand des Hauptfensters. Warum ist das so?
Hauptfenster im Qt Designer:
Bild

Hauptfenster vom fertigen Programm:
Bild


main.py:

Code: Alles auswählen

import sys
import time
from random import choice
from statistics import mean

from PyQt5.QtWidgets import QApplication, QMainWindow, QDialog
from PyQt5.uic import loadUi
from PyQt5 import QtCore


class ConcentrationTest(object):
    def __init__(self, COLORS, designated_color):
        self.COLORS = COLORS
        self.designated_color = designated_color
        self.start_time = None
        self.color = None
        self.color_locked = True
        self.reaction_times = []
        self.false_positives = 0
        self.color_missed = 0
        self.key_too_often_pressed = 0

    def space_pressed(self):
        if self.color == self.designated_color:
            if self.color_locked:
                self.key_too_often_pressed += 1
            else:
                reaction_time = time.monotonic() - self.start_time
                self.reaction_times.append(reaction_time)
                self.color_locked = True
        else:
            self.false_positives += 1

    def next_round(self):
        if not self.color_locked and self.color == self.designated_color:
            self.color_missed += 1
        self.color_locked = False
        current_color = self.color
        while self.color == current_color:
            self.color = choice(list(self.COLORS.values()))
        self.start_time = time.monotonic()  # Ereignis Timer
        return self.color


class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__()
        loadUi("mainwindow.ui", self)
        self.COLORS = {"Schwarz": QtCore.Qt.black,
                       "Blau": QtCore.Qt.blue,
                       "Cyan": QtCore.Qt.cyan,
                       "Grün": QtCore.Qt.green,
                       "Magenta": QtCore.Qt.magenta,
                       "Rot": QtCore.Qt.red,
                       "Gelb": QtCore.Qt.yellow}
        self.comboBox_designated_color.addItems(self.COLORS)
        self.pushButton_start_test.clicked.connect(self.show_concentration_test_window)

    def get_designated_color(self):
        return self.COLORS[self.comboBox_designated_color.currentText()]

    def get_switch_time(self):
        return self.spinBox_switch_time.value()

    def show_concentration_test_window(self):
        self.concentration_test = ConcentrationTest(self.COLORS, self.get_designated_color())
        self.concentration_test_window = ConcentrationTestWindow(self.concentration_test, self.get_switch_time())
        self.concentration_test_window.show()
        self.concentration_test_window.change_screen_color()


class ConcentrationTestWindow(QMainWindow):
    def __init__(self, concentration_test, switch_time, parent=None):
        super().__init__(parent)
        self.showFullScreen()
        self.concentration_test = concentration_test
        self.switch_time = switch_time
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.change_screen_color)
        self.pal = self.palette()
        self.setAutoFillBackground(True)

    def change_screen_color(self):
        color = self.concentration_test.next_round()
        self.pal.setColor(self.backgroundRole(), color)
        self.setPalette(self.pal)
        self.timer.start(self.switch_time)

    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_Escape:
            self.show_result()

        if event.key() == QtCore.Qt.Key_Space:
            self.concentration_test.space_pressed()

    def show_result(self):
        self.close()
        self.results_window = ResultsWindow(self.concentration_test)
        self.results_window.show()



class ResultsWindow(QDialog):
    def __init__(self, concentration_test, parent=None):
        super().__init__(parent)
        loadUi("resultswindow.ui", self)
        self.concentration_test = concentration_test
        self.pushButton_OK.clicked.connect(self.reject)

        self.label_result_too_often.setText(str(self.concentration_test.key_too_often_pressed))
        self.label_result_color_missed.setText(str(self.concentration_test.color_missed))
        self.label_result_false_positives.setText(str(self.concentration_test.false_positives))
        if self.concentration_test.reaction_times:
            self.mean_reaction_time = round(mean(self.concentration_test.reaction_times), 5)
            self.label_result_mean_reaction_time.setText(str(self.mean_reaction_time) + " s")
            self.listWidget_result_reaction_times.addItems([str(i) + " s" for i in self.concentration_test.reaction_times])
        else:
            self.label_mean_reaction_time.setDisabled(True)
            self.label_reaction_times.setDisabled(True)
            self.listWidget_result_reaction_times.setDisabled(True)


def main():
    app = QApplication(sys.argv)
    main_window = MainWindow(app)
    main_window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()

mainwindow.ui:

Code: Alles auswählen

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>350</width>
    <height>257</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Farbkonzentrationstest</string>
  </property>
  <widget class="QWidget" name="centralwidget">
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
     <layout class="QVBoxLayout" name="verticalLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <item>
       <spacer name="verticalSpacer_2">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>40</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QGroupBox" name="groupBox">
        <layout class="QGridLayout" name="gridLayout">
         <item row="1" column="1">
          <widget class="QSpinBox" name="spinBox_switch_time">
           <property name="maximum">
            <number>100000</number>
           </property>
           <property name="value">
            <number>1000</number>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="QLabel" name="label_switch_time">
           <property name="text">
            <string>Umschaltzeit (ms):</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="QComboBox" name="comboBox_designated_color">
           <property name="currentText">
            <string/>
           </property>
          </widget>
         </item>
         <item row="0" column="0">
          <widget class="QLabel" name="label_designated_color">
           <property name="text">
            <string>Zielfarbe:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
        </layout>
       </widget>
      </item>
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>40</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QPushButton" name="pushButton_start_test">
        <property name="layoutDirection">
         <enum>Qt::LeftToRight</enum>
        </property>
        <property name="text">
         <string>Test starten</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <widget class="QMenuBar" name="menubar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>350</width>
     <height>28</height>
    </rect>
   </property>
  </widget>
  <widget class="QStatusBar" name="statusbar"/>
 </widget>
 <resources/>
 <connections/>
</ui>
resultswindow.ui:

Code: Alles auswählen

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Dialog_results</class>
 <widget class="QDialog" name="Dialog_results">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>700</width>
    <height>350</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Ergebnisse</string>
  </property>
  <layout class="QGridLayout" name="gridLayout_2">
   <item row="0" column="0">
    <layout class="QVBoxLayout" name="verticalLayout">
     <item>
      <widget class="QGroupBox" name="groupBox">
       <layout class="QGridLayout" name="gridLayout">
        <item row="3" column="1">
         <widget class="QLabel" name="label_result_mean_reaction_time">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="label_color_missed">
          <property name="text">
           <string>Bei richtiger Farbe nicht gedrückt:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="QLabel" name="label_result_false_positives">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="0" column="1">
         <widget class="QLabel" name="label_result_too_often">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QLabel" name="label_reaction_times">
          <property name="text">
           <string>Reaktionszeit pro richtig gedrückter Farbe:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_false_positives">
          <property name="text">
           <string>Bei falscher Farbe gedrückt:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <widget class="QLabel" name="label_result_color_missed">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="label_mean_reaction_time">
          <property name="text">
           <string>Gemittelte Reaktionszeit:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="label_too_often">
          <property name="text">
           <string>Bei richtiger Farbe zu oft gedrückt:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QListWidget" name="listWidget_result_reaction_times">
          <property name="minimumSize">
           <size>
            <width>250</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>100</height>
           </size>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </item>
     <item>
      <spacer name="verticalSpacer">
       <property name="orientation">
        <enum>Qt::Vertical</enum>
       </property>
       <property name="sizeHint" stdset="0">
        <size>
         <width>20</width>
         <height>40</height>
        </size>
       </property>
      </spacer>
     </item>
     <item>
      <widget class="QPushButton" name="pushButton_OK">
       <property name="text">
        <string>OK</string>
       </property>
      </widget>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections/>
</ui>
Gruß
Atalanttore
__deets__
User
Beiträge: 6178
Registriert: Mittwoch 14. Oktober 2015, 14:29

Sonntag 25. November 2018, 13:20

self.colors gehört klein geschrieben. Und was das dictionary angeht: da kommt es etwas auf die python version an. Seit 3.X (müsste genau nachschauen) ist das IMMER ein ordered dict. Hat also eine stabile, und von der einfügereihenfolge Abhängige Ordnung.

Davor ist es nicht garantiert gewesen, welche Ordnung man hat. Aber stabil im Sinne von zwei Iterationen liefern immer das gleiche Ergebnis, wenn es zwischendurch keine schreibende Veränderung gab, war es schon immer.
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Sonntag 25. November 2018, 16:28

@__deets__: Danke für die Antwort.
__blackjack__ hat geschrieben:
Sonntag 11. November 2018, 15:44
Edit: Konstanten werden per Konvention immer noch KOMPLETT_GROSS geschrieben.
__deets__ hat geschrieben:
Sonntag 25. November 2018, 13:20
self.colors gehört klein geschrieben.
Die Angabe der verschiedenen Farben ist nach meinem Verständnis eine Konstante, weil sie im Laufe des Programms nicht geändert wird. Deshalb habe ich den Bezeichner vor ein paar Wochen in Großbuchstaben geändert. Habe ich da etwas falsch verstanden?

__deets__ hat geschrieben:
Sonntag 25. November 2018, 13:20
Und was das dictionary angeht: da kommt es etwas auf die python version an. Seit 3.X (müsste genau nachschauen) ist das IMMER ein ordered dict. Hat also eine stabile, und von der einfügereihenfolge Abhängige Ordnung.

Davor ist es nicht garantiert gewesen, welche Ordnung man hat. Aber stabil im Sinne von zwei Iterationen liefern immer das gleiche Ergebnis, wenn es zwischendurch keine schreibende Veränderung gab, war es schon immer.
Bei der Suche nach "ordered dict" habe ich dazu eine Bestätigung gefunden.

Gruß
Atalanttore
Sirius3
User
Beiträge: 10343
Registriert: Sonntag 21. Oktober 2012, 17:20

Sonntag 25. November 2018, 16:36

Konstanten werde nicht innerhalb einer Funktion definiert, und alles was als Parameter in einer Funktion verwendet wird, ist keine Konstante. Ich hatte COLORS als Klassenkonstante direkt im Klassenkörper definiert, aber sobald ich es an ConcentrationTest übergeben hatte, war das in diesem Kontext keine Konstante mehr, denn ich hätte dem Initialisierer auch eine Variable übergeben können.
Atalanttore
User
Beiträge: 341
Registriert: Freitag 6. August 2010, 17:03

Sonntag 25. November 2018, 16:38

@Sirius3: Danke für die Erklärung.
Antworten