I've come across links that say Python is a strongly typed language.
However, I thought in strongly typed languages you couldn't do this:
bob = 1
bob = "bob"
I thought a strongly typed language didn't accept type-changing at run-time. Maybe I've got a wrong (or too simplistic) definition of strong/weak types.
So, is Python a strongly or weakly typed language?
Python is strongly, dynamically typed.
As for your example
bob = 1
bob = "bob"
This works because the variable does not have a type; it can name any object. After bob=1
, you'll find that type(bob)
returns int
, but after bob="bob"
, it returns str
. (Note that type
is a regular function, so it evaluates its argument, then returns the type of the value.)
Contrast this with older dialects of C, which were weakly, statically typed, so that pointers and integers were pretty much interchangeable. (Modern ISO C requires conversions in many cases, but my compiler is still lenient about this by default.)
I must add that the strong vs. weak typing is more of a continuum than a boolean choice. C++ has stronger typing than C (more conversions required), but the type system can be subverted by using pointer casts.
The strength of the type system in a dynamic language such as Python is really determined by how its primitives and library functions respond to different types. E.g., +
is overloaded so that it works on two numbers or two strings, but not a string and an number. This is a design choice made when +
was implemented, but not really a necessity following from the language's semantics. In fact, when you overload +
on a custom type, you can make it implicitly convert anything to a number:
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)
Instance of class Foo
can be added to other objects:
>>> a = Foo(42)
>>> a + "1"
43.0
>>> a + Foo
42
>>> a + 1
43.0
>>> a + None
42
Observe that even though strongly typed Python is completely fine with adding objects of type int
and float
and returns an object of type float
(e.g., int(42) + float(1)
returns 43.0
). On the other hand, due to the mismatch between types Haskell would complain if one tries the following (42 :: Integer) + (1 :: Float)
. This makes Haskell a strictly typed language, where types are entirely disjoint and only a controlled form of overloading is possible via type classes.