Ho una situazione del genere ...
class Outer(object):
def some_method(self):
# do something
class Inner(object):
def __init__(self):
self.Outer.some_method() # <-- this is the line in questionCome posso accedere al Outermetodo della Innerclasse dalla classe?
self.<original_parent_name>e ottenere la classe originale, non la nuova classe da cui sono una sottoclasse . Spero che le persone che leggono questo possano visualizzare questo difficile scenario e vedere il punto di domande come questa.
Risposte:
I metodi di una classe nidificata non possono accedere direttamente agli attributi di istanza della classe esterna.
Nota che non è necessariamente il caso che esista un'istanza della classe esterna anche quando hai creato un'istanza della classe interna.
Infatti, è spesso sconsigliato l'uso di classi annidate, poiché l'annidamento non implica alcuna relazione particolare tra le classi interne ed esterne.
Stai tentando di accedere all'istanza della classe di Outer, dall'istanza della classe interna. Quindi usa il metodo factory per costruire l'istanza Inner e passarle l'istanza Outer.
class Outer(object):
def createInner(self):
return Outer.Inner(self)
class Inner(object):
def __init__(self, outer_instance):
self.outer_instance = outer_instance
self.outer_instance.somemethod()
def inner_method(self):
self.outer_instance.anothermethod()forse sono pazzo ma questo sembra davvero molto facile - il fatto è rendere la tua classe interiore all'interno di un metodo della classe esterna ...
def do_sthg( self ):
...
def messAround( self ):
outerClassSelf = self
class mooble():
def do_sthg_different( self ):
...
outerClassSelf.do_sthg()Inoltre ... "self" è usato solo per convenzione, quindi puoi farlo:
def do_sthg( self ):
...
def messAround( outerClassSelf ):
class mooble():
def do_sthg_different( self ):
...
outerClassSelf.do_sthg()Si potrebbe obiettare che non è possibile creare questa classe interna dall'esterno della classe esterna ... ma questo non è vero:
class Bumblebee():
def do_sthg( self ):
print "sthg"
def giveMeAnInnerClass( outerClassSelf ):
class mooble():
def do_sthg_different( self ):
print "something diff\n"
outerClassSelf.do_sthg()
return mooblepoi, da qualche parte a miglia di distanza:
blob = Bumblebee().giveMeAnInnerClass()()
blob.do_sthg_different() anche spingere la barca un po 'fuori ed estendere questa classe interna (NB per far funzionare super () devi cambiare la firma della classe di mooble in "class mooble (object)"
class InnerBumblebeeWithAddedBounce( Bumblebee().giveMeAnInnerClass() ):
def bounce( self ):
print "bounce"
def do_sthg_different( self ):
super( InnerBumblebeeWithAddedBounce, self ).do_sthg_different()
print "and more different"
ibwab = InnerBumblebeeWithAddedBounce()
ibwab.bounce()
ibwab.do_sthg_different()dopo
mrh1997 ha sollevato un punto interessante sull'ereditarietà non comune delle classi interne fornite utilizzando questa tecnica. Ma sembra che la soluzione sia piuttosto semplice:
class Fatty():
def do_sthg( self ):
pass
class InnerFatty( object ):
pass
def giveMeAnInnerFattyClass(self):
class ExtendedInnerFatty( Fatty.InnerFatty ):
pass
return ExtendedInnerFatty
fatty1 = Fatty()
fatty2 = Fatty()
innerFattyClass1 = fatty1.giveMeAnInnerFattyClass()
innerFattyClass2 = fatty2.giveMeAnInnerFattyClass()
print ( issubclass( innerFattyClass1, Fatty.InnerFatty ))
print ( issubclass( innerFattyClass2, Fatty.InnerFatty ))Intendi usare l'ereditarietà invece di nidificare classi come questa? Quello che stai facendo non ha molto senso in Python.
Puoi accedere a Outersome_method di s semplicemente facendo riferimento Outer.some_methodai metodi della classe interna, ma non funzionerà come ti aspetti. Ad esempio, se provi questo:
class Outer(object):
def some_method(self):
# do something
class Inner(object):
def __init__(self):
Outer.some_method()... riceverai un'eccezione TypeError quando inizializzi un Inneroggetto, perché si Outer.some_methodaspetta di ricevere Outerun'istanza come primo argomento. (Nell'esempio sopra, stai fondamentalmente cercando di chiamare some_methodcome metodo di classe di Outer.)
Puoi accedere facilmente alla classe esterna usando la metaclasse: dopo la creazione della classe esterna controlla il suo attributo dict per qualsiasi classe (o applica la logica di cui hai bisogno - il mio è solo un esempio banale) e imposta i valori corrispondenti:
import six
import inspect
# helper method from `peewee` project to add metaclass
_METACLASS_ = '_metaclass_helper_'
def with_metaclass(meta, base=object):
return meta(_METACLASS_, (base,), {})
class OuterMeta(type):
def __new__(mcs, name, parents, dct):
cls = super(OuterMeta, mcs).__new__(mcs, name, parents, dct)
for klass in dct.values():
if inspect.isclass(klass):
print("Setting outer of '%s' to '%s'" % (klass, cls))
klass.outer = cls
return cls
# @six.add_metaclass(OuterMeta) -- this is alternative to `with_metaclass`
class Outer(with_metaclass(OuterMeta)):
def foo(self):
return "I'm outer class!"
class Inner(object):
outer = None # <-- by default it's None
def bar(self):
return "I'm inner class"
print(Outer.Inner.outer)
>>> <class '__main__.Outer'>
assert isinstance(Outer.Inner.outer(), Outer)
print(Outer().foo())
>>> I'm outer class!
print(Outer.Inner.outer().foo())
>>> I'm outer class!
print(Outer.Inner().outer().foo())
>>> I'm outer class!
print(Outer.Inner().bar())
>>> I'm inner class!Utilizzando questo approccio, puoi facilmente associare e fare riferimento a due classi tra loro.
Ho creato del codice Python per utilizzare una classe esterna dalla sua classe interna , basato su una buona idea di un'altra risposta a questa domanda. Penso che sia breve, semplice e facile da capire.
class higher_level__unknown_irrelevant_name__class:
def __init__(self, ...args...):
...other code...
# Important lines to access sub-classes.
subclasses = self._subclass_container()
self.some_subclass = subclasses["some_subclass"]
del subclasses # Free up variable for other use.
def sub_function(self, ...args...):
...other code...
def _subclass_container(self):
_parent_class = self # Create access to parent class.
class some_subclass:
def __init__(self):
self._parent_class = _parent_class # Easy access from self.
# Optional line, clears variable space, but SHOULD NOT BE USED
# IF THERE ARE MULTIPLE SUBCLASSES as would stop their parent access.
# del _parent_class
class subclass_2:
def __init__(self):
self._parent_class = _parent_class
# Return reference(s) to the subclass(es).
return {"some_subclass": some_subclass, "subclass_2": subclass_2}Il codice principale, "pronto per la produzione" (senza commenti, ecc.). Ricordarsi di sostituire tutti i valori tra parentesi angolari (ad esempio <x>) con il valore desiderato.
class <higher_level_class>:
def __init__(self):
subclasses = self._subclass_container()
self.<sub_class> = subclasses[<sub_class, type string>]
del subclasses
def _subclass_container(self):
_parent_class = self
class <sub_class>:
def __init__(self):
self._parent_class = _parent_class
return {<sub_class, type string>: <sub_class>}Creare una funzione denominata _subclass_containerper fungere da wrapper per accedere alla variabile self, un riferimento alla classe di livello superiore (dal codice in esecuzione all'interno della funzione).
Creare una variabile denominata _parent_classche sia un riferimento alla variabile selfdi questa funzione, a cui le sottoclassi di _subclass_containerpossono accedere (evita conflitti di nome con altre selfvariabili nelle sottoclassi).
Restituisce la sottoclasse / sottoclassi come un dizionario / elenco in modo che il codice che chiama la _subclass_containerfunzione possa accedere alle sottoclassi all'interno.
Nella __init__funzione all'interno della classe di livello superiore (o ovunque sia necessario), ricevi le sottoclassi restituite dalla funzione _subclass_containernella variabile subclasses.
Assegna le sottoclassi memorizzate nella subclassesvariabile agli attributi della classe di livello superiore.
Rendere il codice per assegnare le sottoclassi alla classe di livello superiore più facile da copiare e da utilizzare nelle classi derivate dalla classe di livello superiore che hanno la loro __init__ funzione modificata:
Inserire prima della riga 12 nel codice principale:
def _subclass_init(self):Quindi inserire in questa funzione le righe 5-6 (del codice principale) e sostituire le righe 4-7 con il seguente codice:
self._subclass_init(self)Rendere possibile l'assegnazione di sottoclassi alla classe di livello superiore quando ci sono molte / quantità sconosciute di sottoclassi.
Sostituisci la riga 6 con il codice seguente:
for subclass_name in list(subclasses.keys()):
setattr(self, subclass_name, subclasses[subclass_name])Viene class a:creata una classe denominata "a" ( ). Ha sottoclassi che devono accedervi (il genitore). Una sottoclasse è chiamata "x1". In questa sottoclasse, il codice a.run_func()viene eseguito.
Quindi viene creata un'altra classe, denominata "b", derivata dalla classe "a" ( class b(a):). Dopodiché, viene eseguito del codice b.x1()(chiamando la funzione secondaria "x1" di b, una sottoclasse derivata). Questa funzione viene eseguita a.run_func()chiamando la funzione "run_func" della classe "a", non la funzione "run_func" del suo genitore, "b" (come dovrebbe), perché la funzione definita nella classe "a" è impostata per fare riferimento alla funzione della classe "a", poiché quella era il suo genitore.
Ciò causerebbe problemi (es. Se la funzione a.run_funcè stata cancellata) e l'unica soluzione senza riscrivere il codice in classe a.x1sarebbe ridefinire la sottoclasse x1con codice aggiornato per tutte le classi derivate dalla classe "a" che ovviamente sarebbe difficile e non vale la pena esso.
Ho trovato questo .
Ottimizzato per soddisfare la tua domanda:
class Outer(object):
def some_method(self):
# do something
class _Inner(object):
def __init__(self, outer):
outer.some_method()
def Inner(self):
return _Inner(self)Sono sicuro che in qualche modo puoi scrivere un decoratore per questo o qualcosa del genere
Un'altra possibilità:
class _Outer (object):
# Define your static methods here, e.g.
@staticmethod
def subclassRef ():
return Outer
class Outer (_Outer):
class Inner (object):
def outer (self):
return _Outer
def doSomething (self):
outer = self.outer ()
# Call your static mehthods.
cls = outer.subclassRef ()
return cls ()Espandendo il pensiero convincente di @ tsnorri, che il metodo esterno potrebbe essere un metodo statico :
class Outer(object):
@staticmethod
def some_static_method(self):
# do something
class Inner(object):
def __init__(self):
self.some_static_method() # <-- this will work later
Inner.some_static_method = some_static_methodOra la linea in questione dovrebbe funzionare nel momento in cui viene effettivamente chiamata.
L'ultima riga nel codice precedente fornisce alla classe Inner un metodo statico che è un clone del metodo statico Outer.
Questo sfrutta due funzionalità di Python, che le funzioni sono oggetti e l' ambito è testuale .
Di solito, l'ambito locale fa riferimento ai nomi locali della funzione corrente (testualmente).
... o la classe attuale nel nostro caso. Quindi gli oggetti "locali" alla definizione della classe Outer ( Innere some_static_method) possono essere indicati direttamente all'interno di quella definizione.
Qualche anno in ritardo per la festa ... ma per espandere @mike rodentla meravigliosa risposta, ho fornito il mio esempio di seguito che mostra quanto sia flessibile la sua soluzione e perché dovrebbe essere (o avrebbe dovuto essere) accettata risposta.
Python 3.7
class Parent():
def __init__(self, name):
self.name = name
self.children = []
class Inner(object):
pass
def Child(self, name):
parent = self
class Child(Parent.Inner):
def __init__(self, name):
self.name = name
self.parent = parent
parent.children.append(self)
return Child(name)
parent = Parent('Bar')
child1 = parent.Child('Foo')
child2 = parent.Child('World')
print(
# Getting its first childs name
child1.name, # From itself
parent.children[0].name, # From its parent
# Also works with the second child
child2.name,
parent.children[1].name,
# Go nuts if you want
child2.parent.children[0].name,
child1.parent.children[1].name
)
print(
# Getting the parents name
parent.name, # From itself
child1.parent.name, # From its children
child2.parent.name,
# Go nuts again if you want
parent.children[0].parent.name,
parent.children[1].parent.name,
# Or insane
child2.parent.children[0].parent.children[1].parent.name,
child1.parent.children[1].parent.children[0].parent.name
)
# Second parent? No problem
parent2 = Parent('John')
child3 = parent2.Child('Doe')
child4 = parent2.Child('Appleseed')
print(
child3.name, parent2.children[0].name,
child4.name, parent2.children[1].name,
parent2.name # ....
)Produzione:
Foo Foo World World Foo World
Bar Bar Bar Bar Bar Bar Bar
Doe Doe Appleseed Appleseed JohnAncora una volta, una risposta meravigliosa, oggetti di scena per te Mike!
È troppo semplice:
class A:
def __init__(self):
pass
def func1(self):
print('class A func1')
class B:
def __init__(self):
a1 = A()
a1.func1()
def func1(self):
print('class B func1')
b = A.B()
b.func1()classe A func1
classe B func1
func1. E, altrettanto divertente, crei un Ainterno del costruttore di B, che NON è assolutamente l' Aoggetto della classe esterna di quel particolare B.