Python Reflection and callable objects

I have a two part question.

>>> class One(object):
...     pass
... 
>>> class Two(object):
...     pass
... 
>>> def digest(constr):
...     c = apply(constr)
...     print c.__class__.__name__
...     print constr.__class__.__name__
... 
>>> digest(Two)
Two
type

How would one create object 'Two'? Neither constr() or c() work; and 开发者_C百科it seems that apply turns it into a type.

What happens when you pass a class rather and an instance into a method?

Classes are high level objects, so you can simply pass them like this:

def createMyClass ( myClass ):
    obj = myClass()
    return obj

class A ( object ):
    pass

>>> x = createMyClass( A )
>>> type( x )
<class '__main__.A'>

How would one create object 'Two'? Neither constr() or c() work; and it seems that apply turns it into a type.

The above comment was made in regards to this code:

>>> def digest(constr):
...     c = apply(constr)
...     print c.__class__.__name__
...     print constr.__class__.__name__

apply (deprecated: see @pyfunc's answer) certainly does not turn the class Two into a type: It already is one.

>>> class Two(object): pass
... 
>>> type(Two)
<type 'type'>

Classes are first class objects: they're instances of type. This makes sense if you look at the next example.

>>> two = Two()
>>> type(two)
<class '__main__.Two'>

You can see that a class very clearly functions as a type because it can be returned from type. Here's another example.

>>> Three = type('Three', (Two, ), {'foo': 'bar'})
>>> type(Three)
<type 'type'>
>>> three = Three()
>>> type(three)
<class '__main__.Three'>

You can see that type is a class that can be instantiated. Its constructor takes three arguments: the name of the class, a tuple of base classes and a dictionary containing the class attributes. It returns a new type aka class.

As to your final question,

What happens when you pass a class rather and an instance into a method?

You're going to have to be more specific. Classes are just instances of type and so are first class objects. Asking what happens if I pass a class into a method is like asking what happens if I pass an integer into a method: It depends entirely on what the method is expecting.

Just another one example:

def InstanceFactory(classname):
   cls = globals()[classname]
   return cls() 

class A(object):
   def start(self):
       print "a.start"

class B(object):
   def start(self):
        print "b.start"

InstanceFactory("A").start()
InstanceFactory("B").start()

If the class belongs to another module:

def InstanceFactory(modulename, classname):
    if '.' in modulename:
        raise ValueError, "can't handle dotted modules yet"
    mod = __import__(modulename)
    cls = getattr(mod, classname]
    return cls() 

I am confused though. Wasn't apply() deprecated since 2.3

• http://www.python.org/dev/peps/pep-0290/

We don't need this any more.

apply(f, args, kwds)  -->  f(*args, **kwds)

Others have been moved / considered deprecated in modern usage:

1. buffer()
2. coerce()
3. and intern()

Simply use : Classname() to create an object.