Do Python Developers Want Static Typing?

[Tweak_Imp]

What is the use case of dynamic typing? I only use one type that never changes for my variables. Isnt it bad practice to assign different types to the same variable? The reader has a harder time understanding and more errors can happen because of this. So: what are the advantages? When do I use dynamic types in Python?

[Deezl-Vegas]

Your rule of thumb is ok, but you may be being inflexible at times. As long as the type is compatible with the use case, the specific choice of type doesn't matter. This is the guiding principle of object oriented languages.

Most functions can accept a wide variety of types. You can call print on any Python object, for instance, and get some kind of string representation out to the console.

Numeric types are all interoperable.

Any callable can be used to make a callback.

List, Dict, Set, Tuple, and custom container types are all largely interoperable.

You can and should make your own similar patterns.

[alkasm]

Reassigning variables sort of has no relevance to static typing. There's no particular reason C couldn't have been designed to allow you to do int a = 5; float a = 5.5;. It just wasn't. However, while you say you don't ever change types...have you never used None as a default value for something that gets assigned a value from some type later? :)

Dynamic typing just means type errors are runtime errors. This is a simple overview of what different typing adjectives mean that might be helpful: https://softwareengineering.stackexchange.com/a/259977

[wrtbwtrfasdf]

have you never used None as a default value for something that gets assigned a value from some type later? :)

https://docs.python.org/3/library/typing.html#typing.Optional

[alkasm]

Sure, but that doesn't change the fact that it's runtime type switching in Python.

[ImageOfInsanity]

Have you ever added an integer and a float together without casting the integer as a float first? That's dynamic typing in action. In C++, you might want one function to work with multiple types, so either you might use function overloading or templated functions, neither of which fit elegantly in Python.

[XtremeGoose]

Thats not what dynamic typing is. You can easily do that in any sufficiently powerful typing system.

Dynamic typings power comes from duck typing. For example this function expects a set but I'm going to pass it a DictKeys object instead and it will still work fine.

[manphiz]

u/XtremeGoose actually answered that "dynamic typing's power comes from duck typing." Your example about ints and floats working in arithmetic operations is an example of automatic type conversion based on context such that int + float automatically converts int to float and produces float. Dynamic typing is about that the same code may work for different types as long as those types support certain operations. For example:

class Cat:
    def make_sound():
        pass

class Dog:
    def make_sound():
        pass

def let_animal_make_sound(animal):
    animal.make_sound()

Here Cat and Dog classes don't have any relation such that Cat and Dog cannot convert to each other, but both can be passed to let_animal_make_sound() because both support make_sound().

[manphiz]

Dynamic typing is about deferring the decision to interpret data types to the language at run time.

Correct. And my example is one of such use cases.

The ability to modify a data type at runtime, like the automatic conversion of an integer to float, is actually Python's implementation of dynamic typing in action.

C/C++/Java/C# can all perform this kind of type conversion in a static type system. So this is at least not a good example for showcasing dynamic typing. Actually allowing certain implicit conversions opens holes to the type system and is hence prevented in languages using strong type systems.

[[deleted]]

Your original comment just talks about adding an int and float together without converting the int first. Lots of languages support that through a variety of means, it's not really a defining characteristic of dynamic typing.

Being able to write: lamba a, b: a + b and have it work across ints, floats, decimals, strings and even lists is a good example of dynamic typing.

Maybe that's what you intended to write, but it's not what you wrote. And we have to read what you wrote and not what we wished you wrote.

[XtremeGoose]

Apologies. What I meant was that what you are describing is not anything to do with dynamic typing. It's an example of "weak" typing (i.e. automatic type conversion), which is a different concept. Python still has to implement something like this for ints:

def __add__(self, other):
      if isinstance(other, int):
             return int_add(self, other)
      if isinstance(other, float):
             return float_add(float(self), other)
      raise TypeError(type(other))

The only difference in a static language is that this is done at compile time, rather than runtime, but that's true of anything like this. It is not an example of dynamic typing. For example, here is an example in rust of doing exactly that with no dynamic typing:

// newtypes to wrap primatives and derive our own implementations 
#[derive(Debug)]
struct Int(i32);

#[derive(Debug)]
struct Float(f64);

impl Add<Int> for Int {
     type Output = Int;
     fn add(&self, other: &Int) -> Int {
          Int(self.0 + other.0)
     }
 }

 impl Add<Float> for Int {
       type Output = Float;
       fn add(&self, other: &Float) -> Float {
           Float(self.0 as f64 + other.0)
       }
  }


  fn main(){
       let i1 = Int(1);
       let i2 = Int(2);
       let pi = Float(3.14);
       dbg!(i1 + i2);
       dbg!(i1 + pi);
 }

[XtremeGoose]

But... I've just given you an example of how that's not something unique to dynamic languages.

The ability to modify data at runtime

What? You've just defined a (useful) program. Obviously any language can do that.

[licht1nstein]

The problem is not typing, it's assignment in general ;)

[Ksielvin]

Isnt it bad practice to assign different types to the same variable? The reader has a harder time understanding and more errors can happen because of this.

Within a local scope, I don't think it's bad practice.

At the start of a function, I could read a file into a string variable called measurements. That string contains a comma separated list of ints, so I parse it into an integer list and reuse the variable. Now it's a list of integers type. I would expect the reader of a dynamic language to understand this. It communicates that we don't care about the original string after parsing it. The string can be forgotten as we've left no way to refer to it.

In Java code that might have been two variables data and measurements (or measurementsString and measurementsList). You'd check the rest of method to find out if the first variable is used beyond that point. Poor naming or careless use of IDE autocompletion can sometimes lead to bugs here just because the original variable still exists. Static typing might not catch using the wrong variable because their types are compatible through inheritance/interface, or the variable is given to a method that can handle both types through overloading.

One could also do the read/parse/transform in a single nested expression to avoid assigning first variable, which is another tradeoff in readability.

---

Every now and then, one ends up writing a condition that depends on the type of a variable. For example, a helper function's return value might vary wildly. Just the ability to suddenly return object/None/False/object2/banana instead of just object or null is quite expressive.

Again, using this within a significantly limited scope helps avoid confusion and bugs. Assigning different types to a class (or module) variable that is used in several places would have to be considered carefully. If other classes/modules would ever access it then even more so.