Here is the scenario:
I have two classes:
class A:
pass:
class B:
pass
Now I want to create a client, in that I need to have a small utility method, which should return my class template/object e.g: class A, class B, as I pass on the class name to that utility e.g get_obj(classA).
Now, is this possible? If then please suggest an approach, as I don't get any correct answer as of now in web.
Hope I am making sense.
Here is a possible implementation. All the code is contained in a single '.py' file
class A:
pass
class B:
pass
# map class name to class
_classes = {
A.__name__: A,
B.__name__: B,
}
def get_obj(cname):
return _classes[cname]()
# test the function
if __name__ == '__main__':
print get_obj('A')
It will produce the following output
<__main__.A instance at 0x1026ea950>
Standard library function namedtuple creates and returns a class. Internally it uses exec. It may be an inspiration for what you need.
Source code: https://github.com/python/cpython/blob/master/Lib/collections/init.py#L356
exec for this kind of thing.
globals() returns a dictionary containing all symbols defined in the global scope of the module (including classes A and B):
a_and_b_module.py
class A: pass
class B: pass
def get_cls(cls_name):
return globals()[cls_name]
If you are looking for simplicity
If the code that will call this function is inside the module, then you can eliminate the function altogether and use globals()[cls_name] directly.
If the code that will call this function is outside the module, then you could use getattr function:
a_and_b_module.py
class A: pass
class B: pass
another_file.py
import a_and_b_module
cls_name = 'A'
chosen_cls = getattr(a_and_b_module, cls_name)
If you are looking for complete control
The problem with the approach above is that it could return anything defined in a_and_b_module.py, not restricting itself to A and B. If you want to make sure only A and B can be returned:
class A: pass
class B: pass
allowed_classes = ('A', 'B')
def get_cls(cls_name):
assert cls_name in allowed_classes
return globals()[cls_name]
Note: you might also be interested in the concept of factory.
dictlikecls = {'classA': A, 'classB': B}, and then you can callcls.get('classA')for yourget_objimplementation. This is a start though, but without much more details on what you are actually wanting to do the actual answer can be quite different.