同一代码在Node.js与Python 3中的执行时间为何存在显著差异？

First, let's recap your scenario: you solved a coding problem with a JavaScript/ES6 (Node.js) solution that ran in ~870ms, and you're wondering why an equivalent Python 3 implementation would have a drastically different execution time. Here's your JS code snippet for reference:

console.time('runtime')
const isPrime = num => {
  if (num < 0) return false
  for (let i = 2, s = Math.sqrt(num); i <= s; i++)
    if (num % i === 0) return false
  return num !== 1
}
let sideLength = 7
let ratio = 100
let gap = 2
let progress = 1
let primes = 0
let count = 2
// Rest of your logic...

Now, let's dive into the core reasons for the performance gap:

• JIT Compilation vs. Interpreted Execution
  Node.js uses the V8 engine, which employs Just-In-Time (JIT) compilation. V8 watches frequently executed code (like your isPrime function, which gets called repeatedly for prime checks) and compiles it directly into optimized machine code on the fly. This means after the first few runs, your prime-checking logic runs at near-native speeds.

  Python 3 (specifically the standard CPython implementation) is an interpreted language—it executes code by interpreting bytecode one instruction at a time, with no JIT optimization. For loop-heavy tasks like prime checking, this interpretation overhead adds up quickly, making the code run much slower.

• Low-Level Numeric Handling Differences
  V8 is highly optimized for numeric operations. It uses specialized integer representations (no object wrapping for small integers) and converts operations like Math.sqrt(num) and num % i directly into fast machine instructions.

  In Python, every integer is an object—even small numbers. This means every arithmetic operation, loop increment, or modulus check requires object-level operations (like reference counting, attribute lookups) that add significant overhead, especially in tight loops that run thousands or millions of times.

• Function Call Overhead
  V8 aggressively optimizes small, frequently called functions like isPrime with techniques like function inlining—it replaces the function call with the actual function code, eliminating the overhead of setting up stack frames and passing arguments.

  Python has much higher function call overhead. Each time you call your prime-checking function, Python has to create a new stack frame, handle argument passing as objects, and manage the call stack. For a function that's called hundreds of thousands of times, this overhead becomes a major bottleneck.

If you want to narrow the gap with Python, you could try using PyPy (a Python implementation with JIT compilation) or optimize your code to reduce function calls and loop overhead—but the fundamental runtime differences between Node.js/V8 and CPython are the main drivers of the speed discrepancy here.

内容的提问来源于stack exchange，提问作者TheOdd