Seeking a different way in using Reflection or Introspection in Python

Question

I'm refactoring some code, and I thought I could use a bit of Reflection! So, I have this for now:

def f(self, clazz):
    [...]
    boolean = False
    if hasattr(clazz_instace, 'some_attribute'):
        setattr(clazz_instace, 'some_attribute', True)
        boolean = True

    if boolean:
        result = getattr(clazz_instace, 'another_method')(None, request=request)
        return result['objects']

    sorted_objects = getattr(clazz_instace, 'One_more_method')(request)
    result = getattr(clazz_instace, 'another_method')(sorted_objects, request=request)

    return [...]

My question is about the strings I used to indicate which method I'm searching for regarding to the clazz_instance. I'd like to know if there's another and very best way to do what I did (In a dinamic way to be specific)? I mean, intead of putting method's name like strings directly as I did, would be really nice if I could verify dinamically those methods, differently.

Could you give some nice ideas? How would you do it?

Thanks in advance!!!

What exactly are you trying to do here? If the attribute names are all string literals, this is just a more complicated way of accessing them directly (possibly with `except NameError` in one of the cases). If they're not, where are they coming from? — abarnert, Nov 08 '13 at 21:37

score 1 · Accepted Answer · answered Nov 08 '13 at 21:28

An instance's method is nothing more than a function object stored in the instace's __dict__. This said, you are doing correct to find them, except that maybe, the class indeed has the attribute corresponding to your argument string, but is not a function, is just another type instead.

If you depend on this, I recommend you refactor the instance's function looking code into a helper method:

import types
def instance_has_method(instance, name):
    try:
        attr = getattr(instance, name)
        return isinstance(attr, types.FunctionType)
    except AttributeError:
        return False

Once you have this function, your code will be more concise because now you're sure that the attribute is indeed a function and can be callable.

The code above checks if the attribute is a function. If you want something wider, you can check if it's a callable like this: return hasattr(attr, '__call__').

In python, this is basically how you check for attributes inside classes. I don't think there's nothing wrong with your approach and not another more clever way to do reflection.

Hope this helps!

... Yep! Thanks! As always I seek for good tips and lessons. Here now, you gave me a such great idea I didnt think about it! Thanks! — R.R.C., Nov 08 '13 at 21:33
If a function is not defined in a class, but is defined instead in one oft its base classes, it is missing from `__dict__`. So `getattr` works better here, because it properly traverses the inheritance graph (which is not easy to do correctly, trust me). — 9000, Nov 08 '13 at 21:42

score 0 · Answer 2 · answered Nov 08 '13 at 21:37

It's not easy to understand what you are trying to achieve.

getattr(clazz_instace, 'One_more_method')(request) is just a fancy way to say clazz_instace.One_more_method(request).

Use of getattr is reasonable when you don't know the method name in advance, that is, if your method name is variable.

Also, setattr(clazz_instace, 'some_method_inside_this_class', True) turns alleged some_method_inside_this_class into a scalar attribute inside that class, having a True value. Probably this is not what you planned to have.

My best effort to understand your code is this:

def f(clazz):
  # if clazz is capable of better_processing, use it:
  if hasattr(clazz, 'better_processing'):
    return clazz.better_processing(...)
  else:
    return clazz.basic_processing(...)

BTW what getattr gives you is a callable method, you can directly use it, like this:

method = getattr(clazz, 'better_method', clazz.default_method)
# if 'better_method' was available, it was returned by getattr;
# if not, the default method was returned.
return method(clazz_instance, some_data...)

Good points you have! But, I ask in my question: if there is another way of searching class's methods without searchin 'em by their names as strings... And oh yeah, that `setattr(clazz_instace, 'some_method_inside_this_class', True)` is an attribute and not a method, that's my fault. Anyway, thank you for your good points! I'll think about it too! — R.R.C., Nov 08 '13 at 21:50
What _other_ identifier (but name) for a method comes to your mind? Its signature? Signatures in Python are pretty uninformative. If you're looking for something like interfaces, maybe [ABCs](http://docs.python.org/2/library/abc.html) could help you describe them. — 9000, Nov 08 '13 at 22:14

Seeking a different way in using Reflection or Introspection in Python

2 Answers2