从静态或编译时类型检查的意义上讲，Python不是强类型的。

大多数Python代码都属于所谓的“Duck Typing”——例如，你寻找一个对象上读取的方法——你不关心对象是磁盘上的文件还是套接字，你只想从中读取N个字节。

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

正如其他人所说，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++这样的静态语言中是一场噩梦。

Python并不关心你将什么传递给它的函数。当您调用my_func(a,b)时，param1和param2变量将保存a和b的值。Python不知道您正在使用正确的类型调用函数，并期望程序员处理这一点。如果函数将使用不同类型的参数调用，您可以使用try/except块包装访问它们的代码，并以您想要的任何方式计算参数。

要有效地使用typing模块(Python 3.5新增)，请包含all(*)。

from typing import *

你将准备使用:

List, Tuple, Set, Map - for list, tuple, set and map respectively.
Iterable - useful for generators.
Any - when it could be anything.
Union - when it could be anything within a specified set of types, as opposed to Any.
Optional - when it might be None. Shorthand for Union[T, None].
TypeVar - used with generics.
Callable - used primarily for functions, but could be used for other callables.

然而，你仍然可以使用类型名称，如int, list, dict，…

其他的回答很好地解释了鸭子的打字方式和tzot的简单回答:

Python没有变量，不像其他语言，变量有类型和值;它具有指向对象的名称，这些对象知道它们的类型。

然而，自2010年(第一次提出这个问题的时候)以来，有一件有趣的事情发生了变化，那就是PEP 3107的实现(在Python 3中实现)。现在你实际上可以像这样指定形参的类型和函数的返回类型:

def pick(l: list, index: int) -> int:
    return l[index]

这里我们可以看到pick有两个参数，一个列表l和一个整数索引。它还应该返回一个整数。

因此，这里暗示l是一个整数列表，我们可以很容易地看到，但对于更复杂的函数，列表应该包含什么可能有点令人困惑。我们还希望index的默认值为0。要解决这个问题，你可以选择这样写pick:

def pick(l: "list of ints", index: int = 0) -> int:
    return l[index]

请注意，我们现在放入一个字符串作为l类型，这在语法上是允许的，但它不适用于以编程方式解析(稍后我们将回到这一点)。

需要注意的是，如果你将浮点数传递给索引，Python不会引发TypeError，原因是Python设计哲学中的主要观点之一:“我们都是成年人”，这意味着你应该知道什么可以传递给函数，什么不能。如果你真的想编写抛出TypeErrors的代码，你可以使用isinstance函数来检查传入的参数是否属于正确的类型或它的子类，如下所示:

def pick(l: list, index: int = 0) -> int:
    if not isinstance(l, list):
        raise TypeError
    return l[index]

更多关于为什么你应该很少这样做，你应该做什么，在下一节和评论中讨论。

PEP 3107不仅提高了代码的可读性，而且还提供了几个合适的用例，您可以在这里阅读。

---

随着PEP 484的引入，类型注释在Python 3.5中得到了更多的关注，PEP 484引入了用于类型提示的标准模块类型。

这些类型提示来自类型检查器myypy (GitHub)，它现在与PEP 484兼容。

typing模块提供了一个非常全面的类型提示集合，包括:

List, Tuple, Set, Dict -分别用于List, Tuple, Set和Dict。 Iterable -用于生成器。 什么都有可能。 Union——可以是指定类型集中的任何内容，而不是Any。 可选—当它可能为None时。联合的简写[T, None]。 TypeVar -与泛型一起使用。 可调用的-主要用于函数，但也可以用于其他可调用的。

这些是最常见的类型提示。在typing模块的文档中可以找到完整的清单。

下面是使用typing模块中引入的注释方法的旧示例:

from typing import List

def pick(l: List[int], index: int) -> int:
    return l[index]

一个强大的特性是Callable，它允许您键入注释以函数作为参数的方法。例如:

from typing import Callable, Any, Iterable

def imap(f: Callable[[Any], Any], l: Iterable[Any]) -> List[Any]:
    """An immediate version of map, don't pass it any infinite iterables!"""
    return list(map(f, l))

如果使用TypeVar而不是Any，上面的示例可能会变得更加精确，但这是留给读者的练习，因为我相信我的答案中已经包含了太多关于类型提示所支持的美妙新特性的信息。

---

以前，当使用Sphinx编写Python代码时，可以通过编写如下格式的文档字符串来获得上述一些功能:

def pick(l, index):
    """
    :param l: list of integers
    :type l: list
    :param index: index at which to pick an integer from *l*
    :type index: int
    :returns: integer at *index* in *l*
    :rtype: int
    """
    return l[index]

As you can see, this takes a number of extra lines (the exact number depends on how explicit you want to be and how you format your docstring). But it should now be clear to you how PEP 3107 provides an alternative that is in many (all?) ways superior. This is especially true in combination with PEP 484 which, as we have seen, provides a standard module that defines a syntax for these type hints/annotations that can be used in such a way that it is unambiguous and precise yet flexible, making for a powerful combination.

在我个人看来，这是Python有史以来最伟大的特性之一。我等不及人们开始利用它的力量了。抱歉回答这么长，但这就是我兴奋时发生的事情。

---

一个大量使用类型提示的Python代码示例可以在这里找到。

Python是强类型的，因为每个对象都有一个类型，每个对象都知道它的类型，不可能意外或故意使用一个类型的对象，“好像”它是一个不同类型的对象，对象上的所有基本操作都委托给它的类型。

这和名字无关。Python中的名称没有“类型”:如果定义了名称，则名称指向对象，并且对象确实具有类型(但这实际上并不强制名称具有类型:名称就是名称)。

A name in Python can perfectly well refer to different objects at different times (as in most programming languages, though not all) -- and there is no constraint on the name such that, if it has once referred to an object of type X, it's then forevermore constrained to refer only to other objects of type X. Constraints on names are not part of the concept of "strong typing", though some enthusiasts of static typing (where names do get constrained, and in a static, AKA compile-time, fashion, too) do misuse the term this way.