如果有人想指定变量类型，我已经实现了一个包装器。

import functools
    
def type_check(func):

    @functools.wraps(func)
    def check(*args, **kwargs):
        for i in range(len(args)):
            v = args[i]
            v_name = list(func.__annotations__.keys())[i]
            v_type = list(func.__annotations__.values())[i]
            error_msg = 'Variable `' + str(v_name) + '` should be type ('
            error_msg += str(v_type) + ') but instead is type (' + str(type(v)) + ')'
            if not isinstance(v, v_type):
                raise TypeError(error_msg)

        result = func(*args, **kwargs)
        v = result
        v_name = 'return'
        v_type = func.__annotations__['return']
        error_msg = 'Variable `' + str(v_name) + '` should be type ('
        error_msg += str(v_type) + ') but instead is type (' + str(type(v)) + ')'
        if not isinstance(v, v_type):
                raise TypeError(error_msg)
        return result

    return check

使用它作为:

@type_check
def test(name : str) -> float:
    return 3.0

@type_check
def test2(name : str) -> str:
    return 3.0

>> test('asd')
>> 3.0

>> test(42)
>> TypeError: Variable `name` should be type (<class 'str'>) but instead is type (<class 'int'>)

>> test2('asd')
>> TypeError: Variable `return` should be type (<class 'str'>) but instead is type (<class 'float'>)

EDIT

如果没有声明任何参数的(或返回值的)类型，上面的代码就不能工作。下面的编辑可以提供帮助，另一方面，它只对kwarg有效，不检查args。

def type_check(func):

    @functools.wraps(func)
    def check(*args, **kwargs):
        for name, value in kwargs.items():
            v = value
            v_name = name
            if name not in func.__annotations__:
                continue
                
            v_type = func.__annotations__[name]

            error_msg = 'Variable `' + str(v_name) + '` should be type ('
            error_msg += str(v_type) + ') but instead is type (' + str(type(v)) + ') '
            if not isinstance(v, v_type):
                raise TypeError(error_msg)

        result = func(*args, **kwargs)
        if 'return' in func.__annotations__:
            v = result
            v_name = 'return'
            v_type = func.__annotations__['return']
            error_msg = 'Variable `' + str(v_name) + '` should be type ('
            error_msg += str(v_type) + ') but instead is type (' + str(type(v)) + ')'
            if not isinstance(v, v_type):
                    raise TypeError(error_msg)
        return result

    return check

许多语言都有特定类型的变量，变量有一个值。Python没有变量;它有对象，你用名字来指代这些对象。

在其他语言中，当你说:

a = 1

然后，变量(通常是整数)将其内容更改为值1。

在Python中,

a = 1

意思是“使用名称a来指代对象1”。你可以在交互式Python会话中执行以下操作:

>>> type(1)
<type 'int'>

函数类型使用对象1调用;因为每个对象都知道它的类型，所以type很容易找到该类型并返回它。

同样，无论何时定义函数

def funcname(param1, param2):

该函数接收两个对象，并将它们命名为param1和param2，而不考虑它们的类型。如果您想要确保接收到的对象是特定类型的，那么就按照它们是所需的类型来编写函数，如果不是，则捕获抛出的异常。抛出的异常通常是TypeError(您使用了无效操作)和AttributeError(您试图访问不存在的成员(方法也是成员))。

在Python中，所有东西都有类型。如果参数类型支持，Python函数将执行它被要求执行的任何操作。

示例:foo将添加所有可以__add__ed;)的东西，而不太关心它的类型。这意味着，为了避免失败，你应该只提供那些支持加法的东西。

def foo(a,b):
    return a + b

class Bar(object):
    pass

class Zoo(object):
    def __add__(self, other):
        return 'zoom'

if __name__=='__main__':
    print foo(1, 2)
    print foo('james', 'bond')
    print foo(Zoo(), Zoo())
    print foo(Bar(), Bar()) # Should fail

我在其他答案中没有看到这个，所以我把这个加到锅里。

正如其他人所说，Python不会对函数或方法参数强制执行类型。假设您知道自己在做什么，如果您确实需要知道传入的内容的类型，您将检查它并决定自己要做什么。

完成此任务的主要工具之一是isinstance()函数。

例如，如果我编写了一个希望获得原始二进制文本数据的方法，而不是普通的utf-8编码字符串，那么我可以在进入时检查参数的类型，并根据所找到的参数进行调整，或者引发一个异常来拒绝。

def process(data):
    if not isinstance(data, bytes) and not isinstance(data, bytearray):
        raise TypeError('Invalid type: data must be a byte string or bytearray, not %r' % type(data))
    # Do more stuff

Python还提供了各种深入对象的工具。如果您足够勇敢，甚至可以使用importlib动态地为任意类创建自己的对象。我这样做是为了从JSON数据重新创建对象。这样的事情在像c++这样的静态语言中是一场噩梦。

Alex Martelli解释道，

正常的、Pythonic的、首选的解决方案几乎总是“duck typing”:尝试使用参数，好像它是某种所需的类型，在try/except语句中执行它，捕捉如果参数实际上不是该类型(或任何其他类型，很好地模仿它;-)可能出现的所有异常，并在except子句中尝试其他内容(使用参数“as if”它是其他类型)。

阅读他的文章以获得有用的信息。

在这个页面上，有一个臭名昭著的例外值得提及。

当str函数调用__str__类方法时，它会巧妙地检查其类型:

>>> class A(object):
...     def __str__(self):
...         return 'a','b'
...
>>> a = A()
>>> print a.__str__()
('a', 'b')
>>> print str(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __str__ returned non-string (type tuple)

就好像Guido提示我们，如果程序遇到意外类型，应该引发哪个异常。