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。

class testme(object):
    ''' A test object '''
    def __init__(self):
        self.y = 0

def f(aTestMe1, aTestMe2):
    return aTestMe1.y + aTestMe2.y




c = testme            #get a variable to the class
c.x = 10              #add an attribute x inital value 10
c.y = 4               #change the default attribute value of y to 4

t = testme()          # declare t to be an instance object of testme
r = testme()          # declare r to be an instance object of testme

t.y = 6               # set t.y to a number
r.y = 7               # set r.y to a number

print(f(r,t))         # call function designed to operate on testme objects

r.y = "I am r.y"      # redefine r.y to be a string

print(f(r,t))         #POW!!!!  not good....

在一个大型系统中，上述情况会在很长一段时间内造成代码不可维护的噩梦。随便你怎么称呼它，但“动态”改变变量类型的能力只是一个坏主意……

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

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

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

术语“强类型”没有明确的定义。

因此，这个词的使用取决于你和谁说话。

我不认为任何没有显式声明变量类型或没有静态类型的语言是强类型的。

强类型不只是排除转换(例如，“自动”将整数转换为字符串)。它排除了赋值(即改变变量的类型)。

如果以下代码编译(解释)，则该语言不是强类型的:

Foo = 1 Foo = "1"

在强类型语言中，程序员可以“依赖”类型。

例如，如果程序员看到声明，

UINT64 kZarkCount;

并且他或她知道20行之后，kZarkCount仍然是UINT64(只要它出现在同一个块中)——而不必检查中间的代码。

Python变量存储对表示该值的目标对象的无类型引用。

任何赋值操作都意味着将未类型化的引用赋值给已赋值的对象——即对象通过原始引用和新引用(已计数)共享。

值类型绑定到目标对象，而不是引用值。(强)类型检查是在执行带有该值的操作(运行时)时执行的。

换句话说，变量(技术上)没有类型——如果想要精确，那么按照变量类型来考虑是没有意义的。但是引用是自动解除引用的我们实际上是根据目标对象的类型来考虑的。

TLDR;

Python类型是动态的，所以你可以将字符串变量更改为int(在静态语言中你不能)

x = 'somestring'
x = 50

Python类型是强的，所以你不能合并类型:

'foo' + 3 --> TypeError: cannot concatenate 'str' and 'int' objects

在弱类型Javascript中，这种情况会发生……

 'foo'+3 = 'foo3'

关于类型推断

有些语言(如Java)强制显式声明对象类型

int x = 50;

像Kotlin这样的其他人只是从值本身推断它是一个int型

x = 50

但是因为这两种语言都使用静态类型，x不能从int型改变。两种语言都不允许像这样的动态变化

x = 50
x = 'now a string'