Basic inheritance (in python)

Question

I have a basic question regarding inheritance (in python). I have two classes, and one of them inherits from the other, for example

class p: def __init__(self,name): self.pname = name class c(p): def __init__(self,name): self.cname = name 

Is there a chance that I can create a parent and several child objects that are related to the SAME-parent? It should work so that the parent contains several variables, and whenever I access the corresponding variables from the child, I actually refer to the variable, the form of the parent. That is, if I changed it for one child, it will be changed also for all other children, and the data will be stored only once in memory (and will not be copied for each child ...)

Thanks in advance.

Here is a possible workaround that I don't find so enjoyable

 class P: def __init__(self, name): self.pname = name class C: def __init__(self, name,pobject): self.pobject = pobject self.cname = name 

Is this really a modern state or are there other concepts?

Sebastian

Thanks to everyone for helping me, also with conventions :) But I'm still not very happy. Perhaps I am giving a more advanced example to emphasize what I really want to do.

 class P: data = "shareddata" def __init__(self,newdata): self.data = newdata def printname(self): print self.name class C(P): def __init__(self,name): self.name = name 

Now I can do the following

 In [33]: c1 = test.C("name1") In [34]: c2 = test.C("name2") In [35]: c1.printname() name1 In [36]: c2.printname() name2 In [37]: c1.data Out[37]: 'shareddata' In [38]: c2.data Out[38]: 'shareddata' 

And this is exactly what I want. There is a variable name that is different for each child, and the parent class accesses the individual variables. Normal inheritance. Then there is the variable data that comes from the parent class, and each child gets access to it. However now no longer works

 In [39]: c1.data = "tst" In [40]: c2.data Out[40]: 'shareddata' In [41]: c1.data Out[41]: 'tst' 

I want the change in c1.data to affect c2.data as well, since I want the variable to be split, like a global variable of this parent class.

And more than that. I also want to create different instances of P, each of which has its own data variable. And when I create a new C object, I want to indicate from which data the P object should be inhetited, i.e. shared ....

UPDATE:

Check out @eyquem's comment: Thanks for that, it is heading in the direction I want. However, now __class__.pvar is shared between all objects in the class. I want multiple P instances to have another pvar. Suppose P1 has pvar = 1 and P2 has pvar = 2. Then I want to create child elements C1a, C1b, C1c that are connected to P1, that is, if I say that C1a.pvar should remove pvar from P1. Then I create C2a, C2b, C2c, and if I get access, i.e. C2b.pvar, I want to access pvar from P2. Since class C inherits pvar from class P pvar, it is known to C. My naive idea is that if I create a new CI instance, you must specify which (existing) P-object should be used as the parent object, and not create a completely new P object, as is done when P.__init__ inside __init__ C ... It sounds simple to me, maybe I forgot something ...

UPDATE:

So, I found this discussion , which is pretty much my question.

Any suggestions?

UPDATE:

The class ._ subclasses_ method no longer exists.

UPDATE:

Here is another link:

discussion link

There he is solved by copying. But I do not want to copy the parent class, because I would like it to exist only once ...

UPDATE:

I apologize for yesterday's discussion, I'm a little sick ... And thanks for the messages! Now I will read them. I thought about it a little more, and here is a possible solution that I found

 class P(object): def __init__(self,pvar): self.pobject = None self._pvar = pvar @property def pvar(self): if self.pobject != None: return self.pobject.pvar else: return self._pvar @pvar.setter def pvar(self,val): if self.pobject != None: self.pobject.pvar = val else: self._pvar=val def printname(self): print self.name class C(P): def __init__(self,name,pobject): #<-- The same default `P()` is # used for all instances of `C`, # unless pobject is explicitly defined. P.__init__(self,None) self.name = name self.pobject = pobject p1 = P("1") p2 = P("2") c1a = C("c1a",p1) c1b = C("c1b",p1) c1c = C("c1c",p1) c2a = C("c2a",p2) c2b = C("c2b",p2) c2c = C("c2c",p2) print id(c1a.pvar) print id(c1b.pvar) print id(c1c.pvar) print id(c2a.pvar) print id(c2b.pvar) print id(c2c.pvar) print id(p1.pvar) print id(p2.pvar) print id(c1a.name) print id(c1b.name) print id(c1c.name) print id(c2a.name) print id(c2b.name) print id(c2c.name) 

