Communication between class in Python

Communication between class in Python - python

I can call a class from another class but not vice versa.
From class A (see below), I can call Method_B located in class B but from class B, I am not able to call Method_A1 or Method_A2 located in class A.
I got the following error:
NameError: name 'A' is not defined
Here is my code:
test_1.py:
from test_2 import *
class A():
def __init__(self):
self.key = 1
self.call_Method_B = B().Method_B(self.key)
def Method_A1(self):
print("Method_A1: ok")
def Method_A2(self):
print("Method_A2: ok")
if __name__ == '__main__':
start_A = A()
test_2.py:
class B():
def Method_B(self,key):
self.key = key
if self.key ==1:
self.call_Method_A1 = A().Method_A1()
else:
self.call_Method_A2 = A().Method_A2()

To communicate between scripts you need to import test_1 as a module:
from test_1 import *
and change the way you call A to like this:
if self.key ==1:
self.call_Method_A1 = A.Method_A1(self)
else:
self.call_Method_A2 = A.Method_A2(self)

You can pass class A as an argument when calling Method_B
test_1.py:
from test_2 import *
class A():
def __init__(self):
self.key = 1
self.call_Method_B = B().Method_B(self.key, A)
...
test_2.py:
class B():
def Method_B(self, key, A):
...
A more conventional way of showing this would be:
# test_1.py
from test_2 import B
class A():
def __init__(self):
self.key = 1
self.b = B(self)
self.b.method_b(self.key)
#staticmethod
def method_a1():
print("Method_A1: ok")
#staticmethod
def method_a2():
print("Method_A2: ok")
if __name__ == '__main__':
start_a = A()
# test_2.py
class B():
def __init__(self, instance_of_a):
self.a = instance_of_a
def method_b(self, key):
self.key = key
if self.key == 1:
self.a.method_a1()
else:
self.a.method_a2()

You have a loop in your imports. Try adding an import like this:
class B():
def Method_B(self,key):
from test_1 import A
....
This will then only import A from test_1 after it is defined.

Related

Split python code with classes refering to each other into multiple files without circular import error

I would like to split this code
class A:
def __init__(self):
self.b = B(self)
#classmethod
def foo(cls):
pass
class B:
def __init__(self, a):
self.a = a
A.foo()
if __name__ == "__main__":
aa = A()
bb = B(aa)
in two separated files
classA.py
from classB import B
class A:
def __init__(self):
self.b = B(self)
#classmethod
def foo(cls):
pass
and classB.py
from classA import A
class B:
def __init__(self, a):
self.a = a
A.foo()
if __name__ == "__main__":
aa = A()
bb = B(aa)
But this leads to an ImportError:
ImportError: cannot import name 'A' from partially initialized module 'classA' (most likely due to a circular import)
If one instead uses
classA.py
import classB
class A:
def __init__(self):
self.b = classB.B(self)
#classmethod
def foo(cls):
pass
and classB.py
import classA
class B:
def __init__(self, a):
self.a = a
classA.A.foo()
if __name__ == "__main__":
aa = classA.A()
bb = B(aa)
everything is fine. But this second version needs some significant changes to the code. Is there a way to split the content of two python classes referring to each other into two files, without the need to rename the methods?

Run a method in initialize after class has been called

I want the results of the method_test() to to be stored in variable a. So that I access it outside my class
class test:
def __init__(self):
a = method()
def method_test():
return "working"
check = test
print(check.a)

You need to set it as an attribute, which can be done with self.a:
class test:
def __init__(self):
self.a = test.method_test()
def method_test():
return "working"
check = test()
print(check.a)
#working

class test:
def __init__(self):
self.a = self.method_test()
def method_test(self):
return "working"
check = test()
print (check.a)

Python3 How to call to method from one class in other class

I have two classes A and B, I want to run a method from class A in class B. I wrote the code but it's not working, I am getting the following error:
AttributeError: 'B' object has no attribute 'testPrint'
My classes:
class A:
def __init__(self):
self.v = 'A'
def test_1(self):
i = 1
print('Function test_1 in class A: ')
x = self.testPrint(i) # i think error is here
return x
def testPrint(self, i):
return 'testPrint: '+i
class B:
def __init__(self):
self.v = 'B'
def b1(self):
print('wywolanie funkcji z klasy b')
f = A.test_1(self)
return f
Run the program
b = B()
b.b1()

You need to instanciate class A:
class A:
def __init__(self):
self.v = 'A'
def test_1(self):
i = 1
print('Function test_1 in class A: ')
x = self.testPrint(i) # i think error is here
return x
def testPrint(self, i):
return 'testPrint: %s' % i
class B:
def __init__(self):
self.v = 'B'
def b1(self):
print('wywolanie funkcji z klasy b')
f = A().test_1()
return f
b = B()
res = b.b1()
print (res)
Returns (Python3):
wywolanie funkcji z klasy b
Function test_1 in class A:
testPrint:1

