Определите, является ли переменная Python экземпляром встроенного типа

Лучший способ добиться этого — собрать типы в список кортежей с именем primitiveTypes и:

if isinstance(myvar, primitiveTypes): ...

types модуль содержит коллекции всех важных типов, которые могут помочь в создании списка/кортежа .

Работает, начиная с Python 2.2

Это старый вопрос, но, похоже, ни один из ответов на самом деле не отвечает на конкретный вопрос: «(Как) определить, является ли переменная Python экземпляром встроенного типа». Обратите внимание, что это не "[...] встроенного типа конкретного/данного", а a.

Правильный способ определить, является ли данный объект экземпляром встроенного типа/класса, состоит в том, чтобы проверить, определен ли тип объекта в модуле __builtin__.

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

Предупреждение: если obj является классом, а не экземпляром, независимо от того, встроен этот класс или нет, будет возвращено значение True, поскольку класс также является объектом, экземпляром type (т. е. AnyClass.__class__ является type).

Не то чтобы я знал, почему вы хотели бы это сделать, поскольку в Python нет «простых» типов, это все объекты. Но это работает:

type(theobject).__name__ in dir(__builtins__)

Но явное перечисление типов, вероятно, лучше, так как это понятнее. Или еще лучше: изменить приложение, чтобы вам не нужно было знать разницу.

Обновление: проблема, требующая решения, заключается в том, как сделать сериализатор для объектов, даже встроенных. Лучший способ сделать это — не создавать большой phat-сериализатор, который по-разному обрабатывает встроенные функции, а искать сериализаторы на основе типа.

Что-то вроде этого:

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)

Таким образом, вы можете легко добавлять новые сериализаторы, а код легко поддерживать и очищать, так как у каждого типа есть свой сериализатор. Обратите внимание, что тот факт, что некоторые типы являются встроенными, стал совершенно неуместным. :)

Похоже, вы заинтересованы в том, чтобы simplejson справился с вашими типами. Это делается тривиально

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

Это более надежно, чем пытаться угадать, какие типы обрабатывает ваша реализация JSON.

Что такое «собственный тип» в Python? Пожалуйста, не основывайте свой код на типах, используйте Duck Typing.

вы можете получить доступ ко всем этим типам с помощью модуля types:

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

напоминаем, сначала импортируйте модуль types

def isBuiltinTypes(var):
    return type(var) in types.__dict__.values() and not isinstance(var, types.InstanceType)

Встроенная функция типа может быть полезна:

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

основываясь на ответе С.Лотта, у вас должно быть что-то вроде этого:

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)

использовать:

>>> json = JSONEncodeAll()

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

эти вызовы будут использовать ваш специальный класс, и если simplejson сможет позаботиться об объекте, он будет. В противном случае будет запущена ваша универсальная функциональность, и, возможно (в зависимости от того, используете ли вы необязательную часть), объект может определить свою собственную сериализацию.

Для меня лучший вариант:

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

Это исправление, когда значение является модулем, а value.__class__.__module__ == '__builtin__' не работает.

Сейчас 2020 год, я на Python 3.7, и ни один из существующих ответов мне не помог. Вместо этого сработал встроенный модуль . Вот как:

import builtins
type(your_object).__name__ in dir(builtins)