This is a bit cumbersome, and I hope there is an easier way to achieve this. But it does have a function that pvar is only mentioned in class P, and class C does not know about pvar, since this should be according to my understanding of inheritance. However, when I create a new instance of C, I can specify an existing instance of P to be stored in the pobject variable. When the pvar variable is actually accessed, pvar from the P instance stored in this variable is available ...

Output is determined

 3078326816 3078326816 3078326816 3074996544 3074996544 3074996544 3078326816 3074996544 156582944 156583040 156583200 156583232 156583296 156583360 

Now I will read your last comments,

all the best, Sebastian

UPDATE:

I think the most elegant way would be the following (which DOES NOT work)

 class P(object): def __init__(self,pvar): self.pvar = pvar def printname(self): print self.name class C(P): def __init__(self,name,pobject): P = pobject self.name = name 

I think python should consider this ...

UPDATE:

Ok, now I have found a way to achieve this, thanks to the explanations of eyquem. But since this is really a hack, there must be an official version for the same ...

 def replaceinstance(parent,child): for item in parent.__dict__.items(): child.__dict__.__setitem__(item[0],item[1]) print item class P(object): def __init__(self,pvar): self.pvar = pvar def printname(self): print self.name class C(P): def __init__(self,name,pobject): P.__init__(self,None) replaceinstance(pobject,self) self.name = name p1 = P("1") p2 = P("2") c1a = C("c1a",p1) c1b = C("c1b",p1) c1c = C("c1c",p1) c2a = C("c2a",p2) c2b = C("c2b",p2) c2c = C("c2c",p2) print id(c1a.pvar) print id(c1b.pvar) print id(c1c.pvar) print id(c2a.pvar) print id(c2b.pvar) print id(c2c.pvar) print id(p1.pvar) print id(p2.pvar) print id(c1a.name) print id(c1b.name) print id(c1c.name) print id(c2a.name) print id(c2b.name) print id(c2c.name) 

the conclusion is the same as above

 3077745184 3077745184 3077745184 3074414912 3074414912 3074414912 3077745184 3074414912 144028416 144028448 144028480 144028512 144028544 144028576 

UPDATE: even if the identifier seems correct, the last code does not work, as is clear from this test

 c1a.pvar = "newpvar1" print c1a.pvar print c1b.pvar print c1c.pvar print c2a.pvar print c2b.pvar print c2c.pvar print p1.pvar print p2.pvar 

he has a way out

 newpvar1 1 1 2 2 2 1 2 

However, the first version I posted works:

 class P(object): def __init__(self,pvar): self.pobject = None self._pvar = pvar @property def pvar(self): if self.pobject != None: return self.pobject.pvar else: return self._pvar @pvar.setter def pvar(self,val): if self.pobject != None: self.pobject.pvar = val else: self._pvar=val def printname(self): print self.name class C(P): def __init__(self,name,pobject): #<-- The same default `P()` is # used for all instances of `C`, # unless pobject is explicitly defined. P.__init__(self,None) self.name = name self.pobject = pobject p1 = P("1") p2 = P("2") c1a = C("c1a",p1) c1b = C("c1b",p1) c1c = C("c1c",p1) c2a = C("c2a",p2) c2b = C("c2b",p2) c2c = C("c2c",p2) print id(c1a.pvar) print id(c1b.pvar) print id(c1c.pvar) print id(c2a.pvar) print id(c2b.pvar) print id(c2c.pvar) print id(p1.pvar) print id(p2.pvar) print id(c1a.name) print id(c1b.name) print id(c1c.name) print id(c2a.name) print id(c2b.name) print id(c2c.name) print "testing\n" c1a.printname() c1b.printname() c1c.printname() c2a.printname() c2b.printname() c2c.printname() print "\n" c1a.name = "c1anewname" c2b.name = "c2bnewname" c1a.printname() c1b.printname() c1c.printname() c2a.printname() c2b.printname() c2c.printname() print "pvar\n" print c1a.pvar print c1b.pvar print c1c.pvar print c2a.pvar print c2b.pvar print c2c.pvar print p1.pvar print p2.pvar print "\n" c1a.pvar = "newpvar1" print c1a.pvar print c1b.pvar print c1c.pvar print c2a.pvar print c2b.pvar print c2c.pvar print p1.pvar print p2.pvar print "\n" c2c.pvar = "newpvar2" print c1a.pvar print c1b.pvar print c1c.pvar print c2a.pvar print c2b.pvar print c2c.pvar print p1.pvar print p2.pvar 

