Langage le plus rapide : python ou C ?

Version imprimable

11/08/2021, 19h16
mlkgiosn

Langage le plus rapide : python ou C ?

Bonjour.

En fait je me pose une question, j'ai vu dans une vidéo que C était soit disons X fois plus rapide que python, mais avec mes minces connaissances, j'ai écrit un programme qui teste la conjecture de syracuse, dans chacun de ces 2 langages, de 1 jusqu'à 50.000, et C est totalement largué, le prog en python finit largement avant, plus de 50 secondes avant le prog en C.

Donc C est-il vraiment plus rapide ? Si oui faut m'expliquer lol.
11/08/2021, 22h33
dourouc05

:salut:

Si tu codes comme un pied en C, Python risque d'être plus rapide. L'inverse est aussi vrai. La vraie différence, c'est que tu peux optimiser autant que tu veux en C : en Python, tu devras sortir du langage pour atteindre le dernier degré de performance.

Dans https://julialang.org/benchmarks/ (temps de calcul normalisés par rapport au C), on voit que, sur les problèmes testés, Python arrive une fois à peu près au niveau de C (de par l'utilisation d'une bibliothèque écrite en Fortran pour la multiplication matricielle), mais est sinon largué.

Donne les deux codes que tu as utilisés pour tes tests : des gens plus avertis pourraient remarquer des problèmes dans le code (ne fût-ce qu'un malloc/free à chaque itération, ça tue la performance en moins de deux…).

Voici mon code en python :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def syracuse(n):
    print(n)
    while n != 1:
        if n % 2 == 0:
            n = n / 2
        else:
            n = 3 * n + 1
        print(int(n))
 
nombre = 1
while nombre < 50001:
    syracuse(nombre)
    nombre = nombre + 1
    print("*******************************************************************************************")
    print()

Voici mon code en C :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <stdlib.h>
 
void syracuse(n) {
    printf("%d\n", n);
    while(n!=1) {
        if (n % 2 == 0) {
            n = n / 2;
        }
        else {
            n = 3 * n + 1;
        }
            printf("%d\n", n);
            }
}
 
int main()
{
    long nombre = 1;
    while (nombre < 50001) {
    syracuse(nombre);
    nombre++;
    printf("**************************************************************\n");
    }
 
    printf("\n");
    return 0;
}

Je suis débutant, alors c'est très possible que les codes soient très très améliorables lol.

12/08/2021, 21h34
dourouc05

Que se passe-t-il si tu retires les instructions d'affichage dans la boucle de calcul ? Je suppose que Python n'affiche pas le texte que tu lui demandes immédiatement, mais groupe plusieurs appels, contrairement à l'implémentation de la bibliothèque standard C.
12/08/2021, 22h17
Canvas
Bonsoir,

Dans le code C on doit pouvoir remplacer :
Code:

1 2 3 4 5 6 if (n % 2 == 0) { n = n / 2; } else { n = 3 * n + 1; }
par :

Code:

n = (n & 1) ? (3*n + 1) : (n / 2);
13/08/2021, 00h11
mlkgiosn

Canvas : J'ai essayé avec la ligne de code que tu dis mais j'ai une erreur.

Cette erreur : |22|error: expected declaration or statement at end of input|

dourouc05 :Le problème c'est que sans instruction d'affichage je vois rien défiler et ça complique la comparaison.
15/08/2021, 11h48
yildiz-online

Pour une boucle incrémentale, for me semble plus indiqué.
Tu peux utiliser des move pour les divisions par 2 (>>1).
Tu peux utiliser un int plutôt qu'un long.
Tu peux utiliser des types non signés.
Tu peux compiler avec les optimisations aggressives (-O3).
Tu peux initialiser "**************************************************************\n" en dehors de la boucle et le réutiliser.
Les print c'est lent, tu peux stocker les résultats, et tout imprimer à la fin, ce ne sera pas plus rapide, mais tu pourras plus facilement isoler le temps de l'algo de calcul.

Disclaimer: je suis javaiste, donc tout ceci n'est peut-être pas totalement valide pour le C et encore moins pour Python, à prendre avec des pincettes donc(mais ça coûte pas grand chose de tester), et d'avance merci à ceux qui me corrigeront.

Bonsoir,

En tenant compte des différents conseils, voici ce que cela peut donner :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>
#include <stdlib.h>
 
#define LONGUEUR 1024
 
int *syracuse(int n, int *size) {
   int *suite = malloc(LONGUEUR * sizeof *suite);
   int i = 0;
   while (n != 1) {
        n = (n & 1) ? (3*n + 1) : (n >> 1);
        suite[i++] = n;
   }
   *size = i;
   return suite;
}
 
int main(void) {
   int nb, i, j, size;
 
   printf("Saisir un entier positif : ");
   scanf("%d",&nb);
   printf("\n");
 
   printf("1 : 1\n");
 
   for (i=2; i <= nb; i++) {
      printf("%d : ", i);
      size = 0;
      int *a = syracuse(i, &size);
      for (j=0; j < size; j++) {
         printf("%d ", *(a + j));
      }
      printf("\n");
   }
   return 0;
}
 
 
# Test
 
Saisir un entier positif : 16
 
1 : 1
2 : 1 
3 : 10 5 16 8 4 2 1 
4 : 2 1 
5 : 16 8 4 2 1 
6 : 3 10 5 16 8 4 2 1 
7 : 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
8 : 4 2 1 
9 : 28 14 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
10 : 5 16 8 4 2 1 
11 : 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
12 : 6 3 10 5 16 8 4 2 1 
13 : 40 20 10 5 16 8 4 2 1 
14 : 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
15 : 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1 
16 : 8 4 2 1

Il y a moyen d'améliorer encore plus. Il faudrait poser la question sur le forum du langage C.

18/08/2021, 20h35
kaitlyn

Salut,

Et bien comparer deux langages avec des codes qui sont essentiellement dépensés dans des appels systèmes, je ne suis pas sûre que c'est pertinent.
Quoi qu'il en soit, le code C est ici pénalisé par la mémoire tampon qui est en mode ligne par défaut et le nombre excessif de sauts de lignes (\n) à afficher qui tourne en boucle. En effet, à chaque saut de ligne, la mémoire tampon se vide, ce qui consomme de la ressource et du temps. En changeant le mode de ligne à complet (full buffered) grâce à la fonction setvbuf(), il sera possible de rendre l'exécution du code C plus rapide, par exemple avec un if (setvbuf(stdout, 0, _IOFBF, 4096) != 0) return 1; juste après le int main() {.