Python ile genişletme - super () Python 3 ve Python 2 kullanarak

Başlangıçta bu soruyu sormak istedim , ancak daha önce düşünülmüş olduğunu anladım ...

Googling, bu configparser'ı genişletme örneğini buldum . Aşağıdakiler Python 3 ile çalışır:

$ python3
Python 3.2.3rc2 (default, Mar 21 2012, 06:59:51) 
[GCC 4.6.3] on linux2
>>> from configparser import  SafeConfigParser
>>> class AmritaConfigParser(SafeConfigParser):
...     def __init_(self):
...         super().__init__()
... 
>>> cfg = AmritaConfigParser()

Ancak Python 2 ile değil:

>>> class AmritaConfigParser(SafeConfigParser):
...       def __init__(self):
...           super(SafeConfigParser).init()
... 
>>> cfg = AmritaConfigParser()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: must be type, not classob

Sonra biraz Python Yeni Sınıf ve Eski Sınıf stilleri okudum (örneğin burada . Ve şimdi merak ediyorum, şunları yapabilirim:

class MyConfigParser(ConfigParser.ConfigParser):
      def Write(self, fp):
          """override the module's original write funcition"""
          ....
      def MyWrite(self, fp):
          """Define new function and inherit all others"""

Ama init'i aramamalı mıyım? Bu Python 2'de eşdeğer mi:

 class AmritaConfigParser(ConfigParser.SafeConfigParser):
    #def __init__(self):
    #    super().__init__() # Python3 syntax, or rather, new style class syntax ...
    #
    # is this the equivalent of the above ? 
    def __init__(self):
        ConfigParser.SafeConfigParser.__init__(self)

• super()(bağımsız değişkenler olmadan) Python 3'te (bununla birlikte __class__) tanıtıldı :

  super() -> same as super(__class__, self)

  bu, yeni stil sınıfları için Python 2 eşdeğeri olacaktır:

  super(CurrentClass, self)

• eski tarz sınıflar için her zaman kullanabilirsiniz:

   class Classname(OldStyleParent):
      def __init__(self, *args, **kwargs):
          OldStyleParent.__init__(self, *args, **kwargs)

Tek bir miras durumunda (yalnızca bir sınıfı alt sınıflara ayırdığınızda), yeni sınıfınız temel sınıfın yöntemlerini miras alır. Bu içerir __init__. Yani sınıfınızda tanımlamazsanız, temelden bir tane alacaksınız.

Birden fazla kalıtım getirirseniz (bir seferde birden fazla sınıfı alt sınıflara ayırmak) işler karmaşıklaşmaya başlar. Bunun nedeni, birden fazla temel sınıfa sahipse __init__, sınıfınızın yalnızca ilkini miras almasıdır.

Böyle durumlarda gerçekten kullanmalısınız, supereğer yapabiliyorsanız, nedenini açıklayacağım. Ama her zaman yapamazsın. Sorun şu ki, tüm temel sınıflarınız da onu (ve onların temel sınıfları da - tüm ağacı) kullanmalıdır.

Durum böyleyse, bu da doğru şekilde çalışacaktır (Python 3'te ancak Python 2'de yeniden çalışabilirsiniz - ayrıca vardır super):

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

class B:
    def __init__(self):
        print('B')
        super().__init__()

class C(A, B):
    pass

C()
#prints:
#A
#B

Her iki temel sınıfın superkendi temel sınıfları olmasa bile nasıl kullandığına dikkat edin .

Ne superyapar: MRO'daki bir sonraki sınıftan yöntemi çağırır (yöntem çözümleme sırası). İçin MRO Cgeçerli: (C, A, B, object). C.__mro__Görmek için yazdırabilirsiniz .

Yani, Cdevralır __init__gelen Ave superiçinde A.__init__çağrıların B.__init__( Başağıda AMRO olarak).

Yani içinde hiçbir şey Cyapmazsanız, ikisini de ararsınız, ki bu da istediğiniz şeydir.

Şimdi kullanmıyor superolsaydın, A.__init__(daha önce olduğu gibi) miras alırdın ama bu sefer B.__init__seni çağıracak hiçbir şey yok .

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

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

class C(A, B):
    pass

C()
#prints:
#A

Bunu düzeltmek için şunları tanımlamanız gerekir C.__init__:

class C(A, B):
    def __init__(self):
        A.__init__(self)
        B.__init__(self)

Bununla ilgili sorun, daha karmaşık MI ağaçlarında, __init__bazı sınıfların yöntemlerinin birden fazla çağrılırken, süper / MRO'nun yalnızca bir kez çağrıldıklarını garanti etmesidir.

Kısaca eşdeğerdirler. Bir geçmiş görüşüne sahip olalım:

(1) ilk başta, işlev şöyle görünür.

    class MySubClass(MySuperClass):
        def __init__(self):
            MySuperClass.__init__(self)

(2) kodu daha soyut (ve daha taşınabilir) hale getirmek. Super-Class edinmenin yaygın bir yöntemi şu şekildedir:

    super(<class>, <instance>)

Ve init işlevi şunlar olabilir:

    class MySubClassBetter(MySuperClass):
        def __init__(self):
            super(MySubClassBetter, self).__init__()

Bununla birlikte, hem sınıfın hem de örneğin açık bir şekilde geçmesini zorunlu kılmak, DRY (Kendini Tekrar Etme) kuralını biraz bozar.

(3) V3'te. Daha akıllı

    super()

çoğu durumda yeterlidir. Http://www.python.org/dev/peps/pep-3135/ adresine başvurabilirsiniz.

Şimdi çoğu insanın kullandığı anlaşılan Python 3 için basit ve eksiksiz bir örneğe sahip olmak için.

class MySuper(object):
    def __init__(self,a):
        self.a = a

class MySub(MySuper):
    def __init__(self,a,b):
        self.b = b
        super().__init__(a)

my_sub = MySub(42,'chickenman')
print(my_sub.a)
print(my_sub.b)

verir

42
chickenman

Abstract sınıflarının super () ile kullanılmasını içeren başka bir python3 uygulaması. Bunu hatırlamalısın

super().__init__(name, 10)

ile aynı etkiye sahiptir

Person.__init__(self, name, 10)

Super () 'de gizli bir' benlik 'olduğunu hatırlayın, böylece aynı nesne süper sınıf başlatma yöntemine geçer ve nitelikler onu çağıran nesneye eklenir. Bu nedenle super()çevrilir Personve sonra gizli benliği eklerseniz, yukarıdaki kod parçasını alırsınız.

from abc import ABCMeta, abstractmethod
class Person(metaclass=ABCMeta):
    name = ""
    age = 0

    def __init__(self, personName, personAge):
        self.name = personName
        self.age = personAge

    @abstractmethod
    def showName(self):
        pass

    @abstractmethod
    def showAge(self):
        pass


class Man(Person):

    def __init__(self, name, height):
        self.height = height
        # Person.__init__(self, name, 10)
        super().__init__(name, 10)  # same as Person.__init__(self, name, 10)
        # basically used to call the superclass init . This is used incase you want to call subclass init
        # and then also call superclass's init.
        # Since there's a hidden self in the super's parameters, when it's is called,
        # the superclasses attributes are a part of the same object that was sent out in the super() method

    def showIdentity(self):
        return self.name, self.age, self.height

    def showName(self):
        pass

    def showAge(self):
        pass


a = Man("piyush", "179")
print(a.showIdentity())