Как сравнить тип объекта в Python?
Кроме того, как насчет других типов? Например, я не мог реплицировать NoneType .
13 ответов
В вашем случае isinstance(«this is a string», str) вернет True .
Вы также можете прочитать следующее: http://www.canonical.org/
, но, имейте в виду: если он выглядит как утка, и если это звучит как утка, это утка.
EDIT: для типа «Нет» вы можете просто:
Во-первых, избегайте всех сравнений типов. Они очень, очень редко нужны. Иногда они помогают проверять типы параметров в функции — даже такой редкой. Неверные данные типа вызовут исключение и все, что вам когда-либо понадобится.
Все основные функции преобразования будут отображаться как равные функции типа.
Есть еще несколько случаев.
Нет, BTW, никогда не нуждается в такой проверке типов. None — единственный экземпляр NoneType. Объектом None является Singleton. Просто проверьте None
Кстати, не используйте вышеприведенное. Используйте обычные исключения и собственный естественный полиморфизм Python.
Для других типов проверьте модуль types:
P.S. Typechecking — плохая идея.
Вы всегда можете использовать трюк type(x) == type(y) , где y — это что-то с известным типом.
Часто есть лучшие способы сделать это, особенно с любым недавним python. Но если вы только хотите запомнить одну вещь, вы можете это вспомнить.
В этом случае лучшими способами будут:
Обратите внимание на последний случай: в python есть только один экземпляр NoneType , и это None . Вы увидите NoType много в исключениях ( TypeError: ‘NoneType’ object is unsubscriptable — происходит со мной все время..), но вам вряд ли когда-либо понадобится ссылаться на него в коде.
Наконец, как указывает fengshaun, проверка типов в python не всегда хорошая идея. Это более pythonic, чтобы просто использовать значение, как будто это тот тип, который вы ожидаете, и вылавливать (или допускать распространение) исключения, которые вытекают из него.
Это потому, что вам нужно написать
type принимает экземпляр и возвращает его тип. В этом случае вам нужно сравнить типы двух экземпляров.
Если вам нужно выполнить выборочную проверку, лучше проверить, поддерживается ли поддерживаемый интерфейс, чем тип.
Тип действительно не говорит вам о многом, кроме того, что вашему коду нужен экземпляр определенного типа, независимо от того, что у вас может быть другой экземпляр совершенно другого типа, который был бы прекрасно, потому что он реализует тот же интерфейс.
Например, предположим, что у вас есть этот код
Теперь предположим, что вы говорите: я хочу, чтобы этот код принимал только кортеж.
Это уменьшает повторное использование этой процедуры. Он не будет работать, если вы передадите список, строку или numpy.array. Что-то лучше было бы
но нет смысла в этом: параметр [0] вызовет исключение, если протокол не будет удовлетворен в любом случае. это, конечно, если вы не хотите предотвращать побочные эффекты или необходимость восстановления от вызовов, которые вы могли бы вызвать до терпит неудачу. (Глупый) пример, просто чтобы сделать точку:
в этом случае ваш код вызовет исключение перед запуском вызова system(). Без проверок интерфейса вы бы удалили файл, а затем подняли исключение.
Операторы сравнения
Эти операторы сравнивают два типа значений, они меньше и больше чем операторы. Для чисел это просто сравнивает числовые значения, чтобы увидеть, что больше:
Для строк они будут сравниваться лексикографически, что похоже на алфавитный порядок, но не совсем то же самое.
В этих сравнениях, строчные буквы считаются «больше чем» верхний регистр, поэтому «gamma» < «OMEGA» является ложным. Если бы все они были в верхнем регистре, он вернул бы ожидаемый результат в алфавитном порядке:
Каждый тип определяет это расчет с < и > операторы по- разному, так что вы должны исследовать , что операторы означают с данным типом перед его использованием.
Не равно
Это возвращает True , если x и y не равны и в противном случае возвращает значение False .
Равно
Это выражение , если x и y имеют одинаковое значение и возвращает результат как логическое значение. В целом как тип и значение должны совпадать, так что ИНТ 12 не то же самое , как строка ’12’ .
Обратите внимание, что каждый тип должен определять функцию, которая будет использоваться для оценки, если два значения одинаковы. Для встроенных типов эти функции ведут себя так, как вы ожидаете, и просто оценивают вещи, основываясь на том же значении. Однако пользовательские типы можно определить тестирование равенства , как бы они ни хотели, в том числе всегда возвращаются True или всегда возвращаются False .
Сравнение цепей
Вы можете сравнить несколько элементов с несколькими операторами сравнения с помощью цепочки сравнения. Например
это просто краткая форма:
Это позволит оценить, True , только если оба сравнения True .
Где OP представляет один из нескольких операций сравнения , которые можно использовать, а буквы представляют собой произвольные действительные выражения.
Стиль
Нет теоретического ограничения на количество элементов и операций сравнения, если вы используете правильный синтаксис:
Вышеприведенные возвращает True , если каждое сравнение возвращает True .Тем не менее, использование замысловатой цепочки не очень хороший стиль. Хорошая цепочка будет «направленной», не более сложной, чем
Побочные эффекты
Как только одно сравнение возвращает значение False , выражение сразу вычисляет значение False , пропуская все остальные сравнения.
Отметим , что выражение exp в a > exp > b будет оцениваться только один раз, в то время как в случае
exp будет вычисляться дважды , если a > exp верно.
Сравнение по `is` vs` == `
Типичная ошибка является запутанными операторы сравнения равенства is и == .
a == b сравнивает значение и a b .
a is b сравнит тождества и a b .
В принципе, is можно рассматривать как сокращение для id(a) == id(b) .
Помимо этого, существуют особенности среды выполнения, которые еще больше усложняют ситуацию. Короткие строки и небольшие целые числа будут возвращать True , по сравнению с is , из — за машины Python пытается использовать меньше памяти для одинаковых объектов.
Но более длинные строки и большие целые числа будут храниться отдельно.
Вы должны использовать is , чтобы проверить на None :
Применение по is является проверка на «дозорных» (то есть уникальный объект).
Сравнение объектов
Для сравнения равенства пользовательских классов, вы можете переопределить == и != Определяя __eq__ и __ne__ методу. Вы также можете переопределить __lt__ ( < ), __le__ ( <= ), __gt__ ( > ), и __ge__ ( > ). Обратите внимание , что вам нужно только переопределить два метода сравнения, и Python может справиться с остальным ( == таким же , как not < и not > , и т.д.)
Заметим , что это простое сравнение предполагает , что other объект (объект сравнивается с) имеет тот же тип объекта. Сравнение с другим типом приведет к ошибке:
Проверка isinstance() или аналогичный поможет предотвратить это (если это необходимо).
How to compare type of an object in Python?
Also, what about the other types? For example, I couldn’t replicate NoneType .
15 Answers 15
In your case, isinstance(«this is a string», str) will return True .
You may also want to read this: http://www.canonical.org/
First, avoid all type comparisons. They’re very, very rarely necessary. Sometimes, they help to check parameter types in a function — even that’s rare. Wrong type data will raise an exception, and that’s all you’ll ever need.
All of the basic conversion functions will map as equal to the type function.
There are a few other cases.
None, BTW, never needs any of this kind of type checking. None is the only instance of NoneType. The None object is a Singleton. Just check for None
BTW, do not use the above in general. Use ordinary exceptions and Python’s own natural polymorphism.
but, keep in mind: if it looks like a duck, and if it sounds like a duck, it is a duck.
EDIT: For the None type, you can simply do:
For other types, check out the types module:
P.S. Typechecking is a bad idea.
You can always use the type(x) == type(y) trick, where y is something with known type.
Often there are better ways of doing that, particularly with any recent python. But if you only want to remember one thing, you can remember that.
In this case, the better ways would be:
Note the last case: there is only one instance of NoneType in python, and that is None . You’ll see NoneType a lot in exceptions ( TypeError: ‘NoneType’ object is unsubscriptable — happens to me all the time..) but you’ll hardly ever need to refer to it in code.
Finally, as fengshaun points out, type checking in python is not always a good idea. It’s more pythonic to just use the value as though it is the type you expect, and catch (or allow to propagate) exceptions that result from it.
Use isinstance(object, type) . As above this is easy to use if you know the correct type , e.g.,
But for more esoteric objects, this can be difficult to use. For example:
but you can do this trick:
So I recommend instantiating a variable ( y in this case) with a type of the object you want to check (e.g., type(np.array()) ), then using isinstance .
You’re very close! string is a module, not a type. You probably want to compare the type of obj against the type object for strings, namely str :
Note, in Python 2, if obj is a unicode type, then neither of the above will work. Nor will isinstance() . See John’s comments to this post for how to get around this. I’ve been trying to remember it for about 10 minutes now, but was having a memory block!
Use str instead of string
It is because you have to write
type accepts an instance and returns its type. In this case you have to compare two instances’ types.
If you need to do preemptive checking, it is better if you check for a supported interface than the type.
The type does not really tell you much, apart of the fact that your code want an instance of a specific type, regardless of the fact that you could have another instance of a completely different type which would be perfectly fine because it implements the same interface.
For example, suppose you have this code
Now, suppose you say: I want this code to accept only a tuple.
This is reducing the reusability of this routine. It won’t work if you pass a list, or a string, or a numpy.array. Something better would be
but there’s no point in doing it: parameter[0] will raise an exception if the protocol is not satisfied anyway. this of course unless you want to prevent side effects or having to recover from calls that you could invoke before failing. (Stupid) example, just to make the point:
in this case, your code will raise an exception before running the system() call. Without interface checks, you would have removed the file, and then raised the exception.
I use type(x) == type(y)
For instance, if I want to check something is an array:
If you want to check against None, use is
kragen/isinstance of the most voted (+7) answer, by voltronw
i think this should do it
To get the type, use the __class__ member, as in unknown_thing.__class__
Talk of duck-typing is useless here because it doesn’t answer a perfectly good question. In my application code I never need to know the type of something, but it’s still useful to have a way to learn an object’s type. Sometimes I need to get the actual class to validate a unit test. Duck typing gets in the way there because all possible objects have the same API, but only one is correct. Also, sometimes I’m maintaining somebody else’s code, and I have no idea what kind of object I’ve been passed. This is my biggest problem with dynamically typed languages like Python. Version 1 is very easy and quick to develop. Version 2 is a pain in the buns, especially if you didn’t write version 1. So sometimes, when I’m working with a function I didn’t write, I need to know the type of a parameter, just so I know what methods I can call on it.
That’s where the __class__ parameter comes in handy. That (as far as I can tell) is the best way (maybe the only way) to get an object’s type.
Как сравнить типы переменных в Python?
Я работаю над простой программой, которая будет запрашивать погоду и температуру и выводить, какую одежду должен носить пользователь. Однако я дошел до того, что хочу убедиться, что пользователь не может вводить градусы «g» или любую другую строку. Есть ли простой способ сравнения типов переменных? Другими словами, есть ли что-то вроде:
Или что-то похожее, что не слишком сложно? Лично я в порядке с расширенными функциями и еще чем-то, но это будет выглядеть схематично для моего учителя CS.
4 ответа
Вы в значительной степени правильно, просто нет необходимости в кавычках.
Посмотрите, что большинство из нас будет делать в этом сценарии (предполагается, что Python 3):
Если мы получим не число, мы взорвемся ValueError , Зная это, мы должны просто. поймать это:
Не возиться с проверкой типов, так как это сделает ваш код немного менее Pythonic. Вместо этого не бойтесь, что этот код может взорваться; если это произойдет, просто поймайте исключение и устраните последствия позже.
В Python есть встроенная функция для проверки типов переменных. Из документов
isinstance(объект, classinfo)
Вернуть true, если аргумент объекта является экземпляром аргумента classinfo или его (прямого, косвенного или виртуального) подкласса. Также возвращает true, если classinfo является объектом типа (класс нового стиля), а объект является объектом этого типа или его (прямого, косвенного или виртуального) подкласса. Если объект не является экземпляром класса или объектом данного типа, функция всегда возвращает false. Если classinfo не является ни объектом класса, ни объектом типа, он может быть кортежем объектов класса или типа или может рекурсивно содержать другие такие кортежи (другие типы последовательностей не принимаются). Если classinfo не является классом, типом или кортежем классов, типов и таких кортежей, возникает исключение TypeError.
Я только что натолкнулся на это и подумал, что, хотя этот вопрос задавался давным-давно, в интересах других пользователей, я предложу свое решение.
Я создал вспомогательную функцию, которая проверяет тип путем отлова исключений:
Затем в основной части кода, где бы я ни хотел проверить идентичность типа, я просто напишу что-то вроде этого:
Этот подход также позволяет пользователю изменять тип переменной в зависимости от типа другой переменной, так как с этой функцией int вернет 1, а строка вернет 2.