Será que usando propriedades em um estilo antigo problemas classe python causa

Question

pergunta simples Pretty. Eu já vi isso mencionado em muitos lugares que o uso de propriedades em uma classe de estilo antigo não deve trabalhar, mas, aparentemente, as classes Qt (através PyQt4) não são novos em estilo e há propriedades em alguns deles no código I 'm trabalhando com (e, tanto quanto eu sei o código não está mostrando nenhum tipo de problemas)

Eu corri através de uma função pyqtProperty, mas eu não consigo encontrar qualquer documentação sobre isso. Seria uma boa alternativa neste caso?

Answer 1

propriedade funciona porque QObject tem uma metaclasse que cuida deles. Testemunha esta pequena variação sobre @ código de quark ...:

from PyQt4.QtCore import QObject

def makec(base):
  class X( base ):
      def __init__(self):
          self.__x = 10
      def get_x(self):
          print 'getting',
          return self.__x
      def set_x(self, x):
          print 'setting', x
          self.__x = x
      x = property(get_x, set_x)

  print 'made class of mcl', type(X), issubclass(type(X), type)
  return X

class old: pass
for base in (QObject, old):
  X = makec(base)
  x = X()
  print x.x # Should be 10
  x.x = 30
  print x.x # Should be 30

A execução deste emite:

made class of mcl <type 'PyQt4.QtCore.pyqtWrapperType'> True
getting 10
setting 30
getting 30
made class of mcl <type 'classobj'> False
getting 10
30

ver a diferença? Na classe que é realmente um legado (do tipo antigo) classe, a feita pela segunda vez, metaclass é classobj (que não é uma subclasse de tipo) e as propriedades não trabalho direito (atribuindo x.x ignora a propriedade, e depois de que a obtenção de x.x não vê a propriedade mais quer). Mas no primeiro caso, o caso Qt, há uma metaclass diferente, e é uma subclasse do tipo (por isso não é realmente correto dizer a classe "não é novo estilo"!), E as coisas, portanto, fazer o trabalho corretamente.

Answer 2

Propriedades do trabalho tipo Python, na minha experiência, muito bem em PyQt4 objetos. Eu não sei se eles são explicitamente apoiada por PyQt4 ou não ou se existem algumas armadilhas escondidas, mas eu nunca vi eles se comportassem mal. Aqui está um exemplo usando PyQt 4.4 e Python 2.5:

from PyQt4.QtCore import QObject

class X( QObject ):

    def __init__(self):
        self.__x = 10

    def get_x(self):
        return self.__x

    def set_x(self, x):
        self.__x = x

    x = property(get_x, set_x)

x = X()
print x.x # Should be 10
x.x = 30
print x.x # Should be 30

pyqtProperty é permitir usando sistema de propriedade do Qt que não é o mesmo como Python. Qt propriedades são introspectable de dentro das classes de Qt C ++ (que propriedades Python matérias não são), e são utilizados pelo Qt para tais coisas como o Qt Designer editor de formulários, e Qt Creator IDE. Eles permitem que uma grande parte do tipo de introspecção de em tempo de execução estado que você tem em Python e perder em C ++. Em geral Qt fornece algumas das características de linguagens dinâmicas para C ++, e esta não é a única área onde PyQt fornece mais de uma maneira de fazer a mesma coisa (considere também cordas, dicionários, de arquivo I / O e assim por diante). Com a maioria dessas escolhas o principal conselho que eu tenho é apenas para escolher um lado ou do outro e ficar com ela, só para evitar a possibilidade de alguma incompatibilidade desagradável. I tendem a preferir a versão Python sobre a versão Qt porque Python é mais central para o meu trabalho do que Qt é. Se você estava indo para considerar portar qualquer coisa de PyQt de volta para C ++ Qt, do que você pode preferir a versão Qt de um recurso sobre o Python.

Answer 3

Pelo menos em PyQt4.5, as classes Qt certamente são novos objetos de estilo, como visto a partir de sua ordem de resolução método:

from PyQt4 import QtGui
print QtGui.QWidget.__mro__
(<class 'PyQt4.QtGui.QWidget'>, <class 'PyQt4.QtCore.QObject'>, <type 'sip.wrapper'>, <class 'PyQt4.QtGui.QPaintDevice'>, <type 'sip.simplewrapper'>, <type 'object'>)