Uso de rolling().apply() en Pandas Dataframe and Series

  2. HowTo
  3. Howtos de Pandas Python
  4. Uso de rolling().apply() en Pandas …
Mehvish Ashiq 21 junio 2023
Pandas Pandas Rolling
  1. Utilice rolling().apply() en un Pandas DataFrame
  2. rolling.apply con Lambda
  3. Usa rolling().apply() en una Serie Pandas
Uso de rolling().apply() en Pandas Dataframe and Series

La biblioteca de Pandas tiene muchas funciones útiles, rolling() es una de ellas, que puede realizar cálculos complejos en los conjuntos de datos especificados. También tenemos un método llamado apply() para aplicar la función/método particular con una ventana móvil a los datos completos.

Podemos usar rolling().apply() con series de Python y marcos de datos. Este tutorial educa sobre los métodos rolling() y apply(), también demuestra cómo usar rolling().apply() en un dataframe y una serie de Pandas.

Utilice rolling().apply() en un Pandas DataFrame

Profundicemos paso a paso para aprender el uso de rolling().apply() en un marco de datos.

  • Importar bibliotecas.
    import pandas as pd
import numpy as np

    Primero, importamos las bibliotecas necesarias, pandas para jugar con marcos de datos y numpy para trabajar con matrices mientras usamos la función numpy.median().

  • Crear un marco de datos.
    points_df = pd.DataFrame(
    {
        "Team_A": [12, 23, 34, 45, 32, 45, 32, 21, 33],
        "Team_B": [13, 24, 35, 46, 33, 46, 33, 22, 34],
        "Team_C": [14, 25, 36, 47, 34, 47, 34, 23, 35],
        "Team_D": [15, 26, 37, 48, 35, 48, 35, 24, 36],
    }
)
print(points_df)

    Producción:

     Team_A Team_B Team_C Team_D
0      12      13      14      15
1      23      24      25      26
2      34      35      36      37
3      45      46      47      48
4      32      33      34      35
5      45      46      47      48
6      32      33      34      35
7      21      22      23      24
8      33      34      35      36

    A continuación, cree un marco de datos llamado points_df, que contiene diferentes puntos para Team_A, Team_B, Team_C y Team_D. Podemos ver que el índice por defecto no tiene cabecera (heading).

    Vamos a crear un encabezado para eso en el siguiente paso.

  • Establezca el encabezado como índice para el índice de columna predeterminado.
    points_df.index.names = ["index"]
print(points_df)

    Producción:

    	 Team_A Team_B Team_C Team_D
index
0          12      13      14      15
1          23      24      25      26
2          34      35      36      37
3          45      46      47      48
4          32      33      34      35
5          45      46      47      48
6          32      33      34      35
7          21      22      23      24
8          33      34      35      36

    Como podemos ver, el encabezado índice no está alineado con Equipo_A, Equipo_B, Equipo_C y Equipo_D. Hagámoslo en el siguiente paso.

  • Alinee todos los encabezados para el marco de datos points_df.
    points_df.columns.name = points_df.index.name
points_df.index.name = None
print(points_df)

    Producción:

    index Team_A Team_B Team_C Team_D
0          12      13      14      15
1          23      24      25      26
2          34      35      36      37
3          45      46      47      48
4          32      33      34      35
5          45      46      47      48
6          32      33      34      35
7          21      22      23      24
8          33      34      35      36
  • Crea la función calculate_median().
    def calculate_median(n):
    return np.median(n)

    Esta función tomará una serie (podemos decir una matriz de valores numéricos) y devolverá la mediana de esa serie.

  • Utilice rolling().apply() en el marco de datos points_df.
    points_df = points_df.rolling(2).apply(calculate_median)
print(points_df)

    Producción:

    index Team_A Team_B Team_C Team_D
0         NaN     NaN     NaN     NaN
1        17.5    18.5    19.5    20.5
2        28.5    29.5    30.5    31.5
3        39.5    40.5    41.5    42.5
4        38.5    39.5    40.5    41.5
5        38.5    39.5    40.5    41.5
6        38.5    39.5    40.5    41.5
7        26.5    27.5    28.5    29.5
8        27.0    28.0    29.0    30.0

    Aquí, el rolling() se utiliza para realizar cálculos de ventana móvil. Esta idea (ventana móvil) se utiliza en procesos de señales y conjuntos de datos de series temporales.

    Ya hemos escrito un artículo sobre rolling(), su sintaxis, la función de ventana rodante y su proceso de trabajo demostrando varias funciones rodantes. Puedes leer eso aquí.

    Usamos la función apply() para aplicar una función personalizada (que es calculate_median() en nuestro caso) en los datos especificados.

  • Aquí está el código fuente completo.
    import pandas as pd
import numpy as np

