Pourquoi mon calcul est-il tellement plus rapide en C # que Python

TL;DR: Longue haleine post c'est moi en essayant de défendre Python (mon choix de la langue) à l'encontre de C#. Dans cet exemple, le C# est plus performante, mais prend toujours plus de lignes de code pour faire la même quantité de travail, mais la performance finale avantage est que C# est ~5x plus rapide qu'une approche similaire en Python quand codé correctement. Le résultat final est que vous devez utiliser la langue qui vous convient.

Quand je lance l'exemple en C#, il a fallu environ 3 secondes sur ma machine, et m'a donné un résultat de 232,792,560. Il pourrait être optimisé en utilisant le fait bien connu que vous ne pouvez avoir qu'un nombre divisible par les nombres de 1 à 20 si le nombre est un multiple de 20, et, par conséquent, vous n'avez pas besoin d'incrémenter de 1, mais au lieu de 20. Que seul l'optimisation faite le code à exécuter ~10x plus rapide que dans une simple 353 millisecondes.

Quand je lance l'exemple Python, j'ai renoncé à attendre et essayé d'écrire ma propre version à l'aide de itertools, qui n'a pas eu beaucoup plus de succès, et a été prise à peu près aussi long que votre exemple. Puis, je suis tombé sur une version acceptable de itertools, si je prends en compte le fait que seuls les multiples de mes plus grand nombre pourrait être divisible par tous les nombres du plus petit au plus grand. En tant que tel, le raffiné Python(3.6) le code est ici avec un décorateur fonction de synchronisation qui imprime le nombre de secondes qu'il a fallu pour exécuter:

import time
from itertools import count, filterfalse


def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        print(time.time() - start)
        return res
    return wrapper


@timer
def test(stop):
    return next(filterfalse(lambda x: any(x%i for i in range(2, stop)), count(stop, stop)))


print("Test Function")
print(test(20))
# 11.526668787002563
# 232792560

Cela m'a aussi rappelé une question j'ai récemment eu à répondre sur CodeFights pour le plus petit Commun Multiple en utilisant le Plus grand Commun Dénominateur de la fonction en Python. Ce code est comme suit:

import time
from fractions import gcd
from functools import reduce


def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        print(time.time() - start)
        return res
    return wrapper


@timer
def leastCommonDenominator(denominators):
    return reduce(lambda a, b: a * b //gcd(a, b), denominators)


print("LCM Function")
print(leastCommonDenominator(range(1, 21)))
# 0.001001596450805664
# 232792560

Comme dans la plupart des tâches de programmation, parfois, l'approche la plus simple n'est pas toujours le plus rapide. Malheureusement, il m'est resté hors de la tentative en Python cette fois. Cela dit, la beauté en Python, c'est la simplicité de l'obtention d'une performance de l'exécution, où il a pris 10 lignes de C#, j'ai été en mesure de retourner la réponse correcte en (potentiellement) une ligne d'expression lambda, et 300 fois plus rapide que mon optimisation simples sur C#. Je ne suis pas spécialiste en C#, mais la mise en œuvre de la même approche, voici le code que j'ai utilisé et de son résultat (environ 5x plus rapide que Python):

using System;
using System.Diagnostics;
namespace ConsoleApp1
{
class Program
{
public static void Main(string[] args)
{
Stopwatch t0 = new Stopwatch();
int maxNumber = 20;
long start;
t0.Start();
start = Orig(maxNumber);
t0.Stop();
Console.WriteLine("Original | {0:d}, {1:d}", maxNumber, start);
//Original | 20, 232792560
Console.WriteLine("Original | time elapsed = {0}.", t0.Elapsed);
//Original | time elapsed = 00:00:02.0585575
t0.Restart();
start = Test(maxNumber);
t0.Stop();
Console.WriteLine("Test | {0:d}, {1:d}", maxNumber, start);
//Test | 20, 232792560
Console.WriteLine("Test | time elapsed = {0}.", t0.Elapsed);
//Test | time elapsed = 00:00:00.0002763
Console.ReadLine();
}
public static long Orig(int maxNumber)
{
bool found = false;
long start = 0;
while (!found)
{
start += maxNumber;
found = true;
for (int i=2; i < 21; i++)
{
if (start % i != 0)
found = false;
}
}
return start;
}
public static long Test(int maxNumber)
{
long result = 1;
for (long i = 2; i <= maxNumber; i++)
{
result = (result * i) / GCD(result, i);
}
return result;
}
public static long GCD(long a, long b)
{
while (b != 0)
{
long c = b;
b = a % b;
a = c;
}
return a;
}
}
}

Pour la plupart des tâches de niveau supérieur, cependant, j'ai l'habitude de voir Python faisant exceptionnellement bien en comparaison à un .NET mise en œuvre, bien que je ne peut pas justifier les revendications en ce moment, à part de dire le Python Demandes de la bibliothèque m'a donné autant qu'un double à triple retour de performance par rapport à un C# WebRequest écrit de la même manière. C'était également le cas lors de l'écriture de Sélénium processus, comme j'ai pu lire des éléments de texte en Python en 100 millisecondes ou moins, mais chaque élément de récupération a pris C# >1 seconde pour revenir. Cela dit, je préfère le C# de la mise en œuvre en raison de son approche orientée-objet, où Python Sélénium mise en œuvre va fonctionnel, ce qui devient très difficile à lire parfois.

Python (et tous les langages de script, y compris matlab) n'est pas destiné à être directedly utilisé à grande échelle de calcul numérique. Pour avoir un compatible résultat respecté les programmes, éviter les boucles à tout prix, et de convertir de la formule de matrice de formats (qui a besoin d'un peu de mathématique, de la compréhension et des compétences), de sorte que nous pouvons de pousser autant que possible à l'arrière-plan de la bibliothèque C fournis par numpy, scipy, etc.

De nouveau, NE PAS écrire des boucles de calcul numérique en pythonchaque fois qu'une matrice équivalente possible!