python vs java performance reddit

reddit.com › r › Python › comments › 18xfmq2 › why_python_is_slower_than_java

Both Python and Java compile the source files to bytecode. The difference is in how they to run this bytecode. In both languages, the bytecode is basically a binary representation of the textual source code, not an assembly program that can run on a CPU. You have a different program accepts the bytecode and runs it. How does it run it? Python has an interpreter, i.e a program that keeps a "world model" of a Python program (which modules are imported, which variables exist, which objects exist...), and runs the program by loading bytecodes one by one and executing each one separately. This means that a statement such as y = x + 1 is executed as a sequence of operations like "load constant 1", "load x" "add the two values" "store the result in y". Each of these operations is implemented by a function call that does something in C and often reads and updates dictionary structures. This is slow, and it's slower the smaller the operations are. That's why numerical code in Python is slow - numerical operations in Python convert single instructions into multiple function calls, so in this type of code Python can be even 100x slower than other languages. Java compiles the bytecode to machine code. You don't see it because it happens at runtime (referred to as JIT), but it does happen. Since Java also knows that x in y = x + 1 is an integer, it can execute the line using a single CPU instruction. There's actually an implementation of Python that also does JIT compilation. It's called PyPy and it's five times faster than CPython on average, depending what exactly you do with it. It will run all pure Python code, I think, but it still has problems with some libraries. Answer from unruly_mattress on reddit.com

reddit.com › r/python › why python is slower than java?

r/Python on Reddit: Why Python is slower than Java?

January 3, 2024 -

Sorry for the stupid question, I just have strange question.

If CPython interprets Python source code and saves them as byte-code in .pyc and java does similar thing only with compiler, In next request to code, interpreter will not interpret source code ,it will take previously interpreted .pyc files , why python is slower here?

Both PVM and JVM will read previously saved byte code then why JVM executes much faster than PVM?

Sorry for my english , let me know if u don't understand anything. I will try to explain

Top answer

1 of 42

621

Both Python and Java compile the source files to bytecode. The difference is in how they to run this bytecode. In both languages, the bytecode is basically a binary representation of the textual source code, not an assembly program that can run on a CPU. You have a different program accepts the bytecode and runs it. How does it run it? Python has an interpreter, i.e a program that keeps a "world model" of a Python program (which modules are imported, which variables exist, which objects exist...), and runs the program by loading bytecodes one by one and executing each one separately. This means that a statement such as y = x + 1 is executed as a sequence of operations like "load constant 1", "load x" "add the two values" "store the result in y". Each of these operations is implemented by a function call that does something in C and often reads and updates dictionary structures. This is slow, and it's slower the smaller the operations are. That's why numerical code in Python is slow - numerical operations in Python convert single instructions into multiple function calls, so in this type of code Python can be even 100x slower than other languages. Java compiles the bytecode to machine code. You don't see it because it happens at runtime (referred to as JIT), but it does happen. Since Java also knows that x in y = x + 1 is an integer, it can execute the line using a single CPU instruction. There's actually an implementation of Python that also does JIT compilation. It's called PyPy and it's five times faster than CPython on average, depending what exactly you do with it. It will run all pure Python code, I think, but it still has problems with some libraries.

2 of 42

68

There are 2 things that mostly affect this: Language design and Implementation. Python is designed to be higher level and to be more easy to iterate quickly, for example by it's use of duck typing. Java on the other hand, while quite high level when compared to C, forces static type checks at compile time. This means the Java compiler can do optimizations that Python just can't, because it has more information ahead of time (because it forced the programmer to supply that information) Then there is implementation. At least for python I know a handful of language implementations that vary wildly in speed. CPython and PyPy with it'S JIT compiler come to mind. Many of the speed issues are just a matter of optimization. Java has been optimized a lot about 10 years ago I think? I remember sitting in uni and people talking about how Java has finally become fast ^^. Take this with a grain of salt, I don't enjoy java specifically, I might misremember the time. But Python definitely is getting faster by the year. The "normal" python implementation is working hard on optimizations since about 3.9. One of the things holding python back in many applications on modern hardware is the GIL, because it pretty much makes easy and fast multi threading impossible. There are Python versions without a GIL and there are efforts to remove and/or change it for main python as well. These are just some points and examples that came to mind, there is plenty more (Examples as well as details), we only scratched the surface here. I hope it helped though

reddit.com › r/askprogramming › is java faster than python?

r/AskProgramming on Reddit: Is java faster than python?

January 31, 2024 -

Java is said to be much faster than python but there are different ways to run these languages (e.g. pypy for python, maybe dalvik for java). Is there any way python could be made faster than java?

Top answer

1 of 5

17

All things being equal, yes Java is usually faster than Python. That said, there are some pretty important qualifiers to that statement: Much of the "heavy lifting" done by Python is actually implemented in super-optimised C and C++ code which is (again, all other things being equal) faster than Java code, e.g. the Numpy library is a good example of this. Many programmes - e.g. most web apps - are I/O Bound (meaning that their performance is limited by the speed of input/output operations such as sending messages over the network or retrieving information from a database), meaning that, in practice, the speed difference between Java and Python is irrelevant, as the programme spends 99% of its execution time on I/O. Speed of implementation is often more important than speed of language. An inefficient Java implementation will often be orders of magnitude slower than an efficient Python on. Developer time is often relevant. Python advocates often state (rightly or wrongly) that as Python is more concise and "simpler" than Java, meaning that it allows Python developers to be more productive than developers using other languages, which is relevant if CPU cycles are cheaper than engineer wages.

2 of 5

5

Last time I checked, yes, by a huge margin. Java's execution is like reading shorthand (Compiler+JIT), python is like reading Shakespeare (Slow-ass interpreter). While there's good efforts made to make unofficial compilers that can convert Python or Java to Assembly, it's not easy since both languages rely on the VMs that run them to do things like automatic memory management, so the code you have inside your Python/Java program isn't the full story. You also need a garbage collector written in Assembly among other things. This makes it very difficult to turn into native code. That's the efficiency kind of performance. But there's also performance gains from leveraging more hardware that you also need to worry about. Even if you used these unorthodox assembly compilers, the language itself can hamper this performance, like the ability to multithread, which the Python spec lacked for a very long time.

Videos