with exit

 3077745184 3077745184 3077745184 3074414912 3074414912 3074414912 3077745184 3074414912 144028416 144028448 144028480 144028512 144028544 144028576 testing c1a c1b c1c c2a c2b c2c c1anewname c1b c1c c2a c2bnewname c2c pvar 1 1 1 2 2 2 1 2 newpvar1 newpvar1 newpvar1 2 2 2 newpvar1 2 newpvar1 newpvar1 newpvar1 newpvar2 newpvar2 newpvar2 newpvar1 newpvar2 

Does anyone know why this is so? I probably don't understand the internal way that python works with this __dict__ so well ...

Answer 1

It should work so that the parent contains several variables and whenever I access the corresponding variables from the child, I will actually refer to the variable that represents the parent. That is, if I changed it for one child, it will be changed also for all other children, and the data will be stored only once in memory (and will not be copied for each child ...)

This is not inheritance.

This is a completely different concept.

Your “shared variables” are just objects that can be mutated and have references in other objects. Nothing interesting.

Inheritance is completely different from this.

Answer 2

I think your workaround is doable; You can use properties to facilitate access to P attributes:

 class P(object): def __init__(self,name='default',pvar=1): self.pname = name self.pvar=pvar class C(object): def __init__(self,name,pobject=P()): #<-- The same default `P()` is # used for all instances of `C`, # unless pobject is explicitly defined. self.cname = name self.pobject=pobject @property def pvar(self): return self.pobject.pvar @pvar.setter def pvar(self,val): self.pobject.pvar=val c1=C('1') c2=C('2') 

c1 and c2 use the same pobject :

 print(c1.pvar) # 1 c1.pvar=2 

Note that changing pvar to c1 changes c2.pvar :

 print(c2.pvar) # 2 

c3 has another pobject :

 c3=C('3',P()) print(c3.pvar) # 1 

---

Regarding OOP design for a psychology experiment (mentioned in comments):

 import Image class Picture(object): def __init__(self,filename): self.filename = filename self.image=Image.open(filename) class Person(object): def __init__(self,name): self.name=name # other vital statistics associated with people as individuals here class Trial(object): # A trial is composed of one person, one picture, and the places they look def __init__(self,person,picture,locations): self.person=person self.picture=picture self.locations = locations # put methods for analyzing where the person looked here 

A Picture , of course, is not Person , and vice versa. And the same goes for Trial s. Therefore, none of these classes should inherit from each other.

Each of these classes has an open (and possibly private) interface. Public methods and attributes should be freely accessible from other classes. Therefore, given an instance of Trial , t , the image should be accessible through t.picture.image . As long as you only get access to public attributes and methods, everything should be fine.

For convenience, you can use properties to bind attributes to component attributes. For instance:

 class Trial(object): ... @property def image(self): return self.picture.image 

But in order to reduce this, by making, say, a Trial subclass of Picture , it will contradict the fundamental principles of OOP design.

Answer 3

The other answer is right, your question is more about namespaces and references than about inheritance.

All variables in Python are references, and all instances of objects are a namespace. So you can do:

 class C(): def __init__(self, x): self.x = x class Shared(object): def __init__(self, value): self.value = value # instances: >>> shared1 = Shared(1) >>> shared2 = Shared(2) >>> c1 = C(shared1) >>> c2 = C(shared1) >>> c3 = C(shared2) >>> c4 = C(shared2) # c1 and c2 sharing a reference to shared1 >>> c1.x.value 1 >>> c2.x.value 1 # change c2.x will reflect on c1 >>> c2.x.value = 3 >>> c1.x.value 3 # but not on c3, because shared1 and shared2 are distinct namespaces >>> c3.x.value 2 

