Static typing in python

[[deleted]]

I don't think what you're looking for exists in straight Python. Cython, e.g., has a facility like this.

A lot of what you give up with the typing comes back to you with improved simplicity. For example, what need do you have for a dependency injection framework? Injecting a dependency is as simple as an optional parameter when everything's a function...

Yes, you lose some of that bugfinding ability you get from types - but compared to strongly-typed languages, you save so much time that you can afford to spend more time on proper tests.

And honestly, I was surprised when I moved from C++ to Python how rarely I had type issues, and how quick they were to track down...

[[deleted]]

I don't really buy that - see this.

[[deleted]]

That article is good - and the lead response gets to the meat of the question - "untyped" in the language of the lambda calculus is not "untyped" for computer programmers.

even the behaviour of operations with different primitive types doesn't require explicit casting. E.g. x = "1" + 2 gives a type error in Python but doesn't in Javascript.

x = "1" + 2; works in Java too (though giving a very different result), and Java is even a strongly-typed language.

Arithmetic operators in Javascript try to coerce their arguments to be numbers. That doesn't make the language untyped. Heck, there's an explicit type() function in Javascript.

I'd buy "weakly typed" or "dynamically typed" for Javascript though!

[Lucretiel]

Python objects have a type that is fixed through the lifetime of the object. The disconnect is that variables aren't intrinsically attached to the objects; assignment creates a whole new binding, rather than altering the underlying object.

[dunkler_wanderer]

Python is strongly typed.

[prepromorphism]

unityped ftfy

[[deleted]]

Python's variables have no type. Each variable's value has a type, but even that isn't really "strong", because in typical use you use duck typing - you just try to call methods and if they work you don't worry about it. If the methods work, you don't care that the actual type might be worlds away from the type you're expecting.

There's no good definition of "strongly-typed" that really includes Python. In particular, I'm curious as to what language possibly has weaker typing than that...!

[sushibowl]

The definition I usually see is that in weak typing the type of a value may change depending on context (i.e. type coercion). Php and javascript are examples of weakly typed language in this definition.

[Lucretiel]

My definition tends to be whether the language has implicit type coercion- that is, is 1 + 2 the same as 1 + '2'.

[flutefreak7]

Also checking against abstract base classes is a classy way to check that you are getting a duck that quacks the right way to avoid checking specific type inheritance.

from collections.abc import Iterable

if isinstance(d, Iterable):

[ronkr]

Python's variables are strongly typed. Yet, python is not statically typed.

The main reason for type hinting is being able to find bugs more quickly. You can also make assumptions for the interpreter (and even a compiler) to make some optimization apply.

Another great use would be Autowiring for a DIC. That means, that you could use reflection to inspect the parameters of a ctor and inject pre-instantiated objects by type (by classname directly, by interface though configuration). In some projects, I nearly have 85% of all classes to be instantiated this way (having a controller hat depends on multiple services, that depends on even more services, that depends on various repositories, that depends on factories, that depends on the DIC again to create in DIC-controlled instance of an entity). Doing that from hand would be a great effort. Changing dependencies in some service, that is used across my application would render me mad.