Déterminer si la variable Python est une instance d'un type intégré

Question

je dois déterminer si une variable Python donnée est une instance de type natif: str, int, float, bool, list, dict et ainsi de suite. Y a-t-il un moyen élégant de le faire?

Ou est-ce la seule façon:

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

Answer 1

La meilleure façon d'y parvenir est de collecter les types dans une liste de tuple appelé primitiveTypes et:

if isinstance(myvar, primitiveTypes): ... 

Le types module contient des collections de tous les types importants qui peuvent aider à construire la liste/tuple .

Works since Python 2.2

Answer 2

Construit en fonction de type peut être utile:

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

Answer 3

Qu'est-ce qu'un "type natif" en Python? Veuillez ne pas baser votre code sur les types, utilisez Duck Typing.

Answer 4

Pas que je sache pourquoi vous voudriez le faire, car il n'y a pas de types "simples" en Python, ce sont tous des objets. Mais cela fonctionne:

type(theobject).__name__ in dir(__builtins__) 

Mais énumérer explicitement les types est probablement meilleur car il est plus clair. Ou encore mieux: Changer l'application pour ne pas avoir besoin de connaître la différence. Mise à jour: Le problème à résoudre est de savoir comment créer un sérialiseur pour les objets, même ceux qui sont intégrés. La meilleure façon de le faire est de ne pas faire un grand sérialiseur phat qui traite différemment les builtins, mais de rechercher des sérialiseurs basés sur le type.

Quelque chose comme ceci:

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) 

De cette façon, vous pouvez facilement ajouter de nouveaux serializers, et le code est facile à entretenir et claire, que chaque type a son propre sérialiseur. Remarquez comment le fait que certains types sont intégrés est complètement hors de propos. :)

Answer 5

Vous semblez être intéressé à assurer la simplejson se chargera de vos types. Ceci est fait trivialement par

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

Ce qui est plus fiable que d'essayer de deviner quels types votre implémentation JSON gère.

Answer 6

construction hors de la réponse de S. Lott, vous devriez avoir quelque chose comme ceci:

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) 

à utiliser:

>>> json = JSONEncodeAll() 

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

ces appels utiliseront votre classe spéciale et si simplejson peut prendre soin de la objet, il le fera.

Answer 7

Il s'agit d'une vieille question, mais il semble qu'aucune des réponses ne réponde vraiment à la question spécifique: "((La fonction de chariots est activée. How-to) Déterminer si la variable Python est une instance d'un type prédéfini ". Notez que ce n'est pas "[...] d'un spécifique/donné de type intégré" mais de un.

La bonne façon de déterminer si un objet donné est une instance d'une Buil-in Type/classe est de vérifier si le type de l'objet se trouve être définie dans le module __builtin__.

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

Attention: si obj est une classe et non une instance, peu importe si cette classe est intégrée ou non, True sera retourné depuis une classe est aussi un objet, une instance de type (c.-à-AnyClass.__class__ est type).

Answer 8

vous pouvez accéder à tous ces types par le module types:

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

comme un rappel, le module d'importation types premier

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

Pour moi, la meilleure option est:

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

Cette correction lorsque la valeur est un module et value.__class__.__module__ == '__builtin__' échouera.