Override and extend method defined in parent class in Python

I want to redefine the method Old.do(self) in New.do(self, x) so that it takes one argument as below:
#!/usr/bin/env python3
class Old(object):
def __init__(self):
self.a = 0
self.do()
def do(self):
print(self.a)
class New(Old):
def __init__(self):
Old.__init__(self)
b = 1
self.do(b)
def do(self, b):
print(self.a + b)
if __name__ == '__main__':
new = New()
I can do it with the name mangling:
#!/usr/bin/env python3
class Old(object):
def __init__(self):
self.a = 0
self.__do()
def do(self):
print(self.a)
__do = do
class New(Old):
def __init__(self):
Old.__init__(self)
b = 1
self.do(b)
def do(self, b):
print(self.a + b)
if __name__ == '__main__':
new = New()
or I can do it with an explicit reference to the base class:
#!/usr/bin/env python3
class Old(object):
def __init__(self):
self.a = 0
Old.do(self)
def do(self):
print(self.a)
class New(Old):
def __init__(self):
Old.__init__(self)
b = 1
self.do(b)
def do(self, b):
print(self.a + b)
if __name__ == '__main__':
new = New()
Is there any other way to get the same result? Can super() do this?
Thanks

You can do what you trying with super, like this:
class Old(object):
def __init__(self):
self.a = 1
Old.do(self, self.a)
def do(self, a):
print(a)
class New(Old):
def __init__(self):
super(New, self).__init__()
self.b = 2
self.do(self.b)
def do(self, b):
print(self.a + b)
new = New()
the first call will return 1, and the second call 3

Python : How to "merge" two class

