How do you get a list of all variables in a class thats iteratable? Kind of like locals(), but for a class
class Example(object):
bool143 = True
bool2 = True
blah = False
foo = True
foobar2000 = False
def as_list(self)
ret = []
for field in XXX:
if getattr(self, field):
ret.append(field)
return ",".join(ret)
this should return
>>> e = Example()
>>> e.as_list()
bool143, bool2, foo
dir(obj)
gives you all attributes of the object. You need to filter out the members from methods etc yourself:
class Example(object):
bool143 = True
bool2 = True
blah = False
foo = True
foobar2000 = False
example = Example()
members = [attr for attr in dir(example) if not callable(getattr(example, attr)) and not attr.startswith("__")]
print members
Will give you:
['blah', 'bool143', 'bool2', 'foo', 'foobar2000']
callable(attr) work? Isn't attr a string?
vars(Example).items() or vars(instance.__class__).items() instead of dir() if you want to check if its callable or not because dir will only return 'strings as names..If you want only the variables (without functions) use:
vars(your_object)
vars does not include the class variables, only the instance variables.
members = list(vars(example).keys()) as (at least in python3) vars returns a dict mapping the name of the member variable to it's value.@truppo: your answer is almost correct, but callable will always return false since you're just passing in a string. You need something like the following:
[attr for attr in dir(obj()) if not callable(getattr(obj(),attr)) and not attr.startswith("__")]
which will filter out functions
>>> a = Example()
>>> dir(a)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__',
'__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__', 'bool143', 'bool2', 'blah',
'foo', 'foobar2000', 'as_list']
—as you see, that gives you all attributes, so you'll have to filter out a little bit. But basically, dir() is what you're looking for.
Similar to vars(), one can use the below code to list all class attributes. It is equivalent to vars(example).keys().
example.__dict__.keys()
Inspired by https://stackoverflow.com/a/13286863/14298786
class CONSTANT:
a = 4
b = 5
def display() -> None:
print("Hello!")
print(vars(CONSTANT))
# {'__module__': '__main__', 'a': 4, 'b': 5, 'display': <function CONSTANT.display at 0x1030bcb80>, '__dict__': <attribute '__dict__' of 'CONSTANT' objects>, '__weakref__': <attribute '__weakref__' of 'CONSTANT' objects>, '__doc__': None}
print(
[k for k, v in vars(CONSTANT).items() if not callable(v) and not k.startswith("__")]
)
# ['a', 'b']
print(
{
k: v
for k, v in vars(CONSTANT).items()
if not callable(v) and not k.startswith("__")
}
)
# {'a': 4, 'b': 5}
def get_class_variables(cls: type) -> set[str]:
"""Return set of class variables."""
# Get class attributes
attributes = vars(cls)
# Filter out methods, nested classes and dunder (__) attributes
return {
key for key, value in attributes.items()
if not callable(value) and not key.startswith("__")
}
Example of how to use this function:
class Person:
first_name: str = "Joseph"
last_name: str = "ben-Yaakov"
# Then you can do this:
person_class_variables = get_class_variables(Person)
# or even this:
frodo = Person(first_name="Frodo", last_name="Baggins")
frodo_attributes = get_class_variables(frodo)
person_class_variables and frodo_attributes will both be the same:
{"first_name", "last_name"}
row2dict = lambda r: {c.name: str(getattr(r, c.name)) for c in r.__table__.columns} if r else {}
Use this.
ClassName.__dict__["__doc__"]
This will filter out functions, in-built variables etc. and give you just the fields that you need!
The easy way to do this is to save all instances of the class in a list.
a = Example()
b = Example()
all_examples = [ a, b ]
Objects don't spring into existence spontaneously. Some part of your program created them for a reason. The creation is done for a reason. Collecting them in a list can also be done for a reason.
If you use a factory, you can do this.
class ExampleFactory( object ):
def __init__( self ):
self.all_examples= []
def __call__( self, *args, **kw ):
e = Example( *args, **kw )
self.all_examples.append( e )
return e
def all( self ):
return all_examples
makeExample= ExampleFactory()
a = makeExample()
b = makeExample()
for i in makeExample.all():
print i
ClassName.__dict__["__doc__"] This will filter out functions, in-built variables etc. and give you just the fields that you need!
for field in [ self.bool143, self.bool2, self.blah, self.foo, self.foobar2000 ]? How does it happen that you don't know the instance variables of the class?