也许在我使用强类型语言（Java）的日子里，我经常发现自己编写函数，然后强制进行类型检查。例如：
def orSearch(d, query):
assert (type(d) == dict)
assert (type(query) == list)
我应该继续这样做吗？做/不做这件事有什么好处？
停止这样做。
使用"动态"语言（对于值*是强类型的，对于变量是非类型的，并且是后期绑定的）的意义在于，您的函数可以是适当的多态性的，因为它们将处理任何支持您的函数所依赖的接口的对象（"duck typeing"）。
Python定义了许多通用协议（例如，可迭代的），不同类型的对象可以在不相互关联的情况下实现这些协议。协议本身并不是一种语言特性（与java接口不同）。
这样做的实际结果是，一般来说，只要你理解语言中的类型，并适当地进行评论（包括使用文档字符串，这样其他人也能理解你程序中的类型），你通常可以写更少的代码，因为你不必围绕你的类型系统进行编码。你最终不会为不同的类型编写相同的代码，只需要使用不同的类型声明（即使类处于不相交的层次结构中），如果你想只编写一段代码，你也不必弄清楚哪些类型转换是安全的，哪些不安全。
理论上，还有其他语言提供了同样的东西：类型推断语言。最流行的是C++（使用模板）和Haskell。在理论上（可能在实践中），您最终可能会编写更少的代码，因为类型是静态解析的，因此您不必编写异常处理程序来处理被传递的错误类型。我发现他们仍然要求你对类型系统进行编程，而不是对你程序中的实际类型进行编程（他们的类型系统是定理证明器，为了便于处理，他们不会分析你的整个程序）。如果这听起来很棒，可以考虑使用其中一种语言，而不是python（或ruby、smalltalk或任何lisp变体）。
在python（或任何类似的动态语言）中，当对象不支持特定方法时，您将希望使用异常来捕获，而不是进行类型测试。在这种情况下，要么让它进入堆栈，要么抓住它，并引发关于不正确类型的异常。这种类型的"请求原谅胜过请求许可"编码是惯用的python，极大地简化了代码。
*在实践中。类更改在Python和Smalltalk中是可能的，但很少发生。这也不同于用低级语言选角。
更新：您可以使用mypy在生产之外静态检查您的python。注释你的代码，这样他们就可以检查他们的代码是否一致，如果他们愿意的话，可以这样做；如果他们愿意的话，也可以用yolo。
在大多数情况下，它会干扰鸭子类型和继承。
-
继承：你当然打算写一些具有效果的东西
assert isinstance(d, dict)以确保您的代码也能正确地使用
dict的子类。我认为这与Java中的用法类似。但是Python有Java没有的东西，即 -
Duck类型：大多数内置函数不要求对象属于特定的类，只要求它具有行为正确的某些成员函数。例如，
for循环只要求循环变量是可迭代的，这意味着它具有成员函数__iter__()和next()，并且它们的行为正确。
因此，如果您不想关闭Python的全部功能，请不要检查生产代码中的特定类型。（不过，它可能对调试有用。）
如果您坚持在代码中添加类型检查，您可能需要研究注释以及它们如何简化您必须编写的内容。StackOverflow上的一个问题介绍了一个利用注释的小型模糊类型检查器。以下是基于您的问题的示例：
>>> 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'>
>>>
你可能会看到类型检查器，然后想，"这到底在做什么？"我决定自己找出答案，并将其转化为可读代码。第二个草案取消了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
这是一种非惯用的做事方式。通常在Python中，您会使用try/except测试。
def orSearch(d, query):
try:
d.get(something)
except TypeError:
print("oops")
try:
foo = query[:2]
except TypeError:
print("durn")
就我个人而言，我不喜欢断言程序员似乎看到了麻烦的到来，但却懒得考虑如何处理它们，另一个问题是，您的示例会断言，如果任何一个参数是从您期望的参数派生的类，即使这些类应该可以工作！-在你上面的例子中，我会选择这样的东西：
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
...
注意，只有当类型与预期完全一致时，类型才匹配，isistance也适用于派生类。例如：
>>> 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++中断言，因为如果它留在代码中，那么几年后就会有人做出应该被它捕获的更改，在调试中测试得不够好，（甚至根本不测试它），编译为可交付，发布模式，-它删除了所有断言，即所有以这种方式进行的错误检查，现在我们有不可靠的代码，并且很难找到问题
当您需要进行类型检查时，我同意Steve的方法。我不经常发现有必要在Python中进行类型检查，但至少有一种情况是这样做的。不检查类型可能会返回错误的答案，这将在以后的计算中导致错误。这类错误可能很难追踪，我在Python中已经经历过很多次了。和你一样，我首先学习了Java，不必经常与它们打交道。
假设您有一个简单的函数，它需要一个数组并返回第一个元素。
def func(arr): return arr[0]
如果用数组调用它，则会得到数组的第一个元素。
>>> func([1,2,3])
1
如果用字符串或实现getitem魔术方法的任何类的对象调用它，也会得到响应。
>>> func("123")
'1'
这会给你一个回应，但在这种情况下，它的类型是错误的。这种情况可能发生在具有相同方法签名的对象上。你可能要到很久以后的计算中才能发现错误。如果您在自己的代码中确实遇到了这种情况，通常意味着之前的计算中存在错误，但在那里进行检查会更早发现错误。然而，如果您正在为他人编写python包，那么您可能无论如何都应该考虑它。
检查不应该导致很大的性能损失，但这会使代码更难阅读，这在Python世界中是一件大事。
两件事。
首先，如果你愿意花大约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