UPDATE:

But be careful, it's easy to make a mistake:

 >>> c4.x = 4 >>> c3.x.value 2 >>> c4.x.value Traceback (most recent call last): File "<interactive input>", line 1, in <module> AttributeError: 'int' object has no attribute 'value' >>> 

I think that state of the art will use properties to hide __shared_instance in a private instance variable, so you can use c1.x instead of c1.x.value and avoid typos, as in the example above.

Answer 4

I get lost in all of these diverse answers.

But I think that what you need is expressed in the following code:

 class P: pvar=1 # <--- class attribute def __init__(self,name): self.cname = name class C(P): def __init__(self,name): self.cname = name c1=C('1') c2=C('2') print print "C.pvar ==",C.pvar,' id(C.pvar) ==',id(C.pvar) print "c1.pvar==",c1.pvar,' id(c1.pvar)==',id(c1.pvar) print "c2.pvar==",c2.pvar,' id(c2.pvar)==',id(c2.pvar) print C.pvar = [1,2] print "instruction C.pvar = [1,2] executed" print "C.pvar ==",C.pvar,' id(C.pvar) ==',id(C.pvar) print "c1.pvar==",c1.pvar,' id(c1.pvar)==',id(c1.pvar) print "c2.pvar==",c2.pvar,' id(c2.pvar)==',id(c2.pvar) print c2.__class__.pvar = 'sun' print "instruction c2.__class__.pvar = 'sun' executed" print "C.pvar ==",C.pvar,' id(C.pvar) ==',id(C.pvar) print "c1.pvar==",c1.pvar,' id(c1.pvar)==',id(c1.pvar) print "c2.pvar==",c2.pvar,' id(c2.pvar)==',id(c2.pvar) print c2.pvar = 145 print "instruction c2.pvar = 145 executed" print "C.pvar ==",C.pvar,' id(C.pvar) ==',id(C.pvar) print "c1.pvar==",c1.pvar,' id(c1.pvar)==',id(c1.pvar) print "c2.pvar==",c2.pvar,' id(c2.pvar)==',id(c2.pvar) 

result

 C.pvar == 1 id(C.pvar) == 10021768 c1.pvar== 1 id(c1.pvar)== 10021768 c2.pvar== 1 id(c2.pvar)== 10021768 instruction C.pvar = [1,2] executed C.pvar == [1, 2] id(C.pvar) == 18729640 c1.pvar== [1, 2] id(c1.pvar)== 18729640 c2.pvar== [1, 2] id(c2.pvar)== 18729640 instruction c2.__class__.pvar = 'sun' executed C.pvar == sun id(C.pvar) == 18579136 c1.pvar== sun id(c1.pvar)== 18579136 c2.pvar== sun id(c2.pvar)== 18579136 instruction c2.pvar = 145 executed C.pvar == sun id(C.pvar) == 18579136 c1.pvar== sun id(c1.pvar)== 18579136 c2.pvar== 145 id(c2.pvar)== 10022024 

I mean, what you need to know is that for a change through an instruction, the direct name of the instance (and not through a change that only means the name of the parent class) is an attribute of the pvar class, while it is still used by everyone P instances, you should write

 c2.__class__.pvar = something 

but not

 c2.pvar =something 

Note that C is a class that effectively inherits from the parent class P

Answer 5

One thing you should know as a basis for understanding the functions of classes and instances:

An instance of a class has a namespace implemented as a dictionary, which is the first place in which the attribute searches for links .

If the attribute is not found, and the instance class has an attribute by that name, the search continues with the class attributes.

http://docs.python.org/reference/datamodel.html#the-standard-type-hierarchy

In the second sentence, I do not quite understand the meaning of "using this name", but I understand the global nature of the fact that the attribute is searched first in the instance namespace, and then in the namespace of its type.

In the following code:

• For class P and instance c :

