I think the question is too unconstrained. In the abstract, I don't think that one makes programmers more productive than the other. The very fact that this is a source of ongoing debate, with both sides able to make very good cases, indicates to me that the overall difference is negligible.
However, it seems likely to me that one or the other can offer a productivity advantage in certain very specific problem spaces, though.
Also, what counts as "more productive"? It sounds like a silly question, but when you start to drill down into what "productive" really means, there are all sorts of different valid answers to that.
My feelings aren't strong on that issue the way they are for other things.
For instance I program a lot of Java for high-throughput servers and "old A.I." code that involves logic, parsing, implementing databases, etc. I appreciate, for instance, that Java has fast and reliable facilities for multithreaded programming.
I also like programming Python for data analysis, machine learning, as well as some simple http and IoT servers that use aiohttp.
Having scikit-learn (in Python) means I don't have to write some very complex code myself or write JNI bindings to C code which is almost as bad as writing the C code. It saves me so much effort that it doesn't make much difference what language I am writing in.
If I were going to complain about Python, however, it would be that the solver in pip doesn't work 100% of the time, which is not so bad, but the community is obsessed with finding other solutions that work 87% of the time or 93% of the time (they imagine this is easier, but what do they do with the bug report that it only works 92.8% of the time?) and doesn't get that if my packaging system worked 100% of the time it would lift a huge burden off my mind and make me more productive.
Similarly some would a dynamic language is more productive because you can work in the REPL and not be waiting for the compiler all the time, but you can wait a long time for Javascript builds with Babel (though longer for Typescript), compiles are must slower in the static language Rust than they are in the static language Go, but also I feel my development cycle in Java is pretty quick thanks to running unit tests with a working debugger (I think programmers in some languages can't conceive of having a functional debugger.)
However, it seems likely to me that one or the other can offer a productivity advantage in certain very specific problem spaces, though.
Also, what counts as "more productive"? It sounds like a silly question, but when you start to drill down into what "productive" really means, there are all sorts of different valid answers to that.