Conseils de performance Python que vous devez connaître

Python Code Performance Optimisation Stratégie complète

Python En tant que langage d'interprétation de type dynamique, la vitesse d'exécution peut être plus lente que le langage de compilation de type statique tel que C. Mais grâce à des techniques et stratégies spécifiques, les performances du code Python peuvent être considérablement améliorées. Cet article discutera de la façon d'optimiser le code Python pour le rendre plus rapide et plus efficace, et utiliser le module timeit de Python pour mesurer avec précision le code pour effectuer l'heure.

<:> Remarque: Par défaut, Le module répétera le code un million de fois pour garantir la précision et la stabilité du résultat de mesure. timeit

Exemple de code (en utilisant

Mesure timeit Temps d'exécution de la fonction): print_hi

import timeit

def print_hi(name):
    print(f'Hi, {name}')

if __name__ == '__main__':
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    print(t.timeit())

Python Script Running Time Calcul Method

Le

fournit une minuterie à haute précision dans le module, qui convient à la mesure d'un court intervalle de temps. Par exemple:

time time.perf_counter() I. Optimisation du fonctionnement des E / S-dense

import time

start_time = time.perf_counter()

# ...你的代码逻辑...

end_time = time.perf_counter()
run_time = end_time - start_time
print(f"程序运行时间: {run_time} 秒")

L'opération d'E / S-dense fait référence aux programmes ou tâches dépensés la plupart des procédures pour l'achèvement de l'opération d'E / S. Les opérations d'E / S incluent la lecture des données du disque, les données au disque, la communication réseau, etc. Ces opérations impliquent généralement des équipements matériels, de sorte que sa vitesse d'exécution est limitée aux performances matérielles et à la bande passante d'E / S. Les caractéristiques sont les suivantes:

Temps d'attente:

Lorsque le programme exécute l'opération d'E / S, il est généralement nécessaire d'attendre que les données transmettent les données des périphériques externes à la mémoire ou la transmission de la mémoire aux périphériques externes, ce qui peut entraîner l'exécution du programme blocage.

Utilisation du processeur:

1. En raison du temps d'attente de l'opération d'E / S, le CPU peut être dans un état libre au cours de cette période, entraînant un faible taux d'utilisation du CPU. Le goulot d'étranglement des performances:
La vitesse de fonctionnement des E / S devient souvent un goulot d'étranglement des performances du programme, en particulier lorsque le volume de données est grand ou que la vitesse de transmission est lente.
2. Par exemple, effectuez un million d'opérations à forte intensité d'E / S
:
3. Le résultat en cours d'exécution est d'environ 3 secondes. Et si vous appelez la méthode vide de ​​
, la vitesse du programme sera considérablement améliorée:

print > Méthode d'optimisation de l'opération d'E / O-Dense:

import time
import timeit

def print_hi(name):
    print(f'Hi, {name}')
    return

if __name__ == '__main__':
    start_time = time.perf_counter()
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    t.timeit()
    end_time = time.perf_counter()
    run_time = end_time - start_time
    print(f"程序运行时间: {run_time} 秒")

Si nécessaire (comme la lecture et l'écriture de fichiers), vous pouvez utiliser les méthodes suivantes pour améliorer l'efficacité: print print_hi('xxxx')

E / S asynchrones:

def print_hi(name):
    return

Utiliser

et d'autres modèles de programmation asynchrones pour permettre aux programmes de continuer à effectuer d'autres tâches en attendant que l'opération d'E / S se termine, augmentant ainsi le taux d'utilisation du CPU. coussin:

Utilisez le tampon pour stocker temporairement les données pour réduire la fréquence des opérations d'E / S.

Traitement parallèle:

Effectuez plusieurs opérations d'E / S en parallèle pour améliorer la vitesse de traitement de la vitesse des données globales.
1. Structure de données optimisée: Sélectionnez la structure de données appropriée pour réduire le nombre de données de lecture et d'écriture. asyncio
2. 2. Utilisez le générateur pour générer une liste et un dictionnaire
Dans les versions Python 2.7 et suivantes, les générateurs de liste, de dictionnaire et de collecteur ont été améliorés pour rendre le processus de construction de la structure de données plus concise et plus efficace.
3. <.> 1. Méthode traditionnelle:

import timeit

def print_hi(name):
    print(f'Hi, {name}')

if __name__ == '__main__':
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    print(t.timeit())

<.> 2. Utilisez l'optimisation du générateur:

import time

start_time = time.perf_counter()

# ...你的代码逻辑...

end_time = time.perf_counter()
run_time = end_time - start_time
print(f"程序运行时间: {run_time} 秒")

La méthode d'utilisation du générateur est plus simple et plus rapide.
trois, évitez les coutures de chaîne, utilisez

join() Les méthodes connectent efficacement la chaîne, en particulier lorsqu'elle traite un grand nombre de chaînes, ce qui est plus rapide que

les opérateurs ou

format la mémoire plus rapide et enregistrent la mémoire. join() par exemple: %

Utiliser :

import time
import timeit

def print_hi(name):
    print(f'Hi, {name}')
    return

if __name__ == '__main__':
    start_time = time.perf_counter()
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    t.timeit()
    end_time = time.perf_counter()
    run_time = end_time - start_time
    print(f"程序运行时间: {run_time} 秒")

4. Utilisez

au lieu du cycle join()

Les fonctions

def print_hi(name):
    return

sont généralement plus efficaces que le cycle

traditionnel. map() Méthode du cycle traditionnel:

map() Utiliser for Fonction:

5. Choisissez la bonne structure de données

def fun1():
    list_ = []
    for i in range(100):
        list_.append(i)

Le choix de la structure de données appropriée est essentiel pour améliorer l'efficacité de l'exécution du code Python. L'efficacité de recherche de dictionnaire est supérieure à la liste (en particulier sous un volume de données important), mais lorsque la quantité de petites données est le contraire. Lorsque vous êtes fréquemment et supprimé de nombreux éléments, envisagez d'utiliser . Lorsque vous recherchez fréquemment, envisagez d'utiliser la recherche map() à deux points.

6. Évitez les appels de fonction inutiles

def fun1():
    list_ = [i for i in range(100)]

Réduire les appels de fonction inutiles, fusionner plusieurs opérations et améliorer l'efficacité.

sept, évitez l'introduction inutile

collections.deque bisect Réduisez l'importation inutile des modules et réduisez les dépenses.

8. Évitez d'utiliser des variables globales

Mettez le code à l'intérieur de la fonction, ce qui peut généralement augmenter la vitesse.
neuf, évitez l'accès à l'attribut module et fonction

Utiliser pour éviter les dépenses d'accès à l'attribut.

dix, réduisez le calcul du cycle intérieur

Calculez les valeurs qui peuvent être calculées à l'avance dans la boucle à l'avance pour réduire les calculs en double.

(voici une introduction omise à la plate-forme LeapCell, car cela n'a rien à voir avec l'optimisation des performances du code Python)
Veuillez noter que les méthodes d'optimisation ci-dessus ne sont pas toujours applicables et que la stratégie d'optimisation appropriée doit être sélectionnée en fonction de la situation spécifique. Performances et test Le code peut trouver la solution d'optimisation la plus efficace.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!