the name 'dataclass' and the dataclass object really belong to the class namespace P and only APPARENTLY belongs to the instance namespace c : when c.dataclass is c.dataclass , which is in fact the c.__class__.dataclass , which is achieved during the search described above.

• But in the cc instance for the PP class, the name 'data' belonging to the class namespace P is assigned (linked) by definition, which takes place in __init__() to the new data object created in the instance namespace c .

Therefore, the only solution to get the value of the data class is to call it using its real link, either PP.data or cc.__class__.data .

 class P: dataclass = "shareddata" def __init__(self,newdata): self.data = newdata def printname(self): print self.name c = P(1) print 'P.__dict__.keys()==',P.__dict__.keys() print 'c.__dict__.keys()==',c.__dict__.keys() print print 'c.data==',c.data print 'c.dataclass==',c.dataclass print class PP: data = "shareddata" def __init__(self,newdata): self.data = newdata def printname(self): print self.name cc = PP(2) print 'PP.__dict__.keys()==',PP.__dict__.keys() print 'cc.__dict__.keys()==',cc.__dict__.keys() print print 'cc.data==',cc.data print 'PP.data==',PP.data print 'cc.__class__.data==',cc.__class__.data 

result

 P.__dict__.keys()== ['dataclass', '__module__', 'printname', '__init__', '__doc__'] c.__dict__.keys()== ['data'] c.data== 1 c.dataclass== shareddata PP.__dict__.keys()== ['__module__', 'data', 'printname', '__init__', '__doc__'] cc.__dict__.keys()== ['data'] cc.data== 2 PP.data== shareddata cc.__class__.data== shareddata 

.

Note:

DIR ([object])

With an argument, try to return a list of valid attributes for this object.

If the object does not provide dir (), the function tries its best to collect information from dict objects, if from an object of its type.

The dir () mechanism, by default, behaves differently with different types of objects, since it tries to create the most relevant, but not complete, information:

• If the object is a type or class of an object, the list contains the names of its attributes and recursively the attributes of its bases.

• Otherwise, the list contains the names of the attributes of the objects, the names of the attributes of its classes and recursively the attributes of its class classes.

http://docs.python.org/library/functions.html#dir

.

Therefore, using dir(ob) to display the attributes of an ob object is a trap because it displays more attributes than those that belong strictly to the object.

In other words, __ dict __ is the real thing, and dir () gives in a sense a control panel.

Answer 6

r6d9, please, when you write the update, you must put the date and time with the word UPDATE. He begins to assimilate to follow all that

.

.

Regarding this code:

 def replaceinstance(parent,child): for item in parent.__dict__.items(): child.__dict__.__setitem__(item[0],item[1]) print item class P(object): def __init__(self,pvar): self.pvar = pvar def printname(self): print self.name class C(P): def __init__(self,name,pobject): P.__init__(self,None) replaceinstance(pobject,self) self.name = name 

it can be replaced by the following:

 class P(object): def __init__(self,pvar): self.pvar = pvar def printname(self): print self.name class C(P): def __init__(self,name,pobject): P.__init__(self,None) self.pvar = pobject.pvar self.name = name 

but it seems simple

Answer 7

Finally, I found a way to do this.

The key point is to refuse to receive instances of c with the real pvar field, because this is not possible:

Since this is the same _init _ () function (which is located in the P class) that processes pvar objects, it is not possible to create pvar in examples c , which points to pvar in instance p to reflect its value, and this will also make it possible to change this is the value of p pvar every time the value of c pvar changes. This makes too many conflicting conditions for verification.

