Как сравнить тип объекта в Python?

Ответ 1

isinstance()

В вашем случае isinstance("this is a string", str) вернет True.

Вы также можете прочитать следующее: http://www.canonical.org/~kragen/isinstance/

Ответ 2

isinstance работает:

if isinstance(obj, MyClass): do_foo(obj)

, но, имейте в виду: если он выглядит как утка, и если это звучит как утка, это утка.

EDIT: для типа "Нет" вы можете просто:

if obj is None: obj = MyClass()

Ответ 3

Во-первых, избегайте всех сравнений типов. Они очень, очень редко нужны. Иногда они помогают проверять типы параметров в функции - даже такой редкой. Неверные данные типа вызовут исключение и все, что вам когда-либо понадобится.

Все основные функции преобразования будут отображаться как равные функции типа.

type(9) is int
type(2.5) is float
type('x') is str
type(u'x') is unicode
type(2+3j) is complex

Есть еще несколько случаев.

isinstance( 'x', basestring )
isinstance( u'u', basestring )
isinstance( 9, int )
isinstance( 2.5, float )
isinstance( (2+3j), complex )

Нет, BTW, никогда не нуждается в такой проверке типов. None - единственный экземпляр NoneType. Объектом None является Singleton. Просто проверьте None

variable is None

Кстати, не используйте вышеприведенное. Используйте обычные исключения и собственный естественный полиморфизм Python.

Ответ 4

Для других типов проверьте модуль types:

>>> import types
>>> x = "mystring"
>>> isinstance(x, types.StringType)
True
>>> x = 5
>>> isinstance(x, types.IntType)
True
>>> x = None
>>> isinstance(x, types.NoneType)
True

P.S. Typechecking - плохая идея.

Ответ 5

Вы всегда можете использовать трюк type(x) == type(y), где y - это что-то с известным типом.

# check if x is a regular string
type(x) == type('')
# check if x is an integer
type(x) == type(1)
# check if x is a NoneType
type(x) == type(None)

Часто есть лучшие способы сделать это, особенно с любым недавним python. Но если вы только хотите запомнить одну вещь, вы можете это вспомнить.

В этом случае лучшими способами будут:

# check if x is a regular string
type(x) == str
# check if x is either a regular string or a unicode string
type(x) in [str, unicode]
# alternatively:
isinstance(x, basestring)
# check if x is an integer
type(x) == int
# check if x is a NoneType
x is None

Обратите внимание на последний случай: в python есть только один экземпляр NoneType, и это None. Вы увидите NoType много в исключениях (TypeError: 'NoneType' object is unsubscriptable - происходит со мной все время..), но вам вряд ли когда-либо понадобится ссылаться на него в коде.

Наконец, как указывает fengshaun, проверка типов в python не всегда хорошая идея. Это более pythonic, чтобы просто использовать значение, как будто это тот тип, который вы ожидаете, и вылавливать (или допускать распространение) исключения, которые вытекают из него.

Ответ 6

Это потому, что вам нужно написать

s="hello"
type(s) == type("")

type принимает экземпляр и возвращает его тип. В этом случае вам нужно сравнить типы двух экземпляров.

Если вам нужно выполнить выборочную проверку, лучше проверить, поддерживается ли поддерживаемый интерфейс, чем тип.

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

Например, предположим, что у вас есть этот код

def firstElement(parameter):
    return parameter[0]

Теперь предположим, что вы говорите: я хочу, чтобы этот код принимал только кортеж.

import types

def firstElement(parameter):
    if type(parameter) != types.TupleType:
         raise TypeError("function accepts only a tuple")
    return parameter[0]

Это уменьшает повторное использование этой процедуры. Он не будет работать, если вы передадите список, строку или numpy.array. Что-то лучше было бы

def firstElement(parameter):
    if not (hasattr(parameter, "__getitem__") and callable(getattr(parameter,"__getitem__"))):
        raise TypeError("interface violation")
    return parameter[0]

но нет смысла в этом: параметр [0] вызовет исключение, если протокол не будет удовлетворен в любом случае... это, конечно, если вы не хотите предотвращать побочные эффекты или необходимость восстановления от вызовов, которые вы могли бы вызвать до терпит неудачу. (Глупый) пример, просто чтобы сделать точку:

def firstElement(parameter):
    if not (hasattr(parameter, "__getitem__") and callable(getattr(parameter,"__getitem__"))):
        raise TypeError("interface violation")
    os.system("rm file")
    return parameter[0]

в этом случае ваш код вызовет исключение перед запуском вызова system(). Без проверок интерфейса вы бы удалили файл, а затем подняли исключение.

Ответ 7

Ты очень близко! string - это модуль, а не тип. Вероятно, вы хотите сравнить тип obj с объектом типа для строк, а именно str:

type(obj) == str  # this works because str is already a type

В качестве альтернативы:

type(obj) == type('')

Обратите внимание, что в Python 2, если obj является типом unicode, то ни одно из вышеперечисленных действий не будет работать. Не будет isinstance(). См. Комментарии Джона к этому сообщению о том, как обойти это... Я пытался запомнить его примерно 10 минут, но имел блок памяти!

Ответ 8

Я использую type(x) == type(y)

Например, если я хочу проверить что-то, это массив:

type( x ) == type( [] )

проверка строки:

type( x ) == type( '' ) or type( x ) == type( u'' )

Если вы хотите проверить None, используйте

x is None

Ответ 9

Используйте str вместо строки

type ( obj ) == str

Объяснение

>>> a = "Hello"
>>> type(a)==str
True
>>> type(a)
<type 'str'>
>>>

Ответ 10

Я думаю, это должно сделать это

if isinstance(obj, str)

Ответ 11

Тип не работает для определенных классов. Если вы не уверены в типе объекта, используйте метод __class__, как показано ниже:

>>>obj = 'a string'
>>>obj.__class__ == str
True

Также см. эту статью - http://www.siafoo.net/article/56

Ответ 12

Чтобы получить тип, используйте элемент __class__, как в unknown_thing.__class__

Обсуждение утиного набора бесполезно здесь, потому что оно не отвечает на совершенно хороший вопрос. В моем коде приложения мне никогда не нужно знать тип чего-то, но все же полезно иметь способ изучить тип объекта. Иногда мне нужно получить фактический класс для проверки unit test. Утиная печать попадает туда, потому что все возможные объекты имеют один и тот же API, но только один правильный. Кроме того, иногда я поддерживаю чей-то еще код, и я понятия не имею, какой объект я прошел. Это моя самая большая проблема с динамически типизированными языками, такими как Python. Версия 1 очень проста и быстро развивается. Версия 2 - это боль в булочках, особенно если вы не писали версию 1. Поэтому иногда, когда я работаю с функцией, которую я не писал, мне нужно знать тип параметра, просто чтобы я знал какие методы я могу назвать.

То, где параметр __class__ пригодится. Это (насколько я могу судить) - лучший способ (возможно, единственный способ) получить тип объекта.

Ответ 13

Вы можете сравнить классы для уровня проверки.

#!/usr/bin/env python
#coding:utf8

class A(object):
    def t(self):
        print 'A'
    def r(self):
        print 'rA',
        self.t()

class B(A):
    def t(self):
        print 'B'

class C(A):
    def t(self):
        print 'C'

class D(B, C):
    def t(self):
        print 'D',
        super(D, self).t()

class E(C, B):
    pass

d = D()
d.t()
d.r()

e = E()
e.t()
e.r()

print isinstance(e, D) # False
print isinstance(e, E) # True
print isinstance(e, C) # True
print isinstance(e, B) # True
print isinstance(e, (A,)) # True
print e.__class__ >= A, #False
print e.__class__ <= C, #False
print e.__class__ <  E, #False
print e.__class__ <= E  #True