也许作为我使用强类型语言（Java）的日子的残余，我经常发现自己编写函数然后强制进行类型检查。例如：
def orSearch(d, query):
assert (type(d) == dict)
assert (type(query) == list)
我应该继续这样做吗？做/不做这有什么好处？
答案 0 :(得分：9)
在大多数情况下，它会干扰鸭子打字和继承。
继承：你当然打算写一些具有
效果的东西assert isinstance(d, dict)
确保您的代码也能正常使用dict的子类。我认为这类似于Java中的用法。但Python有一些Java没有的东西，即
鸭子输入：大多数内置函数不要求对象属于特定类，只要它具有以正确方式运行的某些成员函数。 for循环，例如，只需要循环变量是 iterable ，这意味着它具有成员函数__iter__()和next()，并且它们行为正确。
因此，如果您不想关闭Python的全部功能，请不要检查生产代码中的特定类型。 （尽管如此，它可能对调试很有用。）
答案 1 :(得分：7)
停止这样做。
使用“动态”语言（强烈键入值*，无类型变量和后期绑定）的意义在于，您的函数可以是正确的多态，因为它们将处理任何支持的对象你的函数所依赖的接口（“duck typing”）。
Python定义了许多不同类型的对象可以实现而不相互关联的通用协议（例如，可迭代的）。协议本身不是 语言功能（与java接口不同）。这样做的实际结果是，一般来说，只要你理解你的语言类型，并且你恰当地评论（包括文档字符串，所以其他人也理解你的程序中的类型），你通常可以少写代码，因为您不必围绕您的类型系统进行编码。你最终不会为不同的类型编写相同的代码，只是使用不同的类型声明（即使这些类是不相连的层次结构），你也不必弄清楚哪些转换是安全的，哪些不是，如果你我想尝试只编写一段代码。
理论上还有其他语言提供同样的东西：输入推断语言。最流行的是C ++（使用模板）和Haskell。理论上（可能在实践中），您最终可以编写更少的代码，因为类型是静态解析的，因此您不必编写异常处理程序来处理传递错误的类型。我发现他们仍然需要你编程到类型系统，而不是你的程序中的实际类型（他们的类型系统是定理证明，并且易于处理，他们不分析你的整个程序）。如果这听起来不错，请考虑使用其中一种语言而不是python（或ruby，smalltalk或任何lisp变体）。
而不是类型测试，在python（或任何类似的动态语言）中，您将希望在对象不支持特定方法时使用异常来捕获。在这种情况下，要么让它上升，要么抓住它，并提出关于不正确类型的异常。这种类型的“更好地请求宽恕而非许可”编码是惯用的python，并且极大地促进了更简单的代码。
*在实践中。 Python和Smalltalk中的类更改是可能的，但很少见。它也与使用低级语言进行投射不同。
答案 2 :(得分：3)
如果您坚持在代码中添加类型检查，您可能需要查看annotations以及它们如何简化您必须编写的内容。 StackOverflow上的questions之一引入了一个利用注释的小型混淆式检查器。以下是基于您的问题的示例：
>>> def statictypes(a):
def b(a, b, c):
if b in a and not isinstance(c, a[b]): raise TypeError('{} should be {}, not {}'.format(b, a[b], type(c)))
return c
return __import__('functools').wraps(a)(lambda *c: b(a.__annotations__, 'return', a(*[b(a.__annotations__, *d) for d in zip(a.__code__.co_varnames, c)])))
>>> @statictypes
def orSearch(d: dict, query: dict) -> type(None):
pass
>>> orSearch({}, {})
>>> orSearch([], {})
Traceback (most recent call last):
File "<pyshell#162>", line 1, in <module>
orSearch([], {})
File "<pyshell#155>", line 5, in <lambda>
return __import__('functools').wraps(a)(lambda *c: b(a.__annotations__, 'return', a(*[b(a.__annotations__, *d) for d in zip(a.__code__.co_varnames, c)])))
File "<pyshell#155>", line 5, in <listcomp>
return __import__('functools').wraps(a)(lambda *c: b(a.__annotations__, 'return', a(*[b(a.__annotations__, *d) for d in zip(a.__code__.co_varnames, c)])))
File "<pyshell#155>", line 3, in b
if b in a and not isinstance(c, a[b]): raise TypeError('{} should be {}, not {}'.format(b, a[b], type(c)))
TypeError: d should be <class 'dict'>, not <class 'list'>
>>> orSearch({}, [])
Traceback (most recent call last):
File "<pyshell#163>", line 1, in <module>
orSearch({}, [])
File "<pyshell#155>", line 5, in <lambda>
return __import__('functools').wraps(a)(lambda *c: b(a.__annotations__, 'return', a(*[b(a.__annotations__, *d) for d in zip(a.__code__.co_varnames, c)])))
File "<pyshell#155>", line 5, in <listcomp>
return __import__('functools').wraps(a)(lambda *c: b(a.__annotations__, 'return', a(*[b(a.__annotations__, *d) for d in zip(a.__code__.co_varnames, c)])))
File "<pyshell#155>", line 3, in b
if b in a and not isinstance(c, a[b]): raise TypeError('{} should be {}, not {}'.format(b, a[b], type(c)))
TypeError: query should be <class 'dict'>, not <class 'list'>
>>>
你可能会看一下类型检查器并想知道，＆＃34;这到底是做什么的？＆＃34;我决定自己找出来并把它变成可读的代码。第二稿取消了b函数（你可以称之为verify）。第三个也是最后一个草案做了一些改进，下面显示了您的使用：
import functools
def statictypes(func):
template = '{} should be {}, not {}'
@functools.wraps(func)
def wrapper(*args):
for name, arg in zip(func.__code__.co_varnames, args):
klass = func.__annotations__.get(name, object)
if not isinstance(arg, klass):
raise TypeError(template.format(name, klass, type(arg)))
result = func(*args)
klass = func.__annotations__.get('return', object)
if not isinstance(result, klass):
raise TypeError(template.format('return', klass, type(result)))
return result
return wrapper
修改
自从这个答案写完以来已经有四年多了，从那时起Python中发生了很多变化。由于这些变化和语言的个人发展，重新访问类型检查代码并重写它以利用新功能和改进的编码技术似乎是有益的。因此，提供了以下修订版，对statictypes（现在重命名为static_types）函数装饰器进行了一些微小的改进。
#! /usr/bin/env python3
import functools
import inspect
def static_types(wrapped):
def replace(obj, old, new):
return new if obj is old else obj
signature = inspect.signature(wrapped)
parameter_values = signature.parameters.values()
parameter_names = tuple(parameter.name for parameter in parameter_values)
parameter_types = tuple(
replace(parameter.annotation, parameter.empty, object)
for parameter in parameter_values
)
return_type = replace(signature.return_annotation, signature.empty, object)
@functools.wraps(wrapped)
def wrapper(*arguments):
for argument, parameter_type, parameter_name in zip(
arguments, parameter_types, parameter_names
):
if not isinstance(argument, parameter_type):
raise TypeError(f'{parameter_name} should be of type '
f'{parameter_type.__name__}, not '
f'{type(argument).__name__}')
result = wrapped(*arguments)
if not isinstance(result, return_type):
raise TypeError(f'return should be of type '
f'{return_type.__name__}, not '
f'{type(result).__name__}')
return result
return wrapper
答案 3 :(得分：2)
这是一种非惯用的做事方式。通常在Python中，您可以使用try/except测试。
def orSearch(d, query):
try:
d.get(something)
except TypeError:
print("oops")
try:
foo = query[:2]
except TypeError:
print("durn")
答案 4 :(得分：2)
我个人厌恶断言似乎程序员可能会遇到麻烦而无法考虑如何处理它们，另一个问题是如果任一参数是派生自的类，你的示例将断言你期待的那些，即使这些课程应该有效！ - 在上面的例子中，我会找到类似的东西：
def orSearch(d, query):
""" Description of what your function does INCLUDING parameter types and descriptions """
result = None
if not isinstance(d, dict) or not isinstance(query, list):
print "An Error Message"
return result
...
如果类型与预期完全一致，则注释类型仅匹配，isinstance也适用于派生类。 e.g：
>>> class dd(dict):
... def __init__(self):
... pass
...
>>> d1 = dict()
>>> d2 = dd()
>>> type(d1)
<type 'dict'>
>>> type(d2)
<class '__main__.dd'>
>>> type (d1) == dict
True
>>> type (d2) == dict
False
>>> isinstance(d1, dict)
True
>>> isinstance(d2, dict)
True
>>>
您可以考虑抛出自定义异常而不是断言。您甚至可以通过检查参数是否具有您需要的方法来进一步概括。
BTW 对我来说可能很挑剔，但我总是试图避免在C / C ++中断言，理由是如果它留在代码中那么几年后会有人制作一个应该被它捕获的变化，而不是在调试中测试它以便发生这种变化，（甚至根本不测试它），编译为可交付，释放模式， - 它删除所有断言，即所有错误检查是这样做的，现在我们有不可靠的代码，并且很难找到问题。
答案 5 :(得分：1)
当你需要进行类型检查时，我同意Steve的方法。我不经常发现需要在Python中进行类型检查，但至少有一种情况我会这样做。这是不检查类型可能返回错误答案的地方，这将导致计算后期出错。这些错误很难追查，我在Python中经历了很多次。和你一样，我先学习Java，而且不必经常处理它们。
假设你有一个简单的函数需要一个数组并返回第一个元素。
def func(arr): return arr[0]
如果用数组调用它，你将得到数组的第一个元素。
>>> func([1,2,3])
1
如果您使用字符串或任何实现getitem魔术方法的类的对象调用它，您也会得到响应。
>>> func("123")
'1'
这会给你一个回复，但在这种情况下它是错误的类型。对于具有相同method signature的对象，可能会发生这种情况。在计算之后很久才会发现错误。如果您确实在自己的代码中遇到过这种情况，通常意味着先前的计算中存在错误，但是检查一下会提前发现它。但是，如果您正在为其他人编写python包，那么无论如何都应该考虑这个问题。
您不应该对检查产生很大的性能损失，但这会使您的代码更难以阅读，这在Python世界中是一件大事。
答案 6 :(得分：0)
两件事。
首先，如果你愿意花200美元，你可以得到一个非常好的python IDE。我使用PyCharm并给我留下了深刻的印象。 （这是由为C＃制作ReSharper的人。）它会在你编写代码时分析你的代码，并寻找变量类型错误的地方（在其他一堆东西中）。
第二
在我使用PyCharm之前，我遇到了同样的问题 - 也就是说，我忘记了我写的函数的特定签名。我可能在某个地方找到了这个，但也许我写了它（我现在不记得了）。但无论如何，它是一个装饰器，你可以使用你的函数定义来为你进行类型检查。
像这样称呼
@require_type('paramA', str)
@require_type('paramB', list)
@require_type('paramC', collections.Counter)
def my_func(paramA, paramB, paramC):
paramB.append(paramC[paramA].most_common())
return paramB
无论如何，这是装饰者的代码。
def require_type(my_arg, *valid_types):
'''
A simple decorator that performs type checking.
@param my_arg: string indicating argument name
@param valid_types: *list of valid types
'''
def make_wrapper(func):
if hasattr(func, 'wrapped_args'):
wrapped = getattr(func, 'wrapped_args')
else:
body = func.func_code
wrapped = list(body.co_varnames[:body.co_argcount])
try:
idx = wrapped.index(my_arg)
except ValueError:
raise(NameError, my_arg)
def wrapper(*args, **kwargs):
def fail():
all_types = ', '.join(str(typ) for typ in valid_types)
raise(TypeError, '\'%s\' was type %s, expected to be in following list: %s' % (my_arg, all_types, type(arg)))
if len(args) > idx:
arg = args[idx]
if not isinstance(arg, valid_types):
fail()
else:
if my_arg in kwargs:
arg = kwargs[my_arg]
if not isinstance(arg, valid_types):
fail()
return func(*args, **kwargs)
wrapper.wrapped_args = wrapped
return wrapper
return make_wrapper