Take the 2-minute tour ×

I need to determine if a given Python variable is an instance of native type: str, int, float, bool, list, dict and so on. Is there elegant way to doing it?

Or is this the only way:

if myvar in (str, int, float, bool):
    # do something
share|improve this question
What do you mean by "native" type? Do you mean builtin? Why do you need to know this? Python isn't C++ or Java, so there's no distinction between "simple" or "native" types. What are you trying to do? –  S.Lott Aug 24 '09 at 12:30
Yes, I guess I mean "builtin" types. I need such representation of an object, that I could use it in JSON serialization. simplejson "handles" only such types. In other cases (when object are instances of "homemade" classes) i need to make dict objects. –  Aleksandr Motsjonov Aug 24 '09 at 12:43
You know that simplejson has something called "object decoding" and "object encoding"? –  lutz Aug 24 '09 at 12:46
Yes, But as I understood this - I should write such decoder for each kind of class I want to serialize. I don't want to do it. –  Aleksandr Motsjonov Aug 24 '09 at 12:50
@Aleksandr Motsjonov: Please update your question to specifically say that you're interested in types that simplejson handles by default. –  S.Lott Aug 24 '09 at 13:06

8 Answers 8

up vote 7 down vote accepted

The best way to achieve this is to collect the types in a list of tuple called primitiveTypes and:

if isinstance(myvar, primitiveTypes): ...

The types module contains collections of all important types which can help to build the list/tuple.

Works since Python 2.2

share|improve this answer
thx. it's maybe more elegant than I wrote initially. –  Aleksandr Motsjonov Aug 24 '09 at 12:52
using types from 'types' is no different than using the more straightforward names (int, str, float, ...) directly! –  u0b34a0f6ae Aug 24 '09 at 13:07
Yes, that's how types works. But it makes your intention more clean and if you use the predefined sets (StringTypes), you get additional portability between Python versions. –  Aaron Digulla Aug 24 '09 at 13:37
It's also slightly faster ... ;) –  Aaron Digulla Aug 24 '09 at 13:38
I'm not sure this is the best approach. Basically you import types from the types modules and check against them, but the docs discourages this way since python 2.2 on. Accordingly to the docs using isinstance is preferred. The 2nd code example shows a simple case. –  Paolo Nov 18 '12 at 13:01

You appear to be interested in assuring the simplejson will handle your types. This is done trivially by

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

Which is more reliable than trying to guess which types your JSON implementation handles.

share|improve this answer
this is more pythonic 'cause if the object can be dumped (say perhaps simplejson adds more support) then it will be used first, and then in the except you should call your catchall functionality. +1 –  Terence Honles Aug 24 '09 at 22:28

Not that I know why you would want to do it, as there isn't any "simple" types in Python, it's all objects. But this works:

type(theobject).__name__ in dir(__builtins__)

But explicitly listing the types is probably better as it's clearer. Or even better: Changing the application so you don't need to know the difference.

Update: The problem that needs solving is how to make a serializer for objects, even those built-in. The best way to do this is not to make a big phat serializer that treats builtins differently, but to look up serializers based on type.

Something like this:

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):
        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)

This way you can easily add new serializers, and the code is easy to maintain and clear, as each type has its own serializer. Notice how the fact that some types are builtin became completely irrelevant. :)

share|improve this answer
it works, but you should not use it :/ –  NicDumZ Aug 24 '09 at 12:34
+1 "Changing the application so you don't need to know the difference." Some (extremely rare) times is necesary to know, but most likely isn't. –  voyager Aug 24 '09 at 12:44

What is a "native type" in Python? Please don't base your code on types, use Duck Typing.

share|improve this answer
Thanks, I will think twice before do it =) –  Aleksandr Motsjonov Aug 24 '09 at 12:48

Built in type function may be helpful:

>>> a = 5
>>> type(a)
<type 'int'>
share|improve this answer

This is an old question but it seems none of the answers actually answer the specific question: "(How-to) Determine if Python variable is an instance of a built-in type". Note that it's not "[...] of a specific/given built-in type" but of a.

The proper way to determine if a given object is an instance of a buil-in type/class is to check if the type of the object happens to be defined in the module __builtin__.

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

Warning: if obj is a class and not an instance, no matter if that class is built-in or not, True will be returned since a class is also an object, an instance of type (i.e. AnyClass.__class__ is type).

share|improve this answer

building off of S.Lott's answer you should have something like this:

from simplejson import JSONEncoder

class JSONEncodeAll(JSONEncoder):
  def default(self, obj):
      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)

to use:

>>> json = JSONEncodeAll()

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

these calls will use your special class and if simplejson can take care of the object it will. Otherwise your catchall functionality will be triggered, and possibly (depending if you use the optional part) an object can define it's own serialization

share|improve this answer

you can access all these types by types module:

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

as a reminder, import module types first

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

Your Answer


