determinar si la variable de Python es una instancia de un tipo incorporado

Question

necesito para determinar si una variable dada Python es una instancia de tipo nativo: str, int, float, bool, list, dict y así sucesivamente. ¿Hay una forma elegante de hacerlo?

O se trata de la única manera:

if myvar in (str, int, float, bool): 
    # do something 

Answer 1

La mejor manera de lograr esto es recoger los tipos en una lista de tuplas llamada primitiveTypes y:

if isinstance(myvar, primitiveTypes): ... 

El types module contiene colecciones de todos los tipos importantes que pueden ayudar a construir la lista/tupla .

Works since Python 2.2

Answer 2

construido en función de tipo pueden ser útiles:

>>> a = 5 
>>> type(a) 
<type 'int'> 

Answer 3

¿Qué es un "tipo nativo" en Python? Por favor, no base su código en tipos, use Duck Typing.

Answer 4

No sé por qué querrías hacerlo, ya que no hay ningún tipo "simple" en Python, son todos los objetos. Pero esto funciona:

type(theobject).__name__ in dir(__builtins__) 

Pero la enumeración explícita de los tipos es probablemente mejor, ya que es más claro. O incluso mejor: cambiar la aplicación para que no tenga que saber la diferencia.

Actualización: El problema que necesita solución es cómo hacer un serializador para objetos, incluso aquellos incorporados. La mejor forma de hacerlo es no crear un gran serializador de phat que trate las construcciones de manera diferente, sino buscar serializadores según el tipo.

Algo como esto:

def IntSerializer(theint): 
    return str(theint) 

def StringSerializer(thestring): 
    return repr(thestring) 

def MyOwnSerializer(value): 
    return "whatever" 

serializers = { 
    int: IntSerializer, 
    str: StringSerializer, 
    mymodel.myclass: MyOwnSerializer, 
} 

def serialize(ob): 
    try: 
     return ob.serialize() #For objects that know they need to be serialized 
    except AttributeError: 
     # Look up the serializer amongst the serializer based on type. 
     # Default to using "repr" (works for most builtins). 
     return serializers.get(type(ob), repr)(ob) 

esta manera usted puede añadir fácilmente nuevos serializadores, y el código es fácil de mantener y claro, ya que cada tipo tiene su propia serializador. Observe cómo el hecho de que algunos tipos estén integrados se volvió completamente irrelevante. :)

Answer 5

Parece que está interesada en asegurar la simplejson se encargará de sus tipos. Esto se hace trivialmente por

try: 
    json.dumps(object) 
except TypeError: 
    print "Can't convert", object 

que es más confiable que intentar adivinar qué tipos maneja su implementación JSON.

Answer 6

la construcción fuera de la respuesta de S. Lott usted debe tener algo como esto:

from simplejson import JSONEncoder 

class JSONEncodeAll(JSONEncoder): 
    def default(self, obj): 
    try: 
     return JSONEncoder.default(self, obj) 
    except TypeError: 
     ## optionally 
     # try: 
     # # you'd have to add this per object, but if an object wants to do something 
     # # special then it can do whatever it wants 
     # return obj.__json__() 
     # except AttributeError: 
     ## 

     # ...do whatever you are doing now... 
     # (which should be creating an object simplejson understands) 

de usar:

>>> json = JSONEncodeAll() 

>>> json.encode(myObject) 
# whatever myObject looks like when it passes through your serialization code 

estas llamadas usarán su clase especial y si simplejson puede hacerse cargo de la objeto lo hará.De lo contrario, se desencadenará la funcionalidad de su catálogo, y posiblemente (dependiendo de si usa la parte opcional) un objeto puede definir su propia serialización

Answer 7

Esta es una pregunta antigua pero parece que ninguna de las respuestas responde a la pregunta específica: "(Cómo hacerlo) Determine si la variable Python es una instancia de un tipo incorporado ". Tenga en cuenta que no es "[...] de un tipo incorporado específico/dado" sino de a.

La manera apropiada de determinar si un objeto dado es una instancia de un buil-en el tipo/clase es comprobar si el tipo del objeto pasa a ser definida en el módulo __builtin__.

def is_builtin_class_instance(obj): 
    return obj.__class__.__module__ == '__builtin__' 

Advertencia: si obj es una clase y no una instancia, no importa si esa clase está incorporado o no, True serán devueltos desde una clase es también un objeto, una instancia de type (es decir AnyClass.__class__ es type).

Answer 8

puede acceder a todos estos tipos de types módulo:

`builtin_types = [ i for i in types.__dict__.values() if isinstance(i, type)]` 

como un recordatorio, módulo de importación types primera

def isBuiltinTypes(var): 
    return type(var) in [i for i in types.__dict__.values() if isinstance(i, type)] and not isinstance(var, types.InstanceType) 

Answer 9

Para mí, la mejor opción es:

allowed_modules = set(['numpy']) 
def isprimitive(value): 
    return not hasattr(value, '__dict__') or \ 
    value.__class__.__module__ in allowed_modules 

Esta corrección cuando value es un módulo y value.__class__.__module__ == '__builtin__' fallará.