It's a bad design to try to print classes' variable name and not value (eg. x.name print &-CodePudding

The

CodePudding user response：

Once you have an instance of MyClass / MyClass2, you can call vars() or vars().keys() and it will give you the attributes as a str. Unlike dir, it will not show all the builtin attributes/methods starting with __.

class MyClass2: def __init__(self,param3=3,param4=4): self.param3=param3 self.param4=param4 instance_of_myclass2 = MyClass2(param3="what", param4="ever") print(vars(instance_of_myclass2)) {'param3': 'what', 'param4': 'ever'} print(vars(instance_of_myclass2).keys()) dict_keys(['param3', 'param4']) dir(instance_of_myclass2) ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'param3', 'param4']

CodePudding user response：

If you use dataclasses, getting the field names is pretty straightforward:

from dataclasses import dataclass, fields @dataclass class MyClass1: first:int = 4

>>> fields(MyClass1) (Field(name='first',type=<class 'int'>,default=4,...),)

This way, you can iterate over the class fields and ask your user to fill them. Note the field has a type, which you could use to eg ask the user for several values, as in your example.

You could add functions to extract programatically the param names (_show_inputs below ) from the class and values from instances (_json below ):

def blossom(cls): """decorate a class with `_json` (classmethod) and `_show_inputs` (bound)""" def _json(self): return json.dumps(self, cls=DataClassEncoder) def _show_inputs(cls): return { field.name: field.type.__name__ for field in fields(cls) } cls._json = _json cls._show_inputs = classmethod(_show_inputs) return cls

NOTE 1: There's actually no need to decorate the classes with blossom. You could just use its internal functions programatically.

Using a custom json encoder to dump the dataclass objects, including properties:

import json class DataClassPropEncoder(json.JSONEncoder): # https://stackoverflow.com/a/51286749/7814595 def default(self, o): if is_dataclass(o): cls = type(o) # inject instance properties props = { name: getattr(o, name) for name, value in cls.__dict__.items() if isinstance(value, property) } return { **props, **asdict(o) } return super().default(o)

Finally, wrap the computations inside properties so they are serialized as well when using the decorated class. Full code example:

from dataclasses import asdict from dataclasses import dataclass from dataclasses import fields from dataclasses import is_dataclass import json from itertools import product from typing import List class DataClassPropEncoder(json.JSONEncoder): # https://stackoverflow.com/a/51286749/7814595 def default(self, o): if is_dataclass(o): cls = type(o) props = { name: getattr(o, name) for name, value in cls.__dict__.items() if isinstance(value, property) } return { **props, **asdict(o) } return super().default(o) def blossom(cls): def _json(self): return json.dumps(self, cls=DataClassEncoder) def _show_inputs(cls): return { field.name: field.type.__name__ for field in fields(cls) } cls._json = _json cls._show_inputs = classmethod(_show_inputs) return cls @blossom @dataclass class MyClass1: param1:int param2:int @blossom @dataclass class MyClass2: param3: List[str] param4: List[int] def _compute_single(self, values): # TODO: implmement this return values[0]*values[1] @property def combinations(self): # TODO: cache if used more than once # TODO: combinations might explode field_names = [] field_values = [] cls = type(self) for field in fields(cls): field_names.append(field.name) field_values.append(getattr(self, field.name)) results = [] for values in product(*field_values): result = { **{ field_names[idx]: value for idx, value in enumerate(values) }, "output": self._compute_single(values) } results.append(result) return results

>>> print(f"MyClass1:\n{MyClass1._show_inputs()}") MyClass1: {'param1': 'int', 'param2': 'int'} >>> print(f"MyClass2:\n{MyClass2._show_inputs()}") MyClass2: {'param3': 'List', 'param4': 'List'} >>> obj_1 = MyClass1(3,4) >>> print(f"obj_1:\n{obj_1._json()}") obj_1: {"param1": 3, "param2": 4} >>> obj_2 = MyClass2(["first", "second"],[4,2])._json() >>> print(f"obj_2:\n{obj_2._json()}") obj_2: {"combinations": [{"param3": "first", "param4": 4, "output": "firstfirstfirstfirst"}, {"param3": "first", "param4": 2, "output": "firstfirst"}, {"param3": "second", "param4": 4, "output": "secondsecondsecondsecond"}, {"param3": "second", "param4": 2, "output": "secondsecond"}], "param3": ["first", "second"], "param4": [4, 2]}

NOTE 2: If you need to perform several computations per class, it might be a good idea to abstract away the pattern in the combinations property to avoid repeating code.

NOTE 3: If you need access to the properties several times and not ust once, you might want to consider caching their values to avoid re-computation.