Salut à tous !

J'ai fait du Python pendant des années en cours et à chaque fois je me rappelle bien que les profs nous disaient que le langage Python était interprété et que chaque instruction était traduite une à une en routine pré-compilée.

Est-ce que quelqu'un pourrait m'expliquer pourquoi cette info est dans tous les cours de Python alors qu'apparemment le Python serait un langage compilé dans un fichier .pyc qui serait exécuté ?

+ Est-ce qu'il y a des livres indispensables à lire pour comprendre le Python réellement parce qu'après avoir fait des cours de Python je me sens idiot de ne pas avoir entendu parler des fichiers .pyc... c'est quand même la base... Est-ce que quelqu'un comprend d'où vient cette confusion ?

Merci d'avance.

-
Edité par Autechre 6 février 2022 à 22:06:21

Cette question est courante : https://stackoverflow.com/questions/2998215/if-python-is-interpreted-what-are-pyc-files

Pas de chance pour moi.

https://stackoverflow.com/questions/2998215/if-python-is-interpreted-what-are-pyc-files

C'était en maintenance.

Maintenant ça marche ...

-
Edité par PierrotLeFou 7 février 2022 à 4:21:45

J'ai découvert un article qui répond à ma question : https://tenthousandmeters.com/blog/python-behind-the-scenes-1-how-the-cpython-vm-works/

Malheureusement c'est loin d'être très clair... Manifestement le fonctionnement de CPython est assez mystérieux.

-
Edité par Autechre 12 février 2022 à 22:31:29

Quelles réponses ne sont pas présentes dans le lien explicatif que je t'ai partagé ?

Si tu as une question plus précise alors pose là... Mais celle posée à ton post original, et la réponse apportée au lien partagé répond amplement à ta question plutôt généraliste sur le sujet.

"tout simplement" :

Les fichiers compilés par ton interpréteur python (.pyc) sont au format byte code, qui n'est pas exécutable directement par la machine.

Les fichiers compilés en C++ (par exemple) par ton compilateur sont au format machine code, qui est exécutable directement par n'importe quelle machine.

Donc, en gros, les deux fichiers sont "compilés" mais un seul a besoin d'être interprété pour être exécuté.

Pour tout compliquer, le bytecode (suite d'instructions pour une machine virtuelle spécialisée pour le langage) peut être traduit en instructions machine lors de son chargement en machine (ou de sa première exécution).

C'est la notion de "Just In Time" , par opposition à "Ahead Of Time", la compilation classique qui se fait avant le chargement.

https://python.developpez.com/actu/352824/Python-3-13-ajoute-un-compilateur-JIT-qui-pourrait-ameliorer-les-performances-du-langage-d-environ-9-pourcent-mais-l-annonce-suscite-des-reactions-mitigees/

On peut voir le bytecode d'un source (ici fac.py)

def somme(n):
    s = 0
    for i in range(1, n+1):
        s += i
    return s

print(f"1+2+.. 5 = {somme(5)}")

en utilisant le module "dis"  (disassembler)

$ python3 -m dis fac.py 
  0           0 RESUME                   0

  1           2 LOAD_CONST               0 (<code object somme at 0x7f7e509f2c30, file "fac.py", line 1>)
              4 MAKE_FUNCTION            0
              6 STORE_NAME               0 (somme)

  7           8 PUSH_NULL
             10 LOAD_NAME                1 (print)
             12 LOAD_CONST               1 ('1+2+.. 5 = ')
             14 PUSH_NULL
             16 LOAD_NAME                0 (somme)
             18 LOAD_CONST               2 (5)
             20 PRECALL                  1
             24 CALL                     1
             34 FORMAT_VALUE             0
             36 BUILD_STRING             2
             38 PRECALL                  1
             42 CALL                     1
             52 POP_TOP
             54 LOAD_CONST               3 (None)
             56 RETURN_VALUE

Disassembly of <code object somme at 0x7f7e509f2c30, file "fac.py", line 1>:
  1           0 RESUME                   0

  2           2 LOAD_CONST               1 (0)
              4 STORE_FAST               1 (s)

  3           6 LOAD_GLOBAL              1 (NULL + range)
             18 LOAD_CONST               2 (1)
             20 LOAD_FAST                0 (n)
             22 LOAD_CONST               2 (1)
             24 BINARY_OP                0 (+)
             28 PRECALL                  2
             32 CALL                     2
             42 GET_ITER
        >>   44 FOR_ITER                 7 (to 60)
             46 STORE_FAST               2 (i)

  4          48 LOAD_FAST                1 (s)
             50 LOAD_FAST                2 (i)
             52 BINARY_OP               13 (+=)
             56 STORE_FAST               1 (s)
             58 JUMP_BACKWARD            8 (to 44)

  5     >>   60 LOAD_FAST                1 (s)
             62 RETURN_VALUE

-
Edité par michelbillaud 6 mars 2024 à 13:56:15

jeanpierredu31 a écrit:

Donc, en gros, les deux fichiers sont "compilés" mais un seul a besoin d'être interprété pour être exécuté.

Ce sont des instructions pour des machines différentes. Le langage machine (du processeur matériel) peut être lui aussi interprété (via un microcode).

On pourrait même écrire un programme qui interpréterait le code machine.