Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Interfaçage autre langage Python Discussion :

Amélioration code python3 avec cython


Sujet :

Interfaçage autre langage Python

  1. #1
    Futur Membre du Club
    Amélioration code python3 avec cython
    Bonjour,

    En vu de gagner en rapidité d’exécution est-il possible de transformer simplement le code de cette fonction écrit en python3 à l'aide de cython, je m'y suis déjà un peu frotté mais cela fait appel a des notions trop avancées en C pour moi. Je pensais sinon me diriger vers le langage Julia mais je n'arrive pas à utiliser le compilateur.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    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
     
    cpdef list reglesTour(int selfi,int selfj,int selftest,list selfpieces,list selfpermutation,list selftableaupos):
        selfi,selfj,selftest,selfpieces,selfpermutation,selftableaupos=selfi,selfj,selftest,selfpieces,selfpermutation,selftableaupos
        global selflienlettrepos
        global tableauposlettre
        cdef int nbrelem=len(selfpieces[selftest])
        pos=selfpieces[selftest][nbrelem-1]
        posactuelle=selflienlettrepos.get(pos)
        selfpostotaldeblettre, postotal, postotal1, postotal2, postotal3, postotal4=[], [], [], [], [], []
        if posactuelle!=None:
            if 0<=posactuelle[0]<=7 and 0<=posactuelle[1]<=7: 
                if selftest<17:
                    val="N"
                elif selftest>16:
                    val="B"
                for a in range(1, 8):
                    if posactuelle[0]+a>7:
                        break
                    else:
                        postotal1.append((posactuelle[0]+a,posactuelle[1]))
                for n in postotal1:
                    if selftableaupos[n[0]][n[1]] in ("V", val):
                        postotal.append(n)
                        if selftableaupos[n[0]][n[1]]==val:
                            break
                    else:
                        break
                for a in range(1, 8):        
                    if posactuelle[0]-a<0:
                        break
                    else:
                        postotal2.append((posactuelle[0]-a,posactuelle[1]))
                for n in postotal2:
                    if selftableaupos[n[0]][n[1]] in ("V", val):
                        postotal.append(n)
                        if selftableaupos[n[0]][n[1]]==val:
                            break
                    else:
                        break
                for a in range(1, 8):
                    if posactuelle[1]+a>7:
                        break
                    else:
                        postotal3.append((posactuelle[0],posactuelle[1]+a))
                for n in postotal3:
                    if selftableaupos[n[0]][n[1]] in ("V", val):
                        postotal.append(n)
                        if selftableaupos[n[0]][n[1]]==val:
                            break
                    else:
                        break
                for a in range(1, 8):        
                    if posactuelle[1]-a<0:
                        break
                    else:
                        postotal4.append((posactuelle[0],posactuelle[1]-a))
                for n in postotal4:
                    if selftableaupos[n[0]][n[1]] in ("V", val):
                        postotal.append(n)
                        if selftableaupos[n[0]][n[1]]==val:
                            break
                    else:
                        break
                postotal.append(posactuelle)
                for n in postotal:
                    selfpostotaldeblettre.append(tableauposlettre[n[0]][n[1]])
        return selfpostotaldeblettre


    Merci pour votre attention.
    Bonne journée.

  2. #2
    Expert confirmé
    Bonjour,

    Ce code est illisible... Il faut découper cette fonction en plusieurs, et exprimer ce que vous souhaitez faire sur chaque fonction découpée.

    cython accélère et améliore la réactivité d'un code, mais vous devez chercher quels sont les éléments critiques qui ralentissent avant de vous mettre à coder.
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  3. #3
    Expert éminent
    Bonjour,

    Mon expérience, c'est qu'il est d'abord indispensable de travailler l'algorithme en Python.

    On peut aussi travailler la qualité du code avec un analyseur de code comme PyLint.

    En voulant passer par Cython pour gagner en rapidité, il faut savoir que l'on gagne surtout quand la partie compilée en C ou en C++ n'utilise QUE des types de données reconnus par C ou C++. Ce n'est pas le cas de list, dict, etc... La conséquence est que le code compilé doit dans ce cas faire beaucoup d'appels à l'API Python, et on ne gagne plus grand chose en temps. Il m'est même arrivé d'obtenir un temps plus long qu'en Python normal!!!

    Quand ce n'est toujours pas assez rapide, plutôt que de changer de langage pour l'ensemble du programme, il y a toujours possibilité d'écrire un module Python en C ou en C++ uniquement sur la partie critique! Module qui sera ensuite importé par le programme Python. Il faut tout de même une connaissance suffisante en C ou C++, et la documentation dit comment il faut faire pour construire le module: https://docs.python.org/3/extending/index.html.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  4. #4
    Futur Membre du Club
    Bonjour,
    Je suis en train de regarder le langage C de plus près.
    Merci pour vos réponses.
    ++

  5. #5
    Futur Membre du Club
    Bonjour,

    Quelqu'un pourrait-il me donner une méthode pour créer un tableau à deux dimensions avec cython car je n'ai réussi qu'avec un tableau à une seule dimension.
    Je vous joins le code que j'ai trouvé.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    cdef int *my_ints
    my_ints = <int *>malloc(number*cython.sizeof(int))
    if my_ints is NULL:
      raise MemoryError()
    with nogil:
      free(my_ints)


    Merci d'avance.

  6. #6
    Expert éminent sénior
    Salut,

    Citation Envoyé par Sylvestre13 Voir le message
    Quelqu'un pourrait-il me donner une méthode pour créer un tableau à deux dimensions avec cython car je n'ai réussi qu'avec un tableau à une seule dimension.
    Avec Cython, vous programmez en C et ici, c'est le forum Python.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  7. #7
    Expert confirmé
    @Sylvestre13,

    wiztrick a raison, dans le sens que cython, c'est bien de l'interfaçage C et python, mais que votre question est bel est bien liée au langage C. Car si on sait créer un tableau C 2 dimensions, alors pour cython ça ira tout seul.
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  8. #8
    Modérateur

    Sans dénigrer Python, l'interfaçage avec Boost me semble plus simple pour appeler du C ou C++ depuis Python : https://gradot.wordpress.com/2018/12...depuis-python/

  9. #9
    Expert confirmé
    Les goûts et les couleurs, ça ne se discute pas !

    En ce qui me concerne je préfère cython...
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  10. #10
    Expert éminent
    Bonjour,

    Quelques infos complémentaires concernant l'appel de fonctions C++ grâce à cython ou directement. Je suis cependant un peu (!) en retard sur mon site puisque c'était en Python 2:

    - utilisation de cython: https://python.jpvweb.com/python/mesrecettespython/doku.php?id=exemple_cython_cpp. On peut appeler une fonction écrite en Python, ou appeler directement une fonction écrite en C++. Pour l'appel d'une fonction Python modifiée pour cython, j'ai utilisé la méthode des décorateurs qui a l'avantage d'ajouter ce qui manque pour le compilateur C++ (=les déclarations de variables) sans modifier le code de la fonction Python: http://docs.cython.org/en/latest/src/tutorial/pure.html.

    - appel direct par Python d'un module écrit en C++: https://python.jpvweb.com/python/mesrecettespython/doku.php?id=exemple_python_cpp. En Python 3, cela devrait correspondre au lien que j'ai déjà donné: https://docs.python.org/3/extending/index.html

    Je pense que la conversion en Python 3 ne devrait pas être trop compliquée.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  11. #11
    Expert éminent
    J'ai regardé ce que j'avais fait en Python 2 afin de l'adapter en Python 3, et la méthode d'appel direct de code C++ par Python (donc sans cython) a tout de même eu pas mal de changements complexes.

    Par contre, l'appel de code C++ grâce à cython marche toujours très bien et s'adapte facilement à Python 3: c'est donc la méthode que je recommande.

    Voilà mon exemple converti en Python 3:

    fichier d'entête en C++ "bib.h":

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    int pgcd_(int a, int b);


    fichier du code en C++ "bib.cpp":

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #include "bib.h"
     
    int pgcd_(int a, int b){
        int r;
        while (b!=0) {
            r = a%b;
            a = b;
            b = r;
            }
        return a;
        }


    fichier cython pour appeler la fonction externe pgcd_ (ne pas oublier le "_"!) "pgcd3.pyx":

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
     
    # definition des types Python
    from cpython cimport bool, list, dict, tuple
     
    # definition des type d'objets cython
    from cython import cclass, ccall, cfunc, returns as creturns, locals as clocals
     
    # reference a un objet defini en C++
    cdef extern from "bib.h": 
        cdef int pgcd_(int a, int b)
     
    #############################################################################
    @ccall
    @creturns(int)
    @clocals(a=int, b=int)
    def pgcd3(a, b):
        """PGCD de a et de b
        """
        return pgcd_(a,b)


    Et le fichier "setup.py" nécessaire au traitement par cython:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # -*- coding: utf-8 -*-
     
    from distutils.core import setup
    from distutils.extension import Extension
    from Cython.Distutils import build_ext
     
    ext_modules = [Extension("pgcd3",
                             sources=["pgcd3.pyx", "bib.cpp"],
                             include_dirs=["."],
                             language="c++"
                            )
                  ]
     
    setup(
      name = 'PGCD3',
      ext_modules = ext_modules,
      cmdclass = {'build_ext': build_ext}
      )


    Une fois ces fichiers créés, on lance le traitement par cython en console avec:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    python setup.py build_ext --inplace


    Cela donne un fichier "pgcd3.pyd" qui pourra être directement importé par un programme Python 3. Par exemple:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
     
    from pgcd3 import pgcd3
     
    from time import perf_counter
     
    n = 1000000
    a, b = 3819, 6384 # => PGCD=57
    t = perf_counter()
    for c in range(0, n):
        r = pgcd3(a, b)
    t = perf_counter()-t
    print(t, t/n)


    Ce qui donne un temps moyen de calcul par appel de: 1.602227e-07 seconde.

    Le même programme de test sur la fonction pgcd codée en pure Python donne 0.6010849e-07 seconde. On a donc gagné environ 73% sur le temps d'exécution.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

###raw>template_hook.ano_emploi###