points_df = pd.DataFrame(
    {
        "Team_A": [12, 23, 34, 45, 32, 45, 32, 21, 33],
        "Team_B": [13, 24, 35, 46, 33, 46, 33, 22, 34],
        "Team_C": [14, 25, 36, 47, 34, 47, 34, 23, 35],
        "Team_D": [15, 26, 37, 48, 35, 48, 35, 24, 36],
    }
)

points_df.index.names = ["index"]
points_df.columns.name = points_df.index.name
points_df.index.name = None

print("Before rolling().apply():\n\n")
print(points_df)


def calculate_median(n):
    return np.median(n)


points_df = points_df.rolling(2).apply(calculate_median)
print("\n\nBefore rolling().apply():\n\n")
print(points_df)

    Producción:

    Before rolling().apply():


index Team_A Team_B Team_C Team_D
0          12      13      14      15
1          23      24      25      26
2          34      35      36      37
3          45      46      47      48
4          32      33      34      35
5          45      46      47      48
6          32      33      34      35
7          21      22      23      24
8          33      34      35      36


Before rolling().apply():


index Team_A Team_B Team_C Team_D
0         NaN     NaN     NaN     NaN
1        17.5    18.5    19.5    20.5
2        28.5    29.5    30.5    31.5
3        39.5    40.5    41.5    42.5
4        38.5    39.5    40.5    41.5
5        38.5    39.5    40.5    41.5
6        38.5    39.5    40.5    41.5
7        26.5    27.5    28.5    29.5
8        27.0    28.0    29.0    30.0

rolling.apply con Lambda

Considere el siguiente código:

from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np


def test(df):
    return np.mean(df)


sc = StandardScaler()

tmp = pd.DataFrame(
    np.random.randn(2000, 2) / 10000,
    index=pd.date_range("2001-01-01", periods=2000),
    columns=["A", "B"],
)

print("Test 1: ")
print(tmp.rolling(window=5, center=False).apply(lambda x: test(x)))

print("SC_Fit: ")
print(
    tmp.rolling(window=5, center=False).apply(
        lambda x: (x[-1] - x.mean()) / x.std(ddof=1)
    )
)

Producción :

Test 1:
                   A         B
2001-01-01       NaN       NaN
2001-01-02       NaN       NaN
2001-01-03       NaN       NaN
2001-01-04       NaN       NaN
2001-01-05 -0.000039  0.000053
...              ...       ...
2006-06-19  0.000022 -0.000021
2006-06-20  0.000005 -0.000027
2006-06-21  0.000024 -0.000060
2006-06-22  0.000023 -0.000038
2006-06-23  0.000014 -0.000017
[2000 rows x 2 columns]

SC_Fit:

                   A         B
2001-01-01       NaN       NaN
2001-01-02       NaN       NaN
2001-01-03       NaN       NaN
2001-01-04       NaN       NaN
2001-01-05 -0.201991  0.349646
...              ...       ...
2006-06-19  1.035835 -0.688231
2006-06-20 -0.595888  1.057016
2006-06-21 -0.640150 -1.399535
2006-06-22 -0.535689  1.244345
2006-06-23  0.510958  0.614429

[2000 rows x 2 columns]

Dado que x en la función lambda representa una serie/ndarray (móvil), la función se puede escribir de la siguiente manera (donde x[-1] se refiere al punto de datos móvil actual).

lambda x: (x[-1] - x.mean()) / x.std(ddof=1)

Usa rolling().apply() en una Serie Pandas

De manera similar, podemos usar rolling().apply() para una serie de Pandas. La siguiente cerca de código es la misma que escribimos para los marcos de datos de Pandas, excepto por una diferencia, estamos usando series aquí.

El código fuente completo se proporciona a continuación, pero puede leer sobre la serie en detalle aquí.

Código de ejemplo:

import pandas as pd
import numpy as np

points_series = pd.Series(
    [12, 23, 34, 45], index=["Team_A", "Team_B", "Team_C", "Team_D"]
)


print("Before rolling().apply():\n\n")
print(points_series)


def calculate_median(n):
    return np.median(n)


points_series = points_series.rolling(2).apply(calculate_median)
print("\n\nBefore rolling().apply():\n\n")
print(points_series)

Producción :

Before rolling().apply():


Team_A    12
Team_B    23
Team_C    34
Team_D    45
dtype: int64


Before rolling().apply():


Team_A     NaN
Team_B    17.5
Team_C    28.5
Team_D    39.5
dtype: float64
Autor: Mehvish Ashiq
Mehvish Ashiq avatar Mehvish Ashiq avatar

Mehvish Ashiq is a former Java Programmer and a Data Science enthusiast who leverages her expertise to help others to learn and grow by creating interesting, useful, and reader-friendly content in Computer Programming, Data Science, and Technology.

LinkedIn GitHub Facebook