And probably closer to "statically-but-not-too-statically-typed-because-really-more-than-my-language-of-choice-is-too-much" languages. Self-avowed fans of "statically-typed languages" (usually java or C#) rarely consider giving up nulls and casts.
Java:
System.out.println("abc" + 5); -> "abc5"
Python:
print "abc" + 5 -> TypeError: cannot concatenate 'str' and 'int' objects
Ruby:
puts "abc" + 5 -> TypeError: can't convert Fixnum into String
Why do you find implicitly converting an int (/Fixnum) to a float (/Float) more palatable, when they have completely different internal representations, domains of definition, precisions, operational semantics and potential pitfalls?
And what about Python's `"foo" * 3`? Hell, what about this:
> class Fixnum
> def to_str
> self.to_s
> end
> end
=> nil
> "5" + 3
=> "53"
so "strongly typed" it has a protocol for implicit string conversion.But wait, there's more without even bothering with overrides:
> a = [1, 2, 3]
=> [1, 2, 3]
> a[1.4]
=> 2
floating-point index to an array? no problem.
Nit-pick: suspect you are actually a fan of statically-typed languages. Python is a strongly-typed language, but not statically-typed.
(general easy way to tell them apart: in a statically-typed language, both the name and the value bound to it have a type, and those types must match; in a dynamically-typed language only the value has a type; in a weakly-typed language, operations on incompatible types are permitted, and they may be coerced for compatibility; in a strongly-typed language, operations on incompatible types are an error -- usually at compile-time or equivalent for statically-typed, usually run-time for dynamically-typed)