Optimització del codi Python amb eines de creació de perfils
Configurant Google Colab perquè funcioni per optimitzar el codi Python amb eines de creació de perfils, comencem configurant un entorn de Google Colab. Si som nous a Colab, és una plataforma essencial i potent basada en núvol que proporciona accés a quaderns de Jupyter i a una sèrie de biblioteques de Python. Accedim a Colab visitant (https://colab.research.google.com/) i creant un nou quadern Python.
Importa les biblioteques de perfils
La nostra optimització es basa en l'ús competent de les biblioteques de perfils. Dues biblioteques importants en aquest context són cProfile i line_profiler.
importar cPerfil
importar line_profiler
La biblioteca 'cProfile' és una eina de Python integrada per crear perfils de codi, mentre que 'line_profiler' és un paquet extern que ens permet aprofundir encara més, analitzant el codi línia per línia.
En aquest pas, creem un script Python de mostra per calcular la seqüència de Fibonacci mitjançant una funció recursiva. Analitzem aquest procés amb més profunditat. La successió de Fibonacci és un conjunt de nombres en què cada nombre successiu és la suma dels dos anteriors. Normalment comença amb 0 i 1, de manera que la seqüència sembla 0, 1, 1, 2, 3, 5, 8, 13, 21, etc. És una seqüència matemàtica que s'utilitza habitualment com a exemple en programació a causa de la seva naturalesa recursiva.
Definim una funció de Python anomenada 'Fibonacci' a la funció recursiva de Fibonacci. Aquesta funció pren un nombre enter 'n' com a argument, que representa la posició a la seqüència de Fibonacci que volem calcular. Volem localitzar el cinquè nombre a la seqüència de Fibonacci, per exemple, si 'n' és igual a 5.
def Fibonacci ( n ) :
A continuació, establim un cas base. Un cas base en recursivitat és un escenari que finalitza les trucades i retorna un valor predeterminat. A la seqüència de Fibonacci, quan “n” és 0 o 1, ja sabem el resultat. Els nombres 0 i 1 de Fibonacci són 0 i 1, respectivament.
si n <= 1 :tornar n
Aquesta declaració 'si' determina si 'n' és menor o igual a 1. Si ho és, retornem 'n' en si mateix, ja que no hi ha necessitat de més recursivitat.
Càlcul recursiu
Si “n” supera 1, procedim amb el càlcul recursiu. En aquest cas, hem de trobar el nombre de Fibonacci 'n'-è sumant els nombres de Fibonacci '(n-1)' i '(n-2)'. Ho aconseguim fent dues trucades recursives dins de la funció.
altra cosa :tornar Fibonacci ( n - 1 ) + Fibonacci ( n - 2 )
Aquí, “fibonacci(n – 1)” calcula el “(n-1)”è nombre de Fibonacci, i “fibonacci(n – 2)” calcula el “(n-2)”è nombre de Fibonacci. Sumem aquests dos valors per obtenir el nombre de Fibonacci desitjat a la posició 'n'.
En resum, aquesta funció 'fibonacci' calcula recursivament els nombres de Fibonacci dividint el problema en subproblemes més petits. Fa trucades recursives fins que arriba als casos bàsics (0 o 1), retornant valors coneguts. Per a qualsevol altre 'n', calcula el nombre de Fibonacci sumant els resultats de dues crides recursives de '(n-1)' i '(n-2)'.
Tot i que aquesta implementació és senzilla per calcular els nombres de Fibonacci, no és la més eficient. En els passos posteriors, utilitzarem les eines de creació de perfils per identificar i optimitzar les seves restriccions de rendiment per millorar els temps d'execució.
Perfil del codi amb CProfile
Ara, perfilem la nostra funció 'fibonacci' utilitzant 'cProfile'. Aquest exercici d'elaboració de perfils proporciona informació sobre el temps consumit per cada trucada de funció.
cprofiler = cPerfil. Perfil ( )cprofiler. habilitar ( )
resultat = Fibonacci ( 30 )
cprofiler. desactivar ( )
cprofiler. print_stats ( ordenar = 'acumulatiu' )
En aquest segment, inicialitzem un objecte 'cProfile', activem el perfilat, sol·licitem la funció 'fibonacci' amb 'n=30', desactivem el perfilat i mostrem les estadístiques que s'ordenen per temps acumulat. Aquest perfil inicial ens ofereix una visió general d'alt nivell de quines funcions consumeixen més temps.
! pip install line_profilerimportar cPerfil
importar line_profiler
def Fibonacci ( n ) :
si n <= 1 :
tornar n
altra cosa :
tornar Fibonacci ( n - 1 ) + Fibonacci ( n - 2 )
cprofiler = cPerfil. Perfil ( )
cprofiler. habilitar ( )
resultat = Fibonacci ( 30 )
cprofiler. desactivar ( )
cprofiler. print_stats ( ordenar = 'acumulatiu' )
Per perfilar el codi línia per línia amb line_profiler per a una anàlisi més detallada, utilitzem el 'line_profiler' per segmentar el nostre codi línia per línia. Abans d'utilitzar “line_profiler”, hem d'instal·lar el paquet al repositori Colab.
! pip install line_profilerAra que tenim el 'line_profiler' preparat, podem aplicar-lo a la nostra funció 'fibonacci':
%load_ext line_profilerdef Fibonacci ( n ) :
si n <= 1 :
tornar n
altra cosa :
tornar Fibonacci ( n - 1 ) + Fibonacci ( n - 2 )
%lprun -f Fibonacci ( 30 )
Aquest fragment comença carregant l'extensió 'line_profiler', defineix la nostra funció 'fibonacci' i, finalment, utilitza '%lprun' per perfilar la funció 'fibonacci' amb 'n=30'. Ofereix una segmentació línia per línia dels temps d'execució, precisament esborrant on el nostre codi gasta els seus recursos.
Després d'executar les eines de perfilació per analitzar els resultats, se li presentarà una sèrie d'estadístiques que mostren les característiques de rendiment del nostre codi. Aquestes estadístiques impliquen el temps total dedicat a cada funció i la durada de cada línia de codi. Per exemple, podem distingir que la funció de Fibonacci inverteix una mica més de temps en recalcular els valors idèntics diverses vegades. Aquest és el càlcul redundant i és una àrea clara on es pot aplicar l'optimització, ja sigui mitjançant la memorització o emprant els algorismes iteratius.
Ara, fem optimitzacions on hem identificat una optimització potencial a la nostra funció de Fibonacci. Hem observat que la funció torna a calcular els mateixos nombres de Fibonacci diverses vegades, donant lloc a una redundància innecessària i un temps d'execució més lent.
Per optimitzar-ho, implementem la memoització. La memoització és una tècnica d'optimització que consisteix a emmagatzemar els resultats calculats prèviament (en aquest cas, nombres de Fibonacci) i reutilitzar-los quan calgui en comptes de recalcular-los. Això redueix els càlculs redundants i millora el rendiment, especialment per a funcions recursives com la seqüència de Fibonacci.
Per implementar la memoització a la nostra funció de Fibonacci, escrivim el següent codi:
# Diccionari per emmagatzemar nombres de Fibonacci calculatsfib_cache = { }
def Fibonacci ( n ) :
si n <= 1 :
tornar n
# Comproveu si el resultat ja està a la memòria cau
si n en fib_cache:
tornar fib_cache [ n ]
altra cosa :
# Calcula i guarda el resultat a la memòria cau
fib_cache [ n ] = Fibonacci ( n - 1 ) + Fibonacci ( n - 2 )
tornar fib_cache [ n ] ,
En aquesta versió modificada de la funció 'fibonacci', introduïm un diccionari 'fib_cache' per emmagatzemar els nombres de Fibonacci calculats anteriorment. Abans de calcular un nombre de Fibonacci, comprovem si ja està a la memòria cau. Si és així, retornem el resultat de la memòria cau. En qualsevol altre cas, el calculem, el guardem a la memòria cau i després el retornem.
Repetició del perfil i optimització
Després d'implementar l'optimització (memoització en el nostre cas), és crucial repetir el procés de creació de perfils per conèixer l'impacte dels nostres canvis i assegurar-nos que millorem el rendiment del codi.
Elaboració de perfils després de l'optimització
Podem utilitzar les mateixes eines de creació de perfils, 'cProfile' i 'line_profiler', per perfilar la funció de Fibonacci optimitzada. Comparant els nous resultats de perfils amb els anteriors, podem mesurar l'efectivitat de la nostra optimització.
A continuació, es mostra com podem perfilar la funció 'fibonacci' optimitzada mitjançant 'cProfile':
cprofiler = cPerfil. Perfil ( )cprofiler. habilitar ( )
resultat = Fibonacci ( 30 )
cprofiler. desactivar ( )
cprofiler. print_stats ( ordenar = 'acumulatiu' )
Utilitzant el 'line_profiler', el perfilem línia per línia:
%lprun -f Fibonacci ( 30 )Codi:
# Diccionari per emmagatzemar nombres de Fibonacci calculatsfib_cache = { }
def Fibonacci ( n ) :
si n <= 1 :
tornar n
# Comproveu si el resultat ja està a la memòria cau
si n en fib_cache:
tornar fib_cache [ n ]
altra cosa :
# Calcula i guarda el resultat a la memòria cau
fib_cache [ n ] = Fibonacci ( n - 1 ) + Fibonacci ( n - 2 )
tornar fib_cache [ n ]
cprofiler = cPerfil. Perfil ( )
cprofiler. habilitar ( )
resultat = Fibonacci ( 30 )
cprofiler. desactivar ( )
cprofiler. print_stats ( ordenar = 'acumulatiu' )
%lprun -f Fibonacci ( 30 )
Per analitzar els resultats del perfil després de l'optimització, es reduiran significativament els temps d'execució, especialment per a valors 'n' grans. A causa de la memorització, observem que la funció ara passa molt menys temps a recalcular els nombres de Fibonacci.
Aquests passos són essencials en el procés d'optimització. L'optimització consisteix a fer canvis informats al nostre codi basant-se en les observacions que s'obtenen de la creació de perfils, mentre que la repetició de la creació de perfils garanteix que les nostres optimitzacions produeixin les millores de rendiment esperades. Mitjançant la creació de perfils iteratius, l'optimització i la validació, podem afinar el nostre codi Python per oferir un millor rendiment i millorar l'experiència de l'usuari de les nostres aplicacions.
Conclusió
En aquest article, vam parlar de l'exemple en què vam optimitzar el codi Python mitjançant eines de creació de perfils dins de l'entorn de Google Colab. Vam inicialitzar l'exemple amb la configuració, vam importar les biblioteques de perfils essencials, vam escriure els codis de mostra, el vam perfilar amb 'cProfile' i 'line_profiler', vam calcular els resultats, vam aplicar les optimitzacions i vam perfeccionar iterativament el rendiment del codi.