在许多实际情况下，您也可以使用@functools.singledispatch来定义泛型函数（由多个函数组成的函数，对不同类型执行相同的操作），而不是使用类型或isinstance。

换句话说，当您有如下代码时，您可能希望使用它：

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

下面是一个工作原理的小示例：

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

此外，我们可以使用抽象类同时覆盖几种类型：

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

使用类型（）

x='hello this is a string'
print(type(x))

输出

<class 'str'>

要仅提取str，请使用

x='this is a string'
print(type(x).__name__)#you can use__name__to find class

输出

str

如果使用类型（变量）__name__我们可以读

为了完整起见，isinstance不适用于非实例的子类型的类型检查。虽然这很有道理，但没有一个答案（包括公认的答案）涵盖了这一点。请使用issubclass。

>>> class a(list):
...   pass
... 
>>> isinstance(a, list)
False
>>> issubclass(a, list)
True

在许多实际情况下，您也可以使用@functools.singledispatch来定义泛型函数（由多个函数组成的函数，对不同类型执行相同的操作），而不是使用类型或isinstance。

换句话说，当您有如下代码时，您可能希望使用它：

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

下面是一个工作原理的小示例：

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

此外，我们可以使用抽象类同时覆盖几种类型：

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

尝试一下可能会更像蟒蛇。。。除了块。这样，如果你有一个像列表一样嘎嘎作响的类，或者像格言一样嘎嘎作响，那么不管它的类型是什么，它都会表现得很好。

为了澄清，“区分”变量类型的首选方法是鸭子类型：只要变量响应的方法（和返回类型）是您的子例程所期望的，就要像您期望的那样对待它。例如，如果您有一个类用getattr和setattr重载括号运算符，但使用了一些有趣的内部方案，如果这正是它试图模仿的，那么它应该像一本字典一样。

类型（A）的另一个问题是类型（B）检查，如果A是B的子类，那么当您希望它是真的时，它的计算结果为假。如果一个对象是一个列表的子类，那么它应该像列表一样工作：检查另一个答案中显示的类型将防止这种情况发生。（然而，这一点是可行的）。

value = 12
print(type(value)) # will return <class 'int'> (means integer)

或者你可以这样做

value = 12
print(type(value) == int) # will return true