¿Identificando que una variable es una clase de estilo nuevo en Python?

Question

Estoy usando Python 2.x y me pregunto si hay una manera de saber si una variable es una clase de estilo nuevo. Sé que si se trata de una clase de estilo antiguo, puedo hacer lo siguiente para averiguarlo.

import types 

class oldclass: 
    pass 

def test(): 
    o = oldclass() 
    if type(o) is types.InstanceType: 
    print 'Is old-style' 
    else: 
    print 'Is NOT old-style' 

Pero no he podido encontrar nada que funcione para las clases de nuevo estilo. Encontré this question, pero las soluciones propuestas no parecen funcionar como se esperaba, porque los valores simples se identifican como clases.

import inspect 

def newclass(object): 
    pass 

def test(): 
    n = newclass() 
    if inspect.isclass(n): 
    print 'Is class' 
    else: 
    print 'Is NOT class' 
    if inspect.isclass(type(n)): 
    print 'Is class' 
    else: 
    print 'Is NOT class' 
    if inspect.isclass(type(1)): 
    print 'Is class' 
    else: 
    print 'Is NOT class' 
    if isinstance(n, object): 
    print 'Is class' 
    else: 
    print 'Is NOT class' 
    if isinstance(1, object): 
    print 'Is class' 
    else: 
    print 'Is NOT class' 

¿Hay alguna forma de hacer algo como esto? ¿O todo en Python es solo una clase y no hay forma de evitarlo?

Answer 1

Creo que lo que estás preguntando es: "¿Puedo probar si una clase se definió en el código de Python como una clase de nuevo estilo?". Los tipos técnicamente simples como intson clases de nuevo estilo, pero aún es posible distinguir clases escritas en Python de los tipos incorporados.

Aquí hay algo que funciona, aunque es un poco de un truco:

def is_new_style(cls): 
    return hasattr(cls, '__class__') \ 
      and \ 
      ('__dict__' in dir(cls) or hasattr(cls, '__slots__')) 


class new_style(object): 
    pass 

class old_style(): 
    pass 

print is_new_style(int) 
print is_new_style(new_style) 
print is_new_style(old_style) 

salida desde Python 2.6:

False 
True 
False 

Aquí está una manera diferente de hacerlo:

def is_new_style(cls): 
    return str(cls).startswith('<class ') 

Answer 2

No es que "todo es una clase": con lo que se topan es que "todo es un objeto " (es decir, cada cosa (de nuevo estilo) desciende de "objeto").

Pero las clases de nuevo estilo son un "tipo" ellos mismos (en realidad, se introdujeron para reunir clases y tipos). Por lo tanto, puede intentar buscar

import types 

type(o) == types.TypeType 

¿Eso soluciona su problema?

Answer 3

Creo que esto es suficiente:

def is_new_style_class(klass): 
    return issubclass(klass, object) 

def is_new_style_class_instance(instance): 
    return issubclass(instance.__class__, object) 

Normalmente, solo necesita la función is_new_style_class para sus fines. No todo una clase lanzará una TypeError, por lo que es posible que desee actualizar a:

def is_new_style_class(klass): 
    try: 
     return issubclass(klass, object) 
    except TypeError: 
     return False 

Ejemplos:

>>> class New(object): pass 
... 
>>> is_new_style_class(New) 
True 
>>> class Old: pass 
... 
>>> is_new_style_class(Old) 
False 
>>> is_new_style_class(1) 
False 
>>> is_new_style_class(int) 
True 

int, siendo un tipo, es por definición una clase de nuevo estilo (ver Unifying types and classes in Python 2.2) o, si prefiere, las clases de nuevo estilo son por definición tipos.

Answer 4

La comprobación de las clases antiguas es muy fácil. Simplemente marque type(cls) is types.ClassType. También es fácil verificar las clases de nuevo estilo, isinstance(cls, type). Tenga en cuenta que los tipos incorporados también son clases de estilo nuevo.

Parece que no hay una forma trivial de distinguir las incorporaciones de las clases escritas en Python.Las clases de nuevo estilo con __slots__ tampoco tienen __dict__, al igual que int o str. Comprobar si str (cls) coincide con el patrón esperado falla si la metaclase de las clases prevalece sobre el método __str__. Algunas otras maneras que tampoco funcionan:

• cls.__module__ == '__builtin__' (puede reasignar __module__ de clases)
• not any(value is cls for value in vars(__builtins__).values()) (se pueden agregar cosas al módulo __builtin__).

El hecho de que la unificación de tipos incorporados y definidos por el usuario es tan bueno que distinguirlos no es un problema trivial debería implicar para usted el punto subyacente. Realmente no deberías tener que distinguir entre ellos. No importa cuál sea el objeto si implementa el protocolo esperado.