That’ll be the theory answers taken care of, but the practice side seems to have been neglected… Strong-typing means that you can’t use one type of variable where another is expected (or have restrictions to doing so). Weak-typing means you can mix different types. In PHP for example, you can mix numbers and strings and … Read more
Here’s a list of a few interesting systems. It is not exhaustive! Dynamically typed and compiled The Gambit Scheme compiler, Chez Scheme, Will Clinger’s Larceny Scheme compiler, the Bigloo Scheme compiler, and probably many others. Why? Lots of people really like Scheme. Programs as data, good macro system, 35 years of development, big community. But … Read more
Interesting question. BTW, I’m the author/maintainer of phc (compiler for PHP), and am doing my PhD on compilers for dynamic languages, so I hope I can offer some insights. I think there is a mistaken assumption here. The authors of PHP, Perl, Python, Ruby, Lua, etc didn’t design “interpreted languages”, they designed dynamic languages, and … Read more
isinstance(n, int) If you need to know whether it’s definitely an actual int and not a subclass of int (generally you shouldn’t need to do this): type(n) is int this: return int(n) == n isn’t such a good idea, as cross-type comparisons can be true – notably int(3.0)==3.0
I believe Lisp fits that description. http://en.wikipedia.org/wiki/Common_Lisp
Many programmers will equate static type checking to type-safety: “language A has static type checking and so it is type-safe” “language B has dynamic type checking and so it is not type-safe” Sadly, it’s not that simple. In the Real World For example, C and C++ are not type-safe because you can undermine the type-system … Read more
Assuming that some_module has a class named “class_name”: import some_module klass = getattr(some_module, “class_name”) some_object = klass() I should note that you should be careful here: turning strings into code can be dangerous if the string came from the user, so you should keep security in mind in this situation. 🙂 One other method (assuming … Read more
Union typing is only needed when you have a statically typed language, as you need to declare that an object can return one of multiple types (in your case an int or str, or in the other example str or NoneType). Python deals in objects only, so there is never a need to even consider … Read more
Use the builtin type function to get the type, then you can use the __module__ property to find out where it was defined: >>> import numpy as np a = np.array([1, 2, 3]) >>> type(a) <type ‘numpy.ndarray’> >>> type(a).__module__ ‘numpy’ >>> type(a).__module__ == np.__name__ True
Static/Dynamic Typing is about when type information is acquired (Either at compile time or at runtime) Strong/Weak Typing is about how strictly types are distinguished (e.g. whether the language tries to do an implicit conversion from strings to numbers). See the wiki-page for more detailed information.