Pourquoi le code Python s'exécute-t-il plus vite dans une fonction?

Vous pourriez vous demander pourquoi il est plus rapide pour stocker les variables locales que globales. C'est un Disponible détail d'implémentation.

Rappelez-vous que Disponible est compilé en bytecode, qui l'interprète exécute. Lorsqu'une fonction est compilé, les variables locales sont stockées dans un tableau de taille fixe (pas un dict) et les noms de variables sont affectées à l'index. Cela est possible parce que vous ne pouvez pas ajouter dynamiquement des variables locales à une fonction. Puis récupérer une variable locale est littéralement un pointeur de recherche dans la liste et le refcount augmentation de la PyObject qui est trivial.

Cela contraste global de recherche (LOAD_GLOBAL), qui est un vrai dict de recherche impliquant un hachage et ainsi de suite. D'ailleurs, c'est pourquoi vous avez besoin de spécifier global i si vous voulez qu'il soit global: si jamais vous affecter à une variable à l'intérieur d'un champ, le compilateur émet STORE_FASTs pour son accès, sauf si vous lui dites de ne pas.

Par le moyen global des recherches sont encore assez optimisé. Attribut recherches foo.bar sont les vraiment lent!

Voici le petit illustration sur la variable locale de l'efficacité.

À part local/global variable magasin fois, opcode prédiction rend la fonction plus rapide.

Que les autres réponses expliquer, la fonction utilise la STORE_FAST opcode dans la boucle. Voici le pseudo-code pour la fonction de boucle:

    >>   13 FOR_ITER                 6 (to 22)   # get next value from iterator
         16 STORE_FAST               0 (x)       # set local variable
         19 JUMP_ABSOLUTE           13           # back to FOR_ITER

Normalement, lorsqu'un programme est exécuté, Python exécute chaque opcode l'un après l'autre, en gardant la trace de la pile et de préformage d'autres contrôles sur le frame de pile après chaque opcode est exécutée. Opcode prédiction signifie que, dans certains cas, le langage Python est capable de sauter directement à la prochaine opcode, évitant ainsi certains de ces frais.

Dans ce cas, à chaque fois que Python voit FOR_ITER (en haut de la boucle), il "prédit" que STORE_FAST est la prochaine opcode il a à exécuter. Python puis jettant un oeil à la prochaine opcode et, si la prédiction était correcte, il saute directement à STORE_FAST. Cela a pour effet de comprimer les deux opérateurs dans un seul opcode.

D'autre part, la STORE_NAME opcode est utilisée dans la boucle au niveau mondial. Python n' *pas* faire des prédictions similaires lorsqu'il voit cet opcode. Au lieu de cela, il doit revenir à la partie supérieure de l'évaluation de la boucle qui a des répercussions évidentes sur la vitesse à laquelle la boucle est exécutée.

Pour donner plus de détails techniques sur cette optimisation, voici une citation de la ceval.c fichier (le "moteur" de Python de la machine virtuelle):

Certains opérateurs ont tendance à venir en paires afin de rendre possible le
prédire le deuxième code lors de la première exécution. Par exemple,
GET_ITER est souvent suivi par FOR_ITER. Et FOR_ITER est souvent
suivi par STORE_FAST ou UNPACK_SEQUENCE.

De la vérification de la prévision des coûts d'un seul haut-test de vitesse d'un registre
variable par rapport à une constante. Si le couplage a été bonne, l'
processeur internes de la direction de la prévision a une forte probabilité de
un succès qui entraîne une quasi nulle-frais de transition de la
à côté de l'opcode. Un succès de prédiction enregistre un voyage à travers l'eval-boucle
y compris ses deux imprévisible branches, la HAS_ARG test et la
cas de commutateur. Combiné avec le processeur interne de la direction de la prévision,
un succès PREDICT a pour effet de rendre les deux opérateurs s'exécuter comme si
ils ont un seul nouveau opcode avec les organes combinés.

Nous pouvons le voir dans le code source de la FOR_ITER opcode exactement où la prédiction pour STORE_FAST est fait:

case FOR_ITER:                         //the FOR_ITER opcode case
    v = TOP();
    x = (*v->ob_type->tp_iternext)(v); //x is the next value from iterator
    if (x != NULL) {                     
        PUSH(x);                       //put x on top of the stack
        PREDICT(STORE_FAST);           //predict STORE_FAST will follow - success!
        PREDICT(UNPACK_SEQUENCE);      //this and everything below is skipped
        continue;
    }
    //error-checking and more code for when the iterator ends normally                                     

La PREDICT fonction s'étend à if (*next_instr == op) goto PRED_##op c'est à dire juste sauter au début de la prédiction de l'opcode. Dans ce cas, on saute ici:

PREDICTED_WITH_ARG(STORE_FAST);
case STORE_FAST:
    v = POP();                     //pop x back off the stack
    SETLOCAL(oparg, v);            //set it as the new local variable
    goto fast_next_opcode;

La variable locale est maintenant réglée et la prochaine opcode est en place pour l'exécution. Python se poursuit à travers le itératif jusqu'à ce qu'il atteigne la fin, en faisant le succès de la prédiction à chaque fois.

La Python page wiki a plus d'informations sur comment Disponible de la machine virtuelle fonctionne.