现有的答案大多同意Python是一种强类型语言，因为它不会隐式地将值从一种类型转换为另一种类型。这些答案提到了将字符串添加到整数的情况来支持这种说法;"foo" + 3在Python中引发TypeError，而在Javascript(通常被认为是弱类型语言)中，数字3隐式转换为字符串，然后连接，因此结果是字符串"foo3"。

但在其他一些情况下，Python确实会执行隐式类型转换:

# implicit conversion from int to float
1 + 1.0

# implicit conversion from list to bool
if []: pass

相比之下，f#(通常被认为是强类型语言)不允许这两种:

  1 + 1.0;;
  ----^^^
error FS0001: The type 'float' does not match the type 'int'

  if [] then 1 else 2;;
  ---^^
error FS0001: This expression was expected to have type bool but here has type 'a list  

因此，“强类型”和“弱类型”语言并没有严格的二分法，相反，我们可以说Python比Javascript更强类型，但没有f#强类型。

根据这篇wiki Python文章，Python是动态类型和强类型的(也提供了一个很好的解释)。

也许您正在考虑静态类型语言，其中类型在程序执行期间不能更改，并且在编译时进行类型检查以检测可能的错误。

你可能会对这个SO问题感兴趣:动态类型语言还是静态类型语言，这篇关于类型系统的维基百科文章提供了更多信息

你混淆了“强类型”和“动态类型”。

我不能通过添加字符串'12'来改变1的类型，但我可以选择在变量中存储什么类型，并在程序运行时更改它。

与动态类型相对的是静态类型;变量类型的声明在程序的生命周期内不会改变。强类型的反面是弱类型;值的类型可以在程序的生命周期内更改。

Python是强类型的，因为它没有未检查的动态类型错误。换句话说，您不能违反它的类型系统。

定义

Type: set of values. It partially defines the intended usage (behaviour) of its values. It can be specified in extension with an enumeration or in intension with a predicate. Type system: system checking that values are used as intended, avoiding undefined behaviour partially. Undefined behaviour should be avoided because it can lead to late program crash or silent loss of data and production of incorrect results. Typed language: language with a type system. Type error: program error checkable by a type system. Expression: program text denoting a value. Static/dynamic type: compile-time/run-time type of an expression. The run-time type of an expression is the type of the value that it denotes. Static/dynamic type system: type system checking static/dynamic types. Statically/dynamically typed language: language with a static/dynamic type system. Static/dynamic type error: program error checkable by a static/dynamic type system. Weakly/strongly typed language: language with/without unchecked dynamic type errors. Statically typed, dynamically typed, or both imply strongly typed. Monomorphic/polymorphic expression: expression having a single dynamic type/multiple dynamic types. A monomorphic expression has single intended usage, and a polymorphic expression has multiple intended usage. Universal/ad-hoc polymorphic expression: real/virtual polymorphic expression. A real polymorphic expression denotes a single value that has multiple types, and a virtual polymorphic expression denotes multiple values that have single types. Parametric/inclusion polymorphic expression: universal polymorphic expression based on generic types/subtypes of a type (e.g. the C++ expression & denotes a single T* (T&) operator value where T is a generic type/the C++ expression std::exception denotes a single S class value where S is a generic subtype of std::exception). Overloading/coercion polymorphic expression: ad-hoc polymorphic expression based on expression/value conversion (e.g. the C++ expression + denotes int (int&, int&) and float (float&, float&) operator values/the C++ expression 3.5 denotes float and bool values).

参考

Cardelli (Luca)， Wegner (Peter)，“关于理解类型，数据抽象和多态性”，计算调查，第17卷，第4期，1985，第471-523页，DOI: https://doi.org/10.1145/6041.6042。

这个问题已经回答过几次了，但Python是一种强类型语言:

>>> x = 3
>>> y = '4'
>>> print(x+y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

JavaScript代码:

var x = 3    
var y = '4'
alert(x + y) //Produces "34"

这就是弱类型和强类型的区别。弱类型自动尝试从一种类型转换为另一种类型，这取决于上下文(例如Perl)。强类型从不隐式转换。

您的困惑在于误解了Python如何将值绑定到名称(通常称为变量)。

在Python中，名称没有类型，所以你可以这样做:

bob = 1
bob = "bob"
bob = "An Ex-Parrot!"

名字可以绑定到任何东西上:

>>> def spam():
...     print("Spam, spam, spam, spam")
...
>>> spam_on_eggs = spam
>>> spam_on_eggs()
Spam, spam, spam, spam

欲进一步阅读:

https://en.wikipedia.org/wiki/Dynamic_dispatch

还有稍微相关但更高级的:

http://effbot.org/zone/call-by-object.htm

Python是强动态类型的。

强类型意味着值的类型不会以意外的方式改变。只包含数字的字符串不会像Perl中那样神奇地变成数字。每次类型更改都需要显式转换。 动态类型意味着运行时对象(值)具有类型，而静态类型中变量具有类型。

至于你的例子

bob = 1
bob = "bob"

这是因为变量没有类型;它可以命名任何对象。在bob=1之后，你会发现type(bob)返回int，但在bob="bob"之后，它返回str。(注意，type是一个常规函数，所以它计算其参数，然后返回值的类型。)

与此相比，老式的C语言是弱静态类型的，因此指针和整数几乎是可以互换的。(现代ISO C在很多情况下需要转换，但我的编译器在默认情况下仍然很宽容。)

我必须补充一点，强类型和弱类型更多的是一个连续体，而不是一个布尔选择。c++具有比C更强的类型(需要更多的转换)，但类型系统可以通过使用指针强制转换来颠覆。

在动态语言(如Python)中，类型系统的强度实际上取决于其原语和库函数对不同类型的响应方式。例如，+是重载的，所以它对两个数字或两个字符串有效，而不是一个字符串和一个数字。这是在实现+时做出的设计选择，但从语言的语义来看并不是必须的。事实上，当你在自定义类型上重载+时，你可以让它隐式地将任何东西转换为数字:

def to_number(x):
    """Try to convert function argument to float-type object."""
    try: 
        return float(x) 
    except (TypeError, ValueError): 
        return 0 

class Foo:
    def __init__(self, number): 
        self.number = number

    def __add__(self, other):
        return self.number + to_number(other)

类Foo的实例可以添加到其他对象:

>>> a = Foo(42)
>>> a + "1"
43.0
>>> a + Foo
42
>>> a + 1
43.0
>>> a + None
42

请注意，尽管强类型Python完全可以添加int和float类型的对象，并返回float类型的对象(例如，int(42) + float(1)返回43.0)。另一方面，由于类型之间的不匹配，如果尝试以下(42::Integer) + (1:: Float)， Haskell会抱怨。这使得Haskell成为一种严格的类型语言，其中类型是完全不相连的，并且只能通过类型类进行受控的重载。