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

Pas que je sais pourquoi vous voulez le faire, comme il n'est pas "simple" types de Python, c'est tous les objets. Mais cela fonctionne:

type(theobject).__name__ in dir(__builtins__)

Mais une liste explicite des types est probablement mieux que c'est plus clair. Ou encore mieux: la Modification de l'application de sorte que vous n'avez pas besoin de connaître la différence.

Mise à jour: Le problème à résoudre est de savoir comment faire un sérialiseur pour les objets, même ceux intégrés. La meilleure façon de le faire est de ne pas faire un big phat sérialiseur qui traite les builtins différemment, mais pour rechercher les sérialiseurs en fonction de leur 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 sérialiseurs, et le code est facile à entretenir et clair, que chaque type a son propre sérialiseur. Remarquez comment le fait que certains types sont builtin est devenu complètement hors de propos. 🙂

OriginalL'auteur Lennart Regebro

C'est une vieille question, mais il semble aucune des réponses réellement répondre à la question précise: "(how-to) Déterminer si la variable Python est une instance d'un type". Notez qu'il n'est pas "[...] d'une spécifiques/ type" mais de un.

La bonne façon de de déterminer si un objet est une instance d'un bâti-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__'

Avertissement: si obj est une classe, et non pas une instance, peu importe si cette classe est intégré ou pas, la valeur True est retourné depuis une classe est un objet, une instance de type (c'est à dire AnyClass.__class__ est type).

OriginalL'auteur glarrain

Construit dans le type de fonction peut être utile:

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

OriginalL'auteur kolistivra

construction de S. Lott réponse, 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 d'utilisation spéciale de votre classe, et si simplejson peut prendre soin de l'objet, il sera. Sinon, votre fourre-tout de la fonctionnalité sera déclenchée, et éventuellement (en fonction de si vous utilisez l'option d'une partie) d'un objet peut définir ses propres sérialisation

OriginalL'auteur Terence Honles