es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • El bucle iloc de Python está tardando demasiado tiempo en ejecutarse. Cálculo de análisis técnico.

El bucle iloc de Python está tardando demasiado tiempo en ejecutarse. Cálculo de análisis técnico.

28 Jul, 2023 Programación

Desarrollé un código para analizar un gran conjunto de precios de acciones. Básicamente utiliza dos indicadores técnicos (MACD y EMA) y crea una bandera de análisis técnico.

El código funciona, lo cual es genial, pero está tardando demasiado en ejecutarse, probablemente debido a las iteraciones que utilizan iloc. ¿Tienen algunas sugerencias para mejorar la velocidad? A continuación, proporciono un ejemplo:

“`python
import pandas as pd
import numpy as np
import time

df = pd.DataFrame(np.random.uniform(low=2, high=5.5, size=(10000,)), columns=['Close'])
close = df['Close'].astype(float)

def MACD(primer, segundo, señal):
df['EMA'+str(primer)] = close.ewm(span=primer).mean()
df['EMA'+str(segundo)] = close.ewm(span=segundo).mean()
df['MACD']=df['EMA'+str(primer)]-df['EMA'+str(segundo)]
df['señal']=df.MACD.ewm(span=señal).mean()
df['indicador_MACD'] = 0

<pre><code>for i in range (segundo+señal, len(df)):
if df.MACD.iloc[i]>df.señal.iloc[i] and df.MACD.iloc[i-1]<df.señal.iloc[i-1]: df.loc[i,'indicador_macd']="1" if=""></df.señal.iloc[i-1]:><df.señal.iloc[i] and="" df.macd.iloc[i-1]="">df.señal.iloc[i-1]:
df.loc[i,'indicador_MACD']=-1
</code></pre>

def EMA(primer, segundo):
df['EMA'+str(primer)] = close.rolling(window=primer).mean()
df['EMA'+str(segundo)] = close.rolling(window=segundo).mean()
df['diferencia_EMA'] = df['EMA'+str(primer)]-df['EMA'+str(segundo)]
df['indicador_EMA'] = 0
for i in range (segundo, len(df)):
if df.diferencia_EMA.iloc[i]>0 and df.diferencia_EMA.iloc[i-1]<0:
df.loc[i,'indicador_EMA']=1
if df.diferencia_EMA.iloc[i]<0 and df.diferencia_EMA.iloc[i-1]>0:
df.loc[i,'indicador_EMA']=-1

split_time = time.time()
indicadores_TA=list()

MACD(12, 26, 9)
indicadores_TA.append('indicador_MACD')
print("MACD— %s segundos —" % (time.time() – split_time))
split_time = time.time()

EMA(20,50)
indicadores_TA.append('indicador_EMA')
print("EMA— %s segundos —" % (time.time() – split_time))
split_time = time.time()
“`</df.señal.iloc[i]>

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Sí, hay algunas sugerencias para mejorar la velocidad del código. Una posible solución es utilizar operaciones vectorizadas en lugar de iterar a través del dataframe utilizando iloc. Aquí hay algunos ejemplos:

    • En lugar de utilizar iloc para acceder a las columnas del dataframe, utiliza la notación de punto: En lugar de df.MACD.iloc[i], usa df.MACD[i]. Esto puede mejorar la velocidad porque evita el costo adicional del método iloc.
    • Utiliza np.where en lugar de un bucle for: En lugar de utilizar un bucle for para establecer los valores de las columnas MACD_ind y EMA_ind, utiliza np.where para establecer los valores condicionalmente. Esto puede ser mucho más rápido que usar un bucle for.
    • Utiliza el método apply en lugar de un bucle for: En lugar de utilizar un bucle for para aplicar las funciones MACD y EMA a las columnas del dataframe, utiliza el método apply. Esto puede mejorar la velocidad porque evita el costo adicional del bucle for.

    Aquí tienes un ejemplo de cómo podrías modificar la función MACD para utilizar operaciones vectorizadas y np.where:

    def MACD(first, second, signal):
    df['EMA'+str(first)] = close.ewm(span=first).mean()
    df['EMA'+str(second)] = close.ewm(span=second).mean()
    df['MACD'] = df['EMA'+str(first)] - df['EMA'+str(second)]
    df['signal'] = df.MACD.ewm(span=signal).mean()

    df['MACD_ind'] = np.where((df.MACD.shift(1) < df.signal.shift(1)) & (df.MACD > df.signal), 1, 0)
    df['MACD_ind'] = np.where((df.MACD.shift(1) > df.signal.shift(1)) & (df.MACD < df.signal), -1, df['MACD_ind'])

    La función EMA también podría ser modificada de manera similar. Estos cambios deberían ayudar a mejorar la velocidad del código al reducir el número de iteraciones y reemplazarlas con operaciones vectorizadas.

Comments are closed.