ssd ssd - 5 months ago 56
C# Question

Why is my computation so much faster in C# than Python

Below is a simple piece of process coded in

respectively (for those of you curious about the process, it's the solution for Problem No. 5 of Project Euler).

My question is, the
code below takes only 9 seconds to iterate, while completion of
code takes 283 seconds (to be exact, 283 seconds on Python 3.4.3 - 64 bits and 329 seconds on Python 2.7.9 - 32 bits).

So far, I've coded similar processes both in
and the execution time differences were comparable. This time however, there is an extreme difference between the elapsed times.

I think, some part of this difference arise from the flexible variable type of python language (I suspect, python converts some part of variables into double) but this much is still hard to explain.

What am I doing wrong?

My system: Windows-7 64 bits,

C# - VS Express 2012 (9 seconds)

Python 3.4.3 64 bits (283 seconds)

Python 2.7.9 32 bits (329 seconds)

c-sharp code:

using System;

namespace bug_vcs {
class Program {
public static void Main(string[] args) {
DateTime t0 = DateTime.Now;
int maxNumber = 20;
bool found = false;
long start = maxNumber;
while (!found) {
found = true;
int i = 2;
while ((i < maxNumber + 1) && found) {
if (start % i != 0) {
found = false;
Console.WriteLine("{0:d}", start - 1);
Console.WriteLine("time elapsed = {0:f} sec.", (DateTime.Now - t0).Seconds);

and python code:

from datetime import datetime

t0 =
max_number = 20
found = False
start = max_number
while not found:
found = True
i = 2
while ((i < max_number + 1) and found):
if (start % i) != 0:
found = False
i += 1
start += 1

print("number {0:d}\n".format(start - 1))

print("time elapsed = {0:f} sec.\n".format(( - t0).seconds))

Answer Source

The answer is simply that Python deals with objects for everything and that it doesn't have JIT by default. So rather than being very efficient by modifying a few bytes on the stack and optimizing the hot parts of the code (i.e., the iteration) – Python chugs along with rich objects representing numbers and no on-the-fly optimizations.

If you tried this in a variant of Python that has JIT (for example, PyPy) I guarantee you that you'll see a massive difference.

A general tip is to avoid standard Python for very computationally expensive operations (especially if this is for a backend serving requests from multiple clients). Java, C#, JavaScript, etc. with JIT are incomparably more efficient.

By the way, if you want to write your example in a more Pythonic manner, you could do it like this:

from datetime import datetime
start_time =

max_number = 20
x = max_number
while True:
    i = 2
    while i <= max_number:
        if x % i: break
        i += 1
        # x was not divisible by 2...20
    x += 1

print('number:       %d' % x)
print('time elapsed: %d seconds' % ( - start_time).seconds)

The above executed in 90 seconds for me. The reason it's faster relies on seemingly stupid things like x being shorter than start, that I'm not assigning variables as often, and that I'm relying on Python's own control structures rather than variable checking to jump in/out of loops.

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download