I want to add some attributes and methods into various class. The methods and attributes that I have to add are the same but not the class to assign them, so I want to construct a class who assign new methods and attributes for a class given in argument.
I try this but it's not working:
(I know that is a very wrong way to try to assign something to self, it's just to show what I want to do)
class A:
def __init__(self):
self.a = 'a'
def getattA(self):
return self.a
class B:
def __init__(self, parent) :
self = parent
# This is working :
print self.getattA()
def getattB(self):
return self.getattA()
insta = A()
instb = B(insta)
# This is not working :
print instb.getattB()
The result is :
a
Traceback (most recent call last):
File "D:\Documents and settings\Bureau\merge.py", line 22, in <module>
print instb.getattB()
File "D:\Documents and settings\Bureau\merge.py", line 16, in getattB
return self.getattA()
AttributeError: B instance has no attribute 'getattA'
And I expected to got 'a' for the call of instb.gettattB()
To resume I want to inherit class B from class A giving class A in argument of class B because my class B will be a subclass of various class, not always A.

The Best answer is in the comments, it was useful for me so I decided to show it in an answer (thank to sr2222):
The way to dynamicaly declare inherance in Python is the type() built-in function.
For my example :
class A(object) :
def __init__(self, args):
self.a = 'a'
self.args = args
def getattA(self):
return self.a, self.args
class B(object) :
b = 'b'
def __init__(self, args) :
self.b_init = args
def getattB(self):
return self.b
C = type('C', (A,B), dict(c='c'))
instc = C('args')
print 'attributes :', instc.a, instc.args, instc.b, instc.c
print 'methodes :', instc.getattA(), instc.getattB()
print instc.b_init
The code return :
attributes : a args b c
methodes : ('a', 'args') b
Traceback (most recent call last):
File "D:\Documents and settings\Bureau\merge2.py", line 24, in <module>
print instc.b_init
AttributeError: 'C' object has no attribute 'b_init'
My class C inerhite attributes and methods of class A and class B and we add c attribute. With the instanciation of C (instc = C('args')) The init for A is call but not for B.
Very useful for me because I have to add some attributes and methodes (the same) on different class.

I was having trouble with calling different constructors, using super doesn't necessarily make sense in a case like this, I opted to inherit and call each constructor on the current object manually:
class Foo(object):
def __init__(self, foonum):
super(Foo, self).__init__()
self.foonum = foonum
class Bar(object):
def __init__(self, barnum):
super(Bar, self).__init__()
self.barnum = barnum
class DiamondProblem(Foo, Bar):
# Arg order don't matter, since we call the `__init__`'s ourself.
def __init__(self, barnum, mynum, foonum):
Foo.__init__(self, foonum)
Bar.__init__(self, barnum)
self.mynum = mynum

How about this?
class A:
def __init__(self):
self.a = 'a'
def getatt(self):
return self.a
class B:
def __init__(self, parent) :
self.parent = parent
def __getattr__(self, attr):
return getattr(self.parent, attr)
def getattB(self):
return self.parent.getatt()
insta = A()
instb = B(insta)
print instb.getattB()
print instb.getatt()
But method in class A can not access attr in class B.
Another way:
import functools
class A:
def __init__(self):
self.a = 'a'
def getatt(self):
return self.a
class B:
def __init__(self, parent):
for attr, val in parent.__dict__.iteritems():
if attr.startswith("__"): continue
self.__dict__[attr] = val
for attr, val in parent.__class__.__dict__.iteritems():
if attr.startswith("__"): continue
if not callable(val): continue
self.__dict__[attr] = functools.partial(val, self)
def getattB(self):
return self.getatt()
insta = A()
instb = B(insta)
print instb.__dict__
print instb.getattB()
print instb.getatt()
Slow with init but call fast.

Since B is not a subclass of A, there is no path in B to getatt() in A

I guess i have a easier method
class fruit1:
def __init__(self):
self.name = "apple"
self.color = "blue"
class fruit2:
def __init__(self):
self.name = "banana"
self.size = 100
def merge(ob1, ob2):
ob1.__dict__.update(ob2.__dict__)
return ob1
f1 = fruit1()
f2 = fruit2()
fruit = merge(f1, f2)
print("name:",fruit.name," color:",fruit.color, " size:",fruit.size)
#output: name: banana color: blue size: 100

I'm not certain what you are trying to do, but the code below is giving my the output I think you are expecting. notice:
a is initialized outside the constructor in A
B is declared as a subclass of A
Code:
class A:
a='' #Initialize a
def __init__(self):
self.a = 'a'
def getatt(self):
return self.a
class B(A): #Declare B as subclass
def __init__(self, parent) :
self = parent
print self.getatt()
def getattB(self):
return self.getatt()
insta = A()
instb = B(insta)
print instb.getattB()

Helper function below conducts the merge of the dataclass instances, the attributes orders is derived from *args order:
from dataclasses import dataclass
#dataclass
class A:
foo: str
bar: str
def merge_dataclasses(*args):
if len({e.__class__.__name__ for e in args}) > 1:
raise NotImplementedError('Merge of non-homogeneous entries no allowed.')
data = {}
for entry in args[::-1]:
data.update(vars(entry))
return entry.__class__(**data)
print(merge_dataclasses(A(foo='f', bar='bar'), A(foo='b_foo', bar='b_bar')))

One easy way to merge two or more classes is through the tool set dyndesign:
from dyndesign import mergeclasses
class Base:
def __init__(self, init_value):
self.param = init_value
def m1(self):
print(f"Method `m1` of class `Base`, and {self.param=}")
def m2(self):
print(f"Method `m2` of class `Base`")
class Ext:
def m1(self):
print(f"Method `m1` of class `Ext`, and {self.param=}")
MergedClass = mergeclasses(Base, Ext)
merged_instance = MergedClass("INITIAL VALUE")
merged_instance.m1()
# Method `m1` of class `Ext`, and self.param='INITIAL VALUE'
merged_instance.m2()
# Method `m2` of class `Base`

Emphasizing ThorSummoner's's answer and Hong's comment; this method appears to be cleaner than the excepted answer. Notice Hong's use of super().init(self) in all but the last object added to the merge class.
class Foo(object):
def __init__(self, foonum):
super(Foo, self).__init__(self)
self.foonum = foonum
class Bar(object):
def __init__(self, barnum):
super(Bar, self).__init__(self)
self.barnum = barnum
class Oops(object):
def __init__(self, oopsnum):
super(Oops, self).__init__()
self.oopsnum = oopsnum
class DiamondProblem(Foo, Bar, Oops):
def __init__(self, mynum, foonum, barnum, oopsnum):
Foo.__init__(self, foonum)
Bar.__init__(self, barnum)
Oops.__init__(self, oopsnum)
self.mynum = mynum
def main():
dia = DiamondProblem(1, 10, 20, 30)
print(f"mynum: {dia.mynum}")
print(f"foonum: {dia.foonum}")
print(f"barnum: {dia.barnum}")
print(f"oopsnum: {dia.oopsnum}")

Develop Reference

Python is a programming language that lets you work quickly and integrate systems more effectively.

Communication between class in Python - python

To communicate between scripts you need to import test_1 as a module: from test_1 import * and change the way you call A to like this: if self.key ==1: self.call_Method_A1 = A.Method_A1(self) else: self.call_Method_A2 = A.Method_A2(self)

You have a loop in your imports. Try adding an import like this: class B(): def Method_B(self,key): from test_1 import A .... This will then only import A from test_1 after it is defined.

Related

Split python code with classes refering to each other into multiple files without circular import error

Run a method in initialize after class has been called

Python3 How to call to method from one class in other class

Override and extend method defined in parent class in Python

Python : How to "merge" two class

Categories

Resources