Python vs Cython vs C

Version imprimable

10/08/2025, 10h37
Peter57

Python vs Cython vs C

Salut à tous !
J'ai testé un petit programme test (somme d'un cos + sin dans une boucle de 1 000 000 d'itérations) en Python, en Cython et enfin en 'C'.
le résultat est surprenant !
Quelque soit la fonction (j'ai testé un calcul de suite de Fibonacci), Python 3.13 est plus rapide que Cython ! le C quand à lui écrase tout le monde !
Avec n itérations = 1 000 000
fonction testée :

Code:

s+= cos(i) + sin(i)

Somme cython: -0.06
Durée : 0.209480 sec

Somme python: -0.06
Durée : 0.159361 sec

Somme C : -0.06
Duree: 0.011000 sec

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !
Bien cordialement.
Peter
10/08/2025, 15h36
Peter57

avis

Personne n'a un avis sur l'utilisation de Cython ?
10/08/2025, 16h05
wiztricks

Salut,

Citation:

Envoyé par Peter57

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !

Pour sortir ce genre d'affirmation, il faudrait un exemple plus significatif, un code montrant comment ont été obtenus ces résultats permettant de les reproduire au besoin.

- W
10/08/2025, 17h53
fred1599

Bonjour,

Peut-être aussi que vous comparez le temps d'exécution d'un code cpython (python déjà optimisé avec wrapper C) avec votre code cython (code C fait maison).
Ce temps pourrait être logique, mais pour vérifier, il nous faudra comme dit précédemment par mon VDD, le code !
11/08/2025, 11h20
wiztricks

Citation:

Envoyé par Peter57

Personne n'a un avis sur l'utilisation de Cython ?

C'est un outil pour optimiser l'utilisation CPU/mémoire d'un code où on a déjà fait le nécessaire côté algorithme.
Si vous pensez que ça devrait apporter quelque chose et que le résultat n'est pas là, c'est que vous vous êtes planté quelque part sur la pertinence à utiliser cet outil dans ce cas particulier (et on attends toujours les détails de ce que vous avez fait).

note: cython ne date pas d'hier et ceux qui l'utilisent à bon escient en sont généralement satisfait.

- W

voila le programme python -cython

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
59
60
61
62
63
64
65
66
67
#
#   fichier main.py
#
 
from pyximport import install ; install()
import cython_fn
import time
import python_fn
 
#iterations
n = 1000000
 
# cal cython version
t0 = time.time()
sum_cython = cython_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme cython: {sum_cython:.2f}")
print(f"Durée : {t:.6f}")
 
# calc python version
t0 = time.time()
sum_python = python_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme python: {sum_python:.2f}")
print(f"Durée : {t:.6f}")
 
#
#   fichier cython_fn.pyx
#
# cython : language_Level = 3
 
import math
 
def cy_fibo(int n):
    cdef int a,b,i
 
    a , b = 1, 1
 
    for i in range(n):
        a, b = a+b, a
    return a
 
# version cython
def cos_calc(int n):
    cdef double s = 0.0
    cdef int i=0
 
    for i in range(n):
        s += (math.cos(i) + math.sin(i))
 
    return s
 
#
#   fichier python_fn.py
#
 
import math
 
def cos_calc(n : int):
    s = 0.0
    for i in range(n):
        s += math.cos(i) + math.sin(i)
    return s

version 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
29
30
31
 
// Cython vs Python
// C version
 
#include <stdio.h>
#include <time.h>
#include <math.h>
 
double cos_calc(int n) {
	double s = 0.0;
	for (int i = 0; i < n; i++) {
		s += (cos(i) + sin(i));
	}
	return s;
}
 
int main(){
	int n = 1000000;
	double s = 0.0;
 
	clock_t start = clock();
	s = cos_calc(n);
	clock_t end = clock();
 
	double duration = (double)(end - start) / CLOCKS_PER_SEC;
 
	printf("Somme: %.2f\n", s);
	printf("Duree: %.6f secondes\n", duration);
 
	return 0;
}

15/08/2025, 08h38
Peter57

commentaire

Je concois que la bibliothèque 'Math' de Python 3.13 soit sans doute mieux optimisée que celle de Cython pour le calcul de cos() et sin').
Mais j'obtiens des résultats similaires avec le calcul d'une suite de Fibonacci avec l'algorithme non recursif.

Hello,

Pour ce genre de problématique (hors le cas de la suite de Fibonacci qui est un problème itératif), la vectorisation est à mon sens une meilleure solution. Je vous recommande de regarder du côté de numpy.
Le souci principal vient du fait que votre code Cython n'est pas optimisé. Vous effectuez de nombreux allers-retours entre les types C et les objets Python, ce qui a forcément un coût en performance. La solution est de rester le plus possible dans les types C au sein de votre fonction Cython.
Pour cela, il faut utiliser les fonctions C de cosinus et sinus directement depuis la librairie mathématique C :

Code:

from libc.math cimport cos, sin

Ensuite, le code Cython peut être encore optimisé à l'aide de décorateurs (ou directives du compilateur) bien choisis qui évitent certaines vérifications de sécurité de Python (coûteuses en temps) :
Code:

1 2 3 4 5 6 7 import cython @cython.boundscheck(False) # Désactive la vérification des bornes (utile si vous accédiez à un tableau) @cython.wraparound(False) # Désactive la gestion de l'indexation négative (ex: liste[-1]) def cos_calc(int n): # ... suite du code
Même après cette optimisation, le C pur sera probablement toujours un peu plus rapide. C'est normal, il n'y a aucune surcouche liée à l'interpréteur Python.

Pour conclure, au niveau des performances pour votre fonction cos_calc, numpy reste le meilleur choix. Avec Cython, vous écrivez une boucle for qui, bien que compilée en C, traite les éléments un par un. À l'inverse, numpy transforme cette boucle en une série d'appels à des fonctions C vectorisées, qui sont bien plus performantes pour les calculs sur de grands tableaux de données.

Citation:

Envoyé par Peter57

Je concois que la bibliothèque 'Math' de Python 3.13 soit sans doute mieux optimisée que celle de Cython pour le calcul de cos() et sin').

Dans tous les cas, les fonctions sin et cos appelées sont celles du math.h de la libc qui vient avec le compilateur C (puisque Python est écrit en C, on ne va pas ré-écrire les fonction de base).
note: il y a aussi de microprocesseurs qui proposent des accélérateurs matériels qui passent peut être à côté.

On reprend votre code en ajoutant une petite fonction calc_sum qui estime le coût de ce qui n'est pas sin(i)+cos((i)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 from math import cos, sin from time import time def calc_trig(n): s = 0 for i in range(n): s += sin(i) + cos(i) return s def calc_sum(n): s = 0 for i in range(n): s += i return s def test(n, func): t0 = time() func(n) return time() - t0
Chez moi, j'obtiens:
Code:

1 2 3 4 5 6 7 8 9 10 >>> a = test(1000000, calc_trig) >>> b = test(1000000, calc_sum) >>> a 0.10003924369812012 >>> b 0.024285078048706055 >>> b/a 0.24275551424587996 >>>>>> a - b 0.07575416564941406
A quelques petites imprécisions près, vu que Cython et Python utilisent les mêmes fonctions sin et cos, si on "accélère" ce sera sur des instructions autres qui ne contribuent qu'à 25% du temps total.

Pour ce qui est du C, le compilateur peut s'amuser à utiliser des accélérations matérielles (et optimiser aussi le calcul des fonctions). Il faudrait regarder le code machine/assembleur pour voir ce qu'il a produit... si ça vous tente.

- W

16/08/2025, 17h52
Peter57

Merci de ces renseignements !
Cordialement.
Peter.