The advantage of dynamically typed languages, of course, not in syntax but in semantics.
By defining types during program execution strongly facilitates metaprogramming. Very much easier. It, in turn, simplifies the rest of the work.
Thanks to the flexibility of the code in runtime (see duck typing) and introspection (analysis of the properties of objects and code) can be obtained much easier and faster to write generic algorithms and design like interior decorators, all sorts of ORM and things like that. This greatly simplifies the interfaces of the libraries, which together leads to more simple code and a smooth learning curve to newcomers.
From my experience (5 years of writing C++, then the same in Python, these terms overlap a bit) I can say that from the point of view of errors of typing (and actually put them in the disadvantage of dynamically typed languages), the difference is minimal — they are very rare and all are caught with automatic tests. Of course, if you have hands grow from where it should be, and if not from where it should be, these errors are not the biggest problem. Therefore, in the field of software development, not performance-sensitive, such languages rule.
The advantage of statically typed languages is that imposing additional restrictions on the programmer and the code flexible, they allow the compiler to obtain additional information about the program and to make more specific operations. However, now used almost everywhere JIT
and it partially neutralizes the difference in performance.
In the end we get the classic dilemma: raising the level of abstraction against the increase in the level of specialization. Each way has its pros and cons.
The performance of the Python references already inserted, but in any case, here we must proceed from the requirements of a particular task — easier to take and test yourself.