如何将lambda函数与pyqt“连接”一起使用。当小部件在循环中安装时，功能？

Question

我正在PYQT项目中创建一个依赖情况的小部件列表（在这里，它以小部件类型的列表表示）。我不知道每种类型所需的小部件的数量，也不知道它们的类型和小部件的数量。

创建它们并不复杂，但是当用户想要更改它们时，我必须抓住它们的新价值时会遇到麻烦。

这是我问题的最低可再现示例：

from PyQt5.QtWidgets import QApplication, QVBoxLayout, QCheckBox, QSpinBox, QWidget
import sys

class MyWidget(QWidget):
    def __init__(self, widgetList):
        super(QWidget, self).__init__()
        self.widgetList = widgetList
        layout = QVBoxLayout()
        
        for widgetNumber in range(len(widgetList)):
        
            if widgetList[widgetNumber] == 'QCheckBox':
                widget = QCheckBox()
                widget.stateChanged.connect(lambda: self.argumentChanged(widgetNumber, widget.isChecked()))
            
            elif widgetList[widgetNumber] == 'QSpinBox':
                widget = QSpinBox()
                widget.valueChanged.connect(lambda: self.argumentChanged(widgetNumber, widget.value()))
            
            layout.addWidget(widget)
            
        self.setLayout(layout)
    
    def argumentChanged(self, widgetNumber, value):
        print("The widget number", widgetNumber, "that is a", self.widgetList[widgetNumber], "has been modified! New value:", value)
    
def window():
    app = QApplication(sys.argv)
    
    widgetList = ['QCheckBox', 'QCheckBox', 'QSpinBox']
    widget = MyWidget(widgetList)
    widget.show()
    
    sys.exit(app.exec_())
    
if __name__ == '__main__':
    window()

在这种情况下，lambda函数中的widgetnumber的价值将始终是循环的最后一次迭代。因此，如果我有4个小部件，我将在每个lambda函数中具有3个值。目的是具有当前小部件的值。

我还试图将lambda函数的表达式更改为这些：

lambda widgetNumber: self.argumentChanged(widgetNumber, widget.value()))

但是情况变得陌生：当增加旋转框的值时，小部件数字在增加，而在减少它时反之亦然。

Answer 1

lambda内使用的变量始终在执行时评估： widgetnumber Will 始终是for循环中的最后一个值。

此外，信号可以具有参数，如果您在lambda中使用位置参数，则该参数将是该信号发射时的值： lambda widgetnumber：将导致spinbox值或状态。复选框。

如果您需要“静态”参数，则需要使用关键字参数。由于信号有参数，因此也无需再次调用getter：

lambda value, widgetNumber=widgetNumber: self.argumentChanged(widgetNumber, value)

请记住，只有在没有其他情况下才能使用lambdas， simpler （ clearer 或 >清洁器）解决方案。
在这种情况下，我们可以使用 sender（） QT提供的功能，该功能返回发出信号的对象。

在下面的示例中，我简化了整个循环，并使用a custom属性直接在小部件上设置数字（请注意，也可以使用一个基本属性，但属性与QT更一致）。

class MyWidget(QWidget):
    def __init__(self, widgetList):
        super(QWidget, self).__init__()
        self.widgetList = widgetList
        layout = QVBoxLayout()

        for number, widgetType in enumerate(widgetList):

            if widgetType == 'QCheckBox':
                widget = QCheckBox()
                widget.toggled.connect(self.argumentChanged)

            elif widgetType == 'QSpinBox':
                widget = QSpinBox()
                widget.valueChanged.connect(self.argumentChanged)

            widget.setProperty('widgetNumber', number)
            layout.addWidget(widget)

        self.setLayout(layout)

    def argumentChanged(self, value):
        widget = self.sender()
        widgetNumber = widget.property('widgetNumber')
        print("The widget number", widgetNumber, 
            "that is a", self.widgetList[widgetNumber], 
            "has been modified! New value:", value)
    

Answer 2

因此，这里发生的事情

widget.stateChanged.connect(lambda: self.argumentChanged(widgetNumber, widget.isChecked()))

是： widgetNumber 与循环的封装中使用的变量相同。到发出 widget.statechanged 信号时，循环的上述已经结束（显然）， widgetnumber is 3 。

lambda widgetnumber：self.argumentChanged（widgetnumber，widget.value（）））

但是情况变得陌生：当增加旋转框的价值时，小部件数量增加，而降低时的副词。

这是因为 value echanged 信号通过新值的整数值为您的函数/插槽作为第一个参数（ widgetNumber 参数），然后将其传递到 self.argument.argument.argumentChanged 中。

为了将 widgetnumber 的值保持在循环的每次迭代期间，您需要使用 widgetnumber 作为[lambda]函数的默认参数。默认参数将在首次定义函数时评估，而不是每次调用时，因此您可以访问 widgetNumber 在循环的每次迭代期间[lambda]函数时的内容。

请注意，您需要使用嵌套功能。如果您只尝试具有一个默认参数的一个函数，则该参数将被设置为小部件的更改值，因为QT5将其作为第一个参数传递。

外部函数是具有 widgetnumber 作为其默认参数的一个功能，只需定义一个内部函数，然后返回（不调用）。它们是否功能都没关系。嵌套的lambdas很难阅读。

这很令人困惑，但请参阅：

    def __init__(self, widgetList):
        super(QWidget, self).__init__()
        self.widgetList = widgetList
        layout = QVBoxLayout()
        
        for widgetNumber in range(len(widgetList)):
            
            if widgetList[widgetNumber] == 'QCheckBox':
                widget = QCheckBox()
                
                # A normal function with a nested lambda function
                def handle_state_changed(default_arg=widgetNumber):
                    return lambda state: print(f"QCheckBox state changed to {state}. default_arg (aka widgetNumber) = {default_arg})")
                
                widget.stateChanged.connect(handle_state_changed())
            
            elif widgetList[widgetNumber] == 'QSpinBox':
                widget = QSpinBox()
                
                # A normal function nested within another normal function
                # Whether they are lambda functions or not doesn't matter
                def handle_value_changed(default_arg=widgetNumber):
                    def inner(value):
                        print(f"QSpinBox value changed to {value}. default_arg (aka widgetNumber) = {default_arg})")
                    
                    return inner
                
                widget.valueChanged.connect(handle_value_changed())
            
            layout.addWidget(widget)
            
        self.setLayout(layout)

另请参见为什么在具有不同值的循环中定义的lambdas都返回相同的结果？