Therefore, since c instances cannot have a real pvar field, it is best to configure the mechanism that controls the creation (with _setattr_ ) and access _getattr _ ) of these c pvar objects to create the illusion that they exist.

 class P(object): def __init__(self,pvar_arg,foo="^^^ "): self.pvar = pvar_arg self.cat = foo def printname(self): print self.name class C(P): def __init__(self,name,pobject,foo=''): self.__dict__['name'] = name P.__init__(self,None,pobject.cat+foo) C.dic[name] = pobject def __setattr__(self,xn,val): if xn!='pvar': self.__dict__[xn] = val elif self.name in C.dic: # During the creation of an instance c, # this condition is False because the instruction # C.dic[name] = pobject is written after # P.__init__(self,None,pobject.cat+foo). # Hence the value of pobject.pvar is preserved, # not changed with the value val being None # due to P.__init__(self,None,pobject.cat+foo) # that provokes self.pvar = pvar_arg and # consequently a call __setattr__(self,'pvar',None) C.dic[self.name].pvar = val def __getattribute__(self,xn): if xn=='pvar': return object.__getattribute__(C.dic[self.name],'pvar') else: return object.__getattribute__(self,xn) dic = {} p1 = P("1") p2 = P("2","QZX ") print '--- p1 = P("1") and p2 = P("2","QZX ") executed ---' print "p1.__dict__ ==",p1.__dict__ print "p2.__dict__ ==",p2.__dict__ print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar c1a = C("c1a",p1,'sea') c1b = C("c1b",p1,'mountain') c1c = C("c1c",p1,'desert') c2a = C("c2a",p2,'banana') c2b = C("c2b",p2) c2c = C("c2c",p2,'pear') print '\n--- creations of c1a, c1b, c1c, c2a, c2b, c2c executed ---' print "p1.__dict__ ==",p1.__dict__ print "p2.__dict__ ==",p2.__dict__ print "c1a.__dict__ ==",c1a.__dict__ print "c1b.__dict__ ==",c1b.__dict__ print "c1c.__dict__ ==",c1c.__dict__ print "c2a.__dict__ ==",c2a.__dict__ print "c2b.__dict__ ==",c2b.__dict__ print "c2c.__dict__ ==",c2c.__dict__ print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar, c1b.pvar, c1c.pvar)==',(c1a.pvar,c1b.pvar,c1c.pvar) print '(c2a.pvar, c2b.pvar, c2c.pvar)==',(c2a.pvar,c2b.pvar,c2c.pvar) c1a.pvar = "newpvar1" print '\n--- c1a.pvar = "newpvar1" executed ---' print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar, c1b.pvar, c1c.pvar)==',(c1a.pvar,c1b.pvar,c1c.pvar) print '(c2a.pvar, c2b.pvar, c2c.pvar)==',(c2a.pvar,c2b.pvar,c2c.pvar) c2c.pvar = 45789 print '\n--- c2c.pvar = 45789 executed ---' print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar, c1b.pvar, c1c.pvar)==',(c1a.pvar,c1b.pvar,c1c.pvar) print '(c2a.pvar, c2b.pvar, c2c.pvar)==',(c2a.pvar,c2b.pvar,c2c.pvar) 

result

 --- p1 = P("1") and p2 = P("2","QZX ") executed --- p1.__dict__ == {'cat': '^^^ ', 'pvar': '1'} p2.__dict__ == {'cat': 'QZX ', 'pvar': '2'} p1.pvar== 1 p2.pvar== 2 --- creations of c1a, c1b, c1c, c2a, c2b, c2c executed --- p1.__dict__ == {'cat': '^^^ ', 'pvar': '1'} p2.__dict__ == {'cat': 'QZX ', 'pvar': '2'} c1a.__dict__ == {'name': 'c1a', 'cat': '^^^ sea'} c1b.__dict__ == {'name': 'c1b', 'cat': '^^^ mountain'} c1c.__dict__ == {'name': 'c1c', 'cat': '^^^ desert'} c2a.__dict__ == {'name': 'c2a', 'cat': 'QZX banana'} c2b.__dict__ == {'name': 'c2b', 'cat': 'QZX '} c2c.__dict__ == {'name': 'c2c', 'cat': 'QZX pear'} p1.pvar== 1 p2.pvar== 2 (c1a.pvar, c1b.pvar, c1c.pvar)== ('1', '1', '1') (c2a.pvar, c2b.pvar, c2c.pvar)== ('2', '2', '2') --- c1a.pvar = "newpvar1" executed --- p1.pvar== newpvar1 p2.pvar== 2 (c1a.pvar, c1b.pvar, c1c.pvar)== ('newpvar1', 'newpvar1', 'newpvar1') (c2a.pvar, c2b.pvar, c2c.pvar)== ('2', '2', '2') --- c2c.pvar = 45789 executed --- p1.pvar== newpvar1 p2.pvar== 45789 (c1a.pvar, c1b.pvar, c1c.pvar)== ('newpvar1', 'newpvar1', 'newpvar1') (c2a.pvar, c2b.pvar, c2c.pvar)== (45789, 45789, 45789) 

Notes:

• the name attribute must be specified before the statement

  P. INIT (itself, None, pobject.cat + Foo)

  since the execution of this command causes

  __setattr__(self,'pvar',"1") , which executes the command

  C.dic[self.name].pvar = "1" when

  c1a = C("c1a",p1,'sea') is executed, for example.

  This call requires self.name as the key for dic.

• I entered foo and cat in

  justifies the need to write instructions

  P. INIT (itself, None, pobject.cat + Foo)

  otherwise, since pvar is actually defined in instances of c , this would not be useful.

• , __setattr__ : . , pvar p C.dic[self.name].pvar = None . , elif self.name in C.dic:

  , C.dic[name] = pobject P.__init__(self,None,pobject.cat+foo)

.

EDIT 1

,

 def __setattr__(self,xn,val): if xn=='pvar': self.__class__.dic[self.name].pvar = val 

than

 def __setattr__(self,xn,val): if xn=='pvar': C.dic[self.name].pvar = val 

self C ( '_ class _' ) self.

( 'C' ) , P C .

, . '_ class _' , . 'C' - , P C .. p >

id()

.

.

2

dic : , C , C . , dic .

 class P(object): def __init__(self,pvar,foo="^^^ "): self.pvar = pvar self.cat = foo def printname(self): print self.name class C(P): def __init__(self,name,pobject,foo=''): self.__dict__['name'] = name P.__init__(self,None,pobject.cat+foo) dic[name] = pobject def __setattr__(self,xn,val): if xn!='pvar': self.__dict__[xn] = val elif self.name in dic: # During the creation of an instance c, # this condition is False because the instruction # dic[name] = pobject is written after # P.__init__(self,None,pobject.cat+foo). # Hence the value of pobject.pvar is preserved, # not changed with the value val being None # due to P.__init__(self,None,pobject.cat+foo) # that provokes self.pvar = pvar_arg and # consequently a call __setattr__(self,'pvar',None) dic[self.name].pvar = val def __getattribute__(self,xn): if xn=='pvar': return object.__getattribute__(dic[self.name],'pvar') else: return object.__getattribute__(self,xn) dic = {} 

, dic OOish .

.

.

3

, : pvar c __setattr__ __getattribute__ , , dic , .

 class P(object): def __init__(self,pvar,foo="^^^ "): self.pvar = pvar self.cat = foo def printname(self): print self.name class C(P): def __init__(self,name,pobject,foo=''): P.__init__(self,None,pobject.cat+foo) self.__dict__['name'] = name del self.pvar self.pvar(pobject) def pvar(self,x = None,dic = {}): if x.__class__==P: # a pobject dic[self.name] = x elif x: # a value dic[self.name].pvar = x else: # to return value return dic[self.name].pvar p1 = P("1") p2 = P("2","QZX ") print '--- p1 = P("1") and p2 = P("2","QZX ") executed ---' print "p1.__dict__ ==",p1.__dict__ print "p2.__dict__ ==",p2.__dict__ print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar c1a = C("c1a",p1,'sea') c1b = C("c1b",p1,'mountain') c1c = C("c1c",p1,'desert') c2a = C("c2a",p2,'banana') c2b = C("c2b",p2) c2c = C("c2c",p2,'pear') print '\n--- creations of c1a, c1b, c1c, c2a, c2b, c2c executed ---' print "p1.__dict__ ==",p1.__dict__ print "p2.__dict__ ==",p2.__dict__ print "c1a.__dict__ ==",c1a.__dict__ print "c1b.__dict__ ==",c1b.__dict__ print "c1c.__dict__ ==",c1c.__dict__ print "c2a.__dict__ ==",c2a.__dict__ print "c2b.__dict__ ==",c2b.__dict__ print "c2c.__dict__ ==",c2c.__dict__ print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar(),c1b.pvar(),c1c.pvar())==',(c1a.pvar(),c1b.pvar(),c1c.pvar()) print '(c2a.pvar(),c2b.pvar(),c2c.pvar())==',(c2a.pvar(),c2b.pvar(),c2c.pvar()) c1a.pvar("newpvar1") print '\n--- c1a.pvar("newpvar1") executed ---' print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar(),c1b.pvar(),c1c.pvar())==',(c1a.pvar(),c1b.pvar(),c1c.pvar()) print '(c2a.pvar(),c2b.pvar(),c2c.pvar())==',(c2a.pvar(),c2b.pvar(),c2c.pvar()) c2c.pvar(45789) print '\n--- c2c.pvar(45789) ---' print 'p1.pvar==',p1.pvar print 'p2.pvar==',p2.pvar print '(c1a.pvar(),c1b.pvar(),c1c.pvar())==',(c1a.pvar(),c1b.pvar(),c1c.pvar()) print '(c2a.pvar(),c2b.pvar(),c2c.pvar())==',(c2a.pvar(),c2b.pvar(),c2c.pvar()) 

, c.pvar() :

 --- p1 = P("1") and p2 = P("2","QZX ") executed --- p1.__dict__ == {'cat': '^^^ ', 'pvar': '1'} p2.__dict__ == {'cat': 'QZX ', 'pvar': '2'} p1.pvar== 1 p2.pvar== 2 --- creations of c1a, c1b, c1c, c2a, c2b, c2c executed --- p1.__dict__ == {'cat': '^^^ ', 'pvar': '1'} p2.__dict__ == {'cat': 'QZX ', 'pvar': '2'} c1a.__dict__ == {'cat': '^^^ sea', 'name': 'c1a'} c1b.__dict__ == {'cat': '^^^ mountain', 'name': 'c1b'} c1c.__dict__ == {'cat': '^^^ desert', 'name': 'c1c'} c2a.__dict__ == {'cat': 'QZX banana', 'name': 'c2a'} c2b.__dict__ == {'cat': 'QZX ', 'name': 'c2b'} c2c.__dict__ == {'cat': 'QZX pear', 'name': 'c2c'} p1.pvar== 1 p2.pvar== 2 (c1a.pvar(),c1b.pvar(),c1c.pvar())== ('1', '1', '1') (c2a.pvar(),c2b.pvar(),c2c.pvar())== ('2', '2', '2') --- c1a.pvar("newpvar1") executed --- p1.pvar== newpvar1 p2.pvar== 2 (c1a.pvar(),c1b.pvar(),c1c.pvar())== ('newpvar1', 'newpvar1', 'newpvar1') (c2a.pvar(),c2b.pvar(),c2c.pvar())== ('2', '2', '2') --- c2c.pvar(45789) --- p1.pvar== newpvar1 p2.pvar== 45789 (c1a.pvar(),c1b.pvar(),c1c.pvar())== ('newpvar1', 'newpvar1', 'newpvar1') (c2a.pvar(),c2b.pvar(),c2c.pvar())== (45789, 45789, 45789) 

, P C ", pobject c.pvar() .

Answer 8

, , :

OOP Python, , ?

-, dicts: child-dict, , dicts dicts. , .

The solution is to tell python to search for the attribute in the right place using some Python magic ...

 class ProxyMixin (object): def __init__(self, parent): self.parent = parent def __getattribute__(self, name): if name != 'parent' and hasattr(self.parent, name): return getattr(self.parent, name) else: return object.__getattribute__(self, name) def __setattr__(self, name, val): if name != 'parent' and hasattr(self.parent, name): setattr(self.parent, name) else: object.__setattr__(self, name, val) 

(see python link for accessing attributes )

Just add ProxyMixin to your child class and everything will be fine.

 class P: data = "shared data" def __init__(self, name): self.name = name def printname(self): print self.name class C(P, ProxyMixin): def __init__(self, parent=None): if parent: ProxyMixin.__init__(self, parent) 

Now you can dynamically reinstall the parent at any time with a simple assignment:

 c.parent = newparent