ChatGPT解决这个技术问题 Extra ChatGPT

What's the canonical way to check for type in Python?

How do I check if an object is of a given type, or if it inherits from a given type?

How do I check if the object o is of type str?

I think Mr. Coombs is overlooking examples like non-JSON serializable classes. If putting a big chunk of data through a function (whose code one can't influence) one might want to convert certain pieces of that data to, for instance, a before passing it. At least that's how I ended up on this page...
It seems the most common reason for asking for this is that one wants to distinguish between strings and iterables of strings. This is a tricky question because strings are iterables of strings -- a single-character string is even a sequence of itself (last time I checked -- one probably shouldn't rely on it). But would anyone ever have use for something string-like? Yes. So the answer to "What should I do to distinguish between strings and other iterables of strings?" is properly: "It depends on what you are trying to do". :-D
Python type annotations are now a thing. Take a look at mypy

M
Mateen Ulhaq

Use isinstance to check if o is an instance of str or any subclass of str:

if isinstance(o, str):

To check if the type of o is exactly str, excluding subclasses of str:

if type(o) is str:

Another alternative to the above:

if issubclass(type(o), str):

See Built-in Functions in the Python Library Reference for relevant information.

Checking for strings in Python 2

For Python 2, this is a better way to check if o is a string:

if isinstance(o, basestring):

because this will also catch Unicode strings. unicode is not a subclass of str; whereas, both str and unicode are subclasses of basestring. In Python 3, basestring no longer exists since there's a strict separation of strings (str) and binary data (bytes).

Alternatively, isinstance accepts a tuple of classes. This will return True if o is an instance of any subclass of any of (str, unicode):

if isinstance(o, (str, unicode)):

str.__subclasses__() only returns the direct subclasses of str, and does not do the same thing as issubclass() or isinstance(). (To do that, you would have to recursively call .__subclasses__().
This is a good answer, but I think it really ought to start with a warning that you usually shouldn't be doing this in Python. As it is, it seems to validate the assumption that this is a "canonical thing to do in Python", which it isn't.
What's the difference between instance and "exactly"? If type(a) is Object then isn't it also true that isinstance(a, Object). However, if type(a) is SubClassOfObject, then type(a) is Object == False, but isinstance(a, Object) == True. Right?
@mavavilj - a is b means a and b are the exact same thing, i.e. references to the same entity in memory. So a and b would have to be the exact same class, not subclasses, as with isinstance(). See for example stackoverflow.com/a/133024/1072212
@JonCoombs According to the rationale of PEP 622, isinstance() is the second most called builtin function, after len(). I think we have to accept that isinstance is de facto canonical Python.
s
smci

The most Pythonic way to check the type of an object is... not to check it.

Since Python encourages Duck Typing, you should just try...except to use the object's methods the way you want to use them. So if your function is looking for a writable file object, don't check that it's a subclass of file, just try to use its .write() method!

Of course, sometimes these nice abstractions break down and isinstance(obj, cls) is what you need. But use sparingly.


IMHO, the most Pythonic way is to cope with whatever argument which is given. In my code I often cannot know if I recieve an object or an array of objects, and I use type-checking internally to convert a single object to a one-element list.
Rather then just trying to use its write method there are times when you want to do this without causing an exception. In this case you could do... if hasattr(ob, "write") and callable(ob.write): Or save some dict access... func = getattr(ob, "write", None) if callable(func): ...
Duck typing is about using an library. Type checking is about writing an library. Not the same problem domain.
@RickyA, I disagree. Duck typing is about interacting with objects using interfaces with well-known semantics. This can apply either to library code or to the code that uses such a library.
@nyuszika7h, In Python3 hasattr only supresses an AttributeError - See: docs.python.org/3.4/library/functions.html#hasattr
L
L3viathan

isinstance(o, str) will return True if o is an str or is of a type that inherits from str.

type(o) is str will return True if and only if o is a str. It will return False if o is of a type that inherits from str.


Of course, this will fail if the object is not an instance of 'str', but of something string-like instead. Like unicode, mmap, UserString or any other user-defined type. The usual approach in Python is not to do typechecks.
This is very helpful. Because the difference between isinstance and type(var) == type('') is not clear.
P
Praxeolitic

After the question was asked and answered, type hints were added to Python. Type hints in Python allow types to be checked but in a very different way from statically typed languages. Type hints in Python associate the expected types of arguments with functions as runtime accessible data associated with functions and this allows for types to be checked. Example of type hint syntax:

def foo(i: int):
    return i

foo(5)
foo('oops')

In this case we want an error to be triggered for foo('oops') since the annotated type of the argument is int. The added type hint does not cause an error to occur when the script is run normally. However, it adds attributes to the function describing the expected types that other programs can query and use to check for type errors.

One of these other programs that can be used to find the type error is mypy:

mypy script.py
script.py:12: error: Argument 1 to "foo" has incompatible type "str"; expected "int"

(You might need to install mypy from your package manager. I don't think it comes with CPython but seems to have some level of "officialness".)

Type checking this way is different from type checking in statically typed compiled languages. Because types are dynamic in Python, type checking must be done at runtime, which imposes a cost -- even on correct programs -- if we insist that it happen at every chance. Explicit type checks may also be more restrictive than needed and cause unnecessary errors (e.g. does the argument really need to be of exactly list type or is anything iterable sufficient?).

The upside of explicit type checking is that it can catch errors earlier and give clearer error messages than duck typing. The exact requirements of a duck type can only be expressed with external documentation (hopefully it's thorough and accurate) and errors from incompatible types can occur far from where they originate.

Python's type hints are meant to offer a compromise where types can be specified and checked but there is no additional cost during usual code execution.

The typing package offers type variables that can be used in type hints to express needed behaviors without requiring particular types. For example, it includes variables such as Iterable and Callable for hints to specify the need for any type with those behaviors.

While type hints are the most Pythonic way to check types, it's often even more Pythonic to not check types at all and rely on duck typing. Type hints are relatively new and the jury is still out on when they're the most Pythonic solution. A relatively uncontroversial but very general comparison: Type hints provide a form of documentation that can be enforced, allow code to generate earlier and easier to understand errors, can catch errors that duck typing can't, and can be checked statically (in an unusual sense but it's still outside of runtime). On the other hand, duck typing has been the Pythonic way for a long time, doesn't impose the cognitive overhead of static typing, is less verbose, and will accept all viable types and then some.


-1: mypy specifically calls itself a "static type checker" so I'm not sure where you got "type checking must be done at runtime" from.
@Kevin In retrospect, that was an unnecessary digression, but to get into it more, Python's type hints are turned into runtime data and mypy is a Python module that uses importlib to access that data. Whether this is "static type checking" is a philosophical question but it's different from what most would expect since the normal language interpreter and import machinery are involved.
That is not true either. It uses typed_ast, which itself is just a clone of ast with extra features. ast does not import modules; it parses them into an abstract syntax tree.
X
Xiddoc

In Python 3.10, you can use | in isinstance:

>>> isinstance('1223', int | str) 
True

>>> isinstance('abcd', int | str) 
True

This is cool and all... but I don't really see what this is adding here or how it's really helpful.
One of the great things in python is that it avoids having random symbols all over the code. Unfortunately that property is slowly disappearing over time.
Y
Yerramsetty Rohit

You can check for type of a variable using __name__ of a type.

Ex:

>>> a = [1,2,3,4]  
>>> b = 1  
>>> type(a).__name__
'list'
>>> type(a).__name__ == 'list'
True
>>> type(b).__name__ == 'list'
False
>>> type(b).__name__
'int'

That's a terrible way of checking the type of something. I can create a random class with the name I want, and it will pass your tests. It's even worse than duck-typing.
D
Dmitry

Here is an example why duck typing is evil without knowing when it is dangerous.

For instance: Here is the Python code (possibly omitting proper indenting), note that this situation is avoidable by taking care of isinstance and issubclassof functions to make sure that when you really need a duck, you don't get a bomb.

class Bomb:
    def talk(self):
        self.explode()

    def explode(self):
        print("BOOM!, The bomb explodes.")

class Duck:
    def talk(self):
        print("I am a duck, I will not blow up if you ask me to talk.")

class Kid:
    kids_duck = None

    def __init__(self):
        print("Kid comes around a corner and asks you for money so he could buy a duck.")

    def take_duck(self, duck):
        self.kids_duck = duck
        print("The kid accepts the duck, and happily skips along.")

    def do_your_thing(self):
        print("The kid tries to get the duck to talk.")
        self.kids_duck.talk()

my_kid = Kid()
my_kid.take_duck(Bomb())
my_kid.do_your_thing()

NOTE: the example is old, naive, and the danger is greatly exaggerated. It is left as a proof of concept without major edits other than update to Python 3. I do not remember what compelled me to write this originally.


Bombs don’t talk. Don’t add nonsensical methods and this won’t happen.
@Dmitry, this is the common criticism of Duck Typing: en.wikipedia.org/wiki/Duck_typing#Criticism ... you're basically saying that any interface for which the semantics aren't enforced by the language is evil. I believe this is more the approach of Java. The whole point of Python's duck typing is that it only works when there's a commonly-upheld convention about what specific interfaces mean. For example, you could bork a lot of Python code by overriding the __file__ attribute (commonly used to identify file-like objects) to mean something else.
This all comes down to the old joke "Doctor, it hurts when I do this." ... "Then don't do that.". Unsatisfactory to somebody who is used to "if it compiles, it runs", but that's why testing obsession grew out of the dynamic language world.
@clacke that was 2 years ago but it's true. I greatly exaggerate the issue. Type checking in "dynamic space" is very different than that in "compile-time space". At runtime, in order for computer to understand what we want from it, it needs to do a lot more unavoidable work than you would in nice compile time space. When I was writing this example, I was primarily coding in C and Java and had little to no understanding of dynamic space so it seemed bad that things like this can happen without ability to prevent it via static analysis.
@clacke basically, it's too expensive to enforce types at runtime strictly because EVERYTHING must be an object(in order to map from string to any type possible), and too convenient to not have ducktyping because ducktyping allows really powerful prototyping techniques that overcome things that are normally very difficult to do with rigid interfaces. Besides, any static language faces a point where it needs to create duck typing via dynamic libraries, evaluation and stringification, or interfaces, and these things don't inherently make it evil, just very powerful.
D
DarkCygnus
isinstance(o, str)

Link to docs


While this link may answer the question, it is better to include the essential parts of the answer here and provide the link for reference. Link-only answers can become invalid if the linked page changes.
G
Granitosaurus

For more complex type validations I like typeguard's approach of validating based on python type hint annotations:

from typeguard import check_type
from typing import List

try:
    check_type('mylist', [1, 2], List[int])
except TypeError as e:
    print(e)

You can perform very complex validations in very clean and readable fashion.

check_type('foo', [1, 3.14], List[Union[int, float]])
# vs
isinstance(foo, list) and all(isinstance(a, (int, float)) for a in foo) 

P
Peter Mortensen

I think the cool thing about using a dynamic language like Python is you really shouldn't have to check something like that.

I would just call the required methods on your object and catch an AttributeError. Later on this will allow you to call your methods with other (seemingly unrelated) objects to accomplish different tasks, such as mocking an object for testing.

I've used this a lot when getting data off the web with urllib2.urlopen() which returns a file like object. This can in turn can be passed to almost any method that reads from a file, because it implements the same read() method as a real file.

But I'm sure there is a time and place for using isinstance(), otherwise it probably wouldn't be there :)


A good example of when you must use it is if you are parsing a dynamic json object. You don't know ahead of time if a field is a string or a dictionary.
S
Simply Beautiful Art

The accepted answer answers the question in that it provides the answers to the asked questions.

Q: What is the best way to check whether a given object is of a given type? How about checking whether the object inherits from a given type?

A: Use isinstance, issubclass, type to check based on types.

As other answers and comments are quick to point out however, there's a lot more to the idea of "type-checking" than that in python. Since the addition of Python 3 and type hints, much has changed as well. Below, I go over some of the difficulties with type checking, duck typing, and exception handling. For those that think type checking isn't what is needed (it usually isn't, but we're here), I also point out how type hints can be used instead.

Type Checking

Type checking is not always an appropriate thing to do in python. Consider the following example:

def sum(nums):
    """Expect an iterable of integers and return the sum."""
    result = 0
    for n in nums:
        result += n
    return result

To check if the input is an iterable of integers, we run into a major issue. The only way to check if every element is an integer would be to loop through to check each element. But if we loop through the entire iterator, then there will be nothing left for intended code. We have two options in this kind of situation.

Check as we loop. Check beforehand but store everything as we check.

Option 1 has the downside of complicating our code, especially if we need to perform similar checks in many places. It forces us to move type checking from the top of the function to everywhere we use the iterable in our code.

Option 2 has the obvious downside that it destroys the entire purpose of iterators. The entire point is to not store the data because we shouldn't need to.

One might also think that checking if checking all of the elements is too much then perhaps we can just check if the input itself is of the type iterable, but there isn't actually any iterable base class. Any type implementing __iter__ is iterable.

Exception Handling and Duck Typing

An alternative approach would be to forgo type checking altogether and focus on exception handling and duck typing instead. That is to say, wrap your code in a try-except block and catch any errors that occur. Alternatively, don't do anything and let exceptions rise naturally from your code.

Here's one way to go about catching an exception.

def sum(nums):
    """Try to catch exceptions?"""
    try:
        result = 0
        for n in nums:
            result += n
        return result
    except TypeError as e:
        print(e)

Compared to the options before, this is certainly better. We're checking as we run the code. If there's a TypeError anywhere, we'll know. We don't have to place a check everywhere that we loop through the input. And we don't have to store the input as we iterate over it.

Furthermore, this approach enables duck typing. Rather than checking for specific types, we have moved to checking for specific behaviors and look for when the input fails to behave as expected (in this case, looping through nums and being able to add n).

However, the exact reasons which make exception handling nice can also be their downfall.

A float isn't an int, but it satisfies the behavioral requirements to work. It is also bad practice to wrap the entire code with a try-except block.

At first these may not seem like issues, but here's some reasons that may change your mind.

A user can no longer expect our function to return an int as intended. This may break code elsewhere. Since exceptions can come from a wide variety of sources, using the try-except on the whole code block may end up catching exceptions you didn't intend to. We only wanted to check if nums was iterable and had integer elements. Ideally we'd like to catch exceptions our code generators and raise, in their place, more informative exceptions. It's not fun when an exception is raised from someone else's code with no explanation other than a line you didn't write and that some TypeError occured.

In order to fix the exception handling in response to the above points, our code would then become this... abomination.

def sum(nums):
    """
    Try to catch all of our exceptions only.
    Re-raise them with more specific details.
    """
    result = 0

    try:
        iter(nums)
    except TypeError as e:
        raise TypeError("nums must be iterable")

    for n in nums:
        try:
            result += int(n)
        except TypeError as e:
            raise TypeError("stopped mid iteration since a non-integer was found")

    return result

You can kinda see where this is going. The more we try to "properly" check things, the worse our code is looking. Compared to the original code, this isn't readable at all.

We could argue perhaps this is a bit extreme. But on the other hand, this is only a very simple example. In practice, your code is probably much more complicated than this.

Type Hints

We've seen what happens when we try to modify our small example to "enable type checking". Rather than focusing on trying to force specific types, type hinting allows for a way to make types clear to users.

from typing import Iterable

def sum(nums: Iterable[int]) -> int:
    result = 0
    for n in nums:
        result += n
    return result

Here are some advantages to using type-hints.

The code actually looks good now!

Static type analysis may be performed by your editor if you use type hints!

They are stored on the function/class, making them dynamically usable e.g. typeguard and dataclasses.

They show up for functions when using help(...).

No need to sanity check if your input type is right based on a description or worse lack thereof.

You can "type" hint based on structure e.g. "does it have this attribute?" without requiring subclassing by the user.

The downside to type hinting?

Type hints are nothing more than syntax and special text on their own. It isn't the same as type checking.

In other words, it doesn't actually answer the question because it doesn't provide type checking. Regardless, however, if you are here for type checking, then you should be type hinting as well. Of course, if you've come to the conclusion that type checking isn't actually necessary but you want some semblance of typing, then type hints are for you.


P
Peter Mortensen

To Hugo:

You probably mean list rather than array, but that points to the whole problem with type checking - you don't want to know if the object in question is a list, you want to know if it's some kind of sequence or if it's a single object. So try to use it like a sequence.

Say you want to add the object to an existing sequence, or if it's a sequence of objects, add them all

try:
   my_sequence.extend(o)
except TypeError:
  my_sequence.append(o)

One trick with this is if you are working with strings and/or sequences of strings - that's tricky, as a string is often thought of as a single object, but it's also a sequence of characters. Worse than that, as it's really a sequence of single-length strings.

I usually choose to design my API so that it only accepts either a single value or a sequence - it makes things easier. It's not hard to put a [ ] around your single value when you pass it in if need be.

(Though this can cause errors with strings, as they do look like (are) sequences.)


U
Ultrablendz

A simple way to check type is to compare it with something whose type you know.

>>> a  = 1
>>> type(a) == type(1)
True
>>> b = 'abc'
>>> type(b) == type('')
True

X
Xiddoc

I think the best way is to typing well your variables. You can do this by using the "typing" library.

Example:

from typing import NewType
UserId = NewType ('UserId', int)
some_id = UserId (524313`)

See https://docs.python.org/3/library/typing.html.


But you didn't demonstrate a check anywhere, did you? If you did, can you please explain where you're checking for the type in the code you have given?