相关疑难解决方法(0)

我正在教自己Python,我最近的教训是Python不是Java,因此我花了一些时间将所有的Class方法转换为函数.

我现在意识到我不需要使用Class方法来处理staticJava中的方法,但现在我不确定何时使用它们.我能找到的关于Python类方法的所有建议都是像我这样的新手应该避开它们,而标准文档在讨论时最不透明.

有没有人有一个在Python中使用Class方法的好例子,或者至少可以有人告诉我什么时候可以明智地使用Class方法？

我最近发现(通过StackOverflow)调用基类中的方法我应该调用:

super([[derived class]], self).[[base class method]]()

没关系,它有效.但是,当我进行更改时,我发现自己经常在类之间复制和粘贴,而且我经常忘记将派生类参数修复为super()函数.

我想避免记得更改派生类参数.我可以改为使用self.__class__super()函数的第一个参数吗？

它似乎有用,但有充分的理由我不应该这样做吗？

sys.setdefaultencoding('utf-8')在Python 2中存在令人沮丧的设置趋势.任何人都可以列出问题的真实例子吗？论证喜欢it is harmful或it hides bugs听起来不太令人信服.

更新:请注意,这个问题只是关于utf-8,它不是关于改变默认编码"一般情况下".

如果可以,请举一些代码示例.

这里有一个惊喜:

>>> class B:
...     print(locals())
...     def foo(self):
...         print(locals())
...         print(__class__ in locals().values())
...         
{'__module__': '__main__', '__qualname__': 'B'}
>>> B().foo()
{'__class__': <class '__main__.B'>, 'self': <__main__.B object at 0x7fffe916b4a8>}
True

似乎只是提到__class__了解析器明确检查了吗？否则我们应该得到类似的东西

NameError: name '__class__' is not defined

实际上,如果您修改为仅检查密钥,即检查'__class__' in locals(),那么我们只self在预期范围内.

如何将这个变量神奇地注入范围？我的猜测是与此有关super- 但我没有使用super,那么为什么编译器在不需要时会在这里创建一个隐式闭包引用呢？

短版(tl; dr)

我正在学习PySide,大多数在线教程都super用来初始化UI元素.这是重要的(即,更具可扩展性),还是品味问题？

澄清:当我在详细版本中更清楚时,这不是另一个通知线程,询问何时使用super(这已经在之前完成).相反,考虑到使用PySide教程的数量super,而不是<class>.__init__,我想如果用弄清楚super是PySide应用程序的标准？如果是这样,是因为super在使用PySide/PyQt时需要特别提到的(涉及解决继承问题)？或者这是品味问题.

详细版本

我是Python的新手,目前正在使用Zets教程学习PySide(http://zetcode.com/gui/pysidetutorial/firstprograms/).本教程的第二个示例包括:

from PySide import QtGui

class Example(QtGui.QWidget):
    def __init__(self):      
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.setGeometry(300,300,250,150)
        self.setWindowTitle("PySide 101: Window the First!")
        self.show()

app=QtGui.QApplication(sys.argv)
ex=Example()
sys.exit(app.exec_())    

这工作正常,但我从未使用过super.因此,我重写了上面的代码,成功地替换super了父类的更标准的显式调用:

QtGui.QWidget.__init__(self)

但是,当我在网上搜索PySide教程时(例如,http://qt-project.org/wiki/PySide-Newbie-Tutorials ),它们都包括调用super.我的问题是:我应该super用于PySide脚本吗？

看来,super当你有继承的钻石,它倾向于解决多重继承的情况下,以合理的方式似乎是最有帮助的.是否super与PySide一起使用,因为这些钻石的案例占优势,我会面对更现实的复杂例子？[编辑:否:请参阅下面的答案.]

我为什么要问？为什么不直接使用super并完成它？

我在问,因为我用来学习Python的书(学习Python,由Lutz撰写)花了20多页关于这个主题super,并明确告诫不要使用它.他建议新的Python用户在使用它之前采用更传统,更明确的路线(例如,参见第832页,学习Python的第1041-1064页,第5版).他基本上将它描绘成一种非剧性的,神秘的,很少需要的新风格,刚开始时你应该非常谨慎地对待它,并认为它被有经验的用户过度使用.

此外,查看两个主要的PySide/PyQt项目(Spyder和pyqtgraph)的源代码,两者都没有使用super.One(Spyder)明确告诉贡献者出于兼容性原因而避免使用它(http://code.google.com/p/spyderlib/wiki/NoteForContributors). …

我的一位同事今天写了类似下面的代码,请我看看,我花了一段时间才发现错误:

class A():                                                                                         
    def __init__(self):                                                         
        print('A')                                                              

class B(A):                                                                     
    def __init__(self):                                                         
        super(B).__init__()                                               

b = B()

这里的问题是在构造函数中没有self参数.让我感到惊讶的是,在这种情况下绝对没有任何事情发生,即没有错误,没有.包含的对象创建了什么？作为一个对象,它显然有一个构造函数,所以这是被调用的,但该对象是如何与？相关的？特别是,为什么这个有效的代码并没有在某处抛出异常？是一个具有一些实际用途的对象,那会是什么？super()Bsupersuper(B)Bsuper(B)

在理解中使用python3的超级似乎总是导致TypeError: super(type, obj): obj must be an instance or subtype of type(但使用python 2的超级确实按预期工作)

class A(object):
    def __repr__(self):
         return "hi!"  

class B(A):
    def __repr__(self):
         return "".join(super().__repr__() for i in range(2))  

repr(B())
#output: <repr(<__main__.B at 0x7f70cf36fcc0>) failed: TypeError: super(type, obj): obj must be an instance or subtype of type>

class C(A):
    def __repr__(self):
        s = ''
        for i in range(4):
            s += super().__repr__()
        return s     

repr(C())
#output: hi!hi!hi!hi!

class D(A):
    def __repr__(self):
        return "".join(super(D,self).__repr__() for i in range(4))

repr(D())
#output: …

这按预期工作:

>>> class Foo(object):
...   @classmethod
...   def hello(cls):
...     print 'hello, foo'
... 
>>> class Bar(Foo):
...   @classmethod
...   def hello(cls):
...     print 'hello, bar'
...     super(Bar, cls).hello()
... 
>>> b = Bar()
>>> b.hello()
hello, bar
hello, foo

我也可以显式调用基类:

>>> class Bar(Foo):
...   @classmethod
...   def hello(cls):
...     print 'hello, bar'
...     Foo.hello()
... 
>>> b = Bar()
>>> b.hello()
hello, bar
hello, foo

我想知道为什么我不能省略第一个参数super,像这样:

>>> class Bar(Foo):
...   @classmethod
...   def hello(cls):
...     print 'hello, …

我想知道从 super() 函数获得的实​​例的类型。我试着print(super())和__print(type(super()))__

class Base:
    def __init__(self):
        pass

class Derive(Base):
    def __init__(self):
        print(super())        
        print(type(super()))        
        super().__init__()

d = Derive()

结果是

<super: <class 'Derive'>, <Derive object>>
<class 'super'>

有了这些结果，我想知道如何super().__init__()调用正确的构造函数。

有时，一个类会有其他方法调用的“私有” ： @classmethod

class FooClassThisSometimesHasALongNameEspIfAUnittestSubclasss(...):
    @classmethod
    def foo():
        ... 

    def bar(self):
        ...
        FooClassThisSometimesHasALongNameEspIfAUnittestSubclasss.foo()
        ...

可以看到，类名是重复的；诚然，这可能还没有严重到导致当前技术崩溃并引发僵尸大灾难，但它仍然是一种DRY违规，而且有点烦人。

类似问题super的答案表明这是Py3 新的原因之一super。

在缺少某些神奇normal()函数（与 相反super()，返回当前类）的情况下，是否有某种方法可以避免重复？