À quelle vitesse est python?

Il est très difficile de faire une comparaison véritablement objective et générale de la vitesse d'exécution de deux langues. En comparant deux langues x et y, on trouve souvent X est plus rapide que Y à certains égards tout en étant plus lent dans d'autres. Pour moi, cela rend les points de repère / comparaisons disponibles en ligne largement inutiles. Le meilleur moyen est de le tester vous-même et de voir à quel point chaque langue est rapide pour le travail que vous faites.

Cela dit, il y a certaines choses que l'on veut se rappeler lors du test de langues comme Java et Python. Le code dans ces langues peut souvent être accéléré de manière significative en utilisant des constructions plus adaptées à la langue (par exemple, des compréhensions de liste dans Python ou en utilisant Char [] et StringBuilder pour certaines opérations de chaîne en Java). De plus, pour Python, l'utilisation de PSYCO peut considérablement augmenter la vitesse du programme. Et puis il y a toute la question de l'utilisation de structures de données appropriées et de garder un œil sur la complexité d'exécution de votre code.

Je pense que la réponse de Keyle (entre autres) apporte à la maison un point de base: une quantité énorme dépend de la façon dont vous faites les choses. Ce lien a donné deux réponses pour C ++, mais j'ai du mal à croire que quiconque écrirait normalement C ++ qui ressemble beaucoup à celui de l'un ou l'autre. Ma première tentative ressemblerait à ceci comme suit:

#include <iostream>
#include <vector>
#include <time.h>

class person { 
    int count_;
    static int current_;
public:
    person() : count_(++current_) {}
    int count() { return count_; }
};
int person::current_ = 0;
typedef std::vector<person> plist;
class chain {
    plist people_;
    void check_wrap(std::vector<person>::iterator &p) {
        if (p==people_.end())
            p = people_.begin();
    }
    void advance(std::vector<person>::iterator &p, int places) {
        for (int i=0; i<places; i++)
            check_wrap(++p);
    }
public:
    chain(int length) : people_(length) {}
    person *kill(int n) { 
        plist::iterator current = people_.begin();
        while (people_.size()>1) {
            advance(current, n);
            current = people_.erase(current);
            check_wrap(current);
        }
        return &(*current);
    }
};
int main() {
    const int ITER = 1000000;  
    clock_t start = clock();
    for(int i = 0 ; i <ITER; i++) {
        chain c(40);
        c.kill(3);  
    }
    clock_t end = clock();
    std::cout << "Time per iterator: " << (((end - start) /(double)CLOCKS_PER_SEC/ITER)*1000000 << " microseconds.\n";
    return 0;
}