Verwendung von rolling().apply() auf Pandas Dataframe und Series

  2. How-To's
  3. Python Pandas How-To's
  4. Verwendung von rolling().apply() auf …
Mehvish Ashiq 21 Juni 2023
Pandas Pandas Rolling
  1. Verwenden Sie rolling().apply() auf einem Pandas DataFrame
  2. rolling.apply Mit Lambda
  3. Verwenden Sie rolling().apply() auf einer Pandas-Serie
Verwendung von rolling().apply() auf Pandas Dataframe und Series

Pandas Bibliothek hat viele nützliche Funktionen, rolling() ist eine davon, die komplexe Berechnungen auf den angegebenen Datensätzen durchführen kann. Wir haben auch eine Methode namens apply(), um die jeweilige Funktion/Methode mit einem rollenden Fenster auf die vollständigen Daten anzuwenden.

Wir können rolling().apply() mit Python-Serien und Datenrahmen verwenden. Dieses Tutorial informiert über die Methoden rolling() und apply() und zeigt auch, wie man rolling().apply() auf einem Pandas-Datenrahmen und -Serien verwendet.

Verwenden Sie rolling().apply() auf einem Pandas DataFrame

Lassen Sie uns Schritt für Schritt eintauchen, um die Verwendung von rolling().apply() in einem Datenrahmen zu lernen.

  • Bibliotheken importieren.
    import pandas as pd
import numpy as np

    Zuerst importieren wir die notwendigen Bibliotheken, pandas zum Spielen mit Datenrahmen und numpy zum Arbeiten mit Arrays, während wir die Funktion numpy.median() verwenden.

  • Erstellen Sie einen Datenrahmen.
    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)

    Ausgang:

     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

    Erstellen Sie als Nächstes einen Datenrahmen namens points_df, der verschiedene Punkte für Team_A, Team_B, Team_C und Team_D enthält. Wir können sehen, dass der Standardindex keinen Header (Überschrift) hat.

    Lassen Sie uns im nächsten Schritt eine Überschrift dafür erstellen.

  • Setzen Sie die Überschrift als index für den Standard-Spaltenindex.
    points_df.index.names = ["index"]
print(points_df)

    Ausgang:

    	 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

    Wie wir sehen können, ist die Überschrift index nicht auf Team_A, Team_B, Team_C und Team_D ausgerichtet. Lassen Sie es uns im folgenden Schritt tun.

  • Richten Sie alle Überschriften für den Datenrahmen points_df aus.
    points_df.columns.name = points_df.index.name
points_df.index.name = None
print(points_df)

    Ausgang:

    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
  • Erstellen Sie die Funktion calculate_median().
    def calculate_median(n):
    return np.median(n)

    Diese Funktion nimmt eine Reihe (wir können sagen, ein Array numerischer Werte) und gibt den Median dieser Reihe zurück.

  • Verwenden Sie rolling().apply() auf dem Datenrahmen points_df.
    points_df = points_df.rolling(2).apply(calculate_median)
print(points_df)

    Ausgang:

    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

    Hier wird das rolling() verwendet, um Rolling-Window-Berechnungen zu bedienen. Diese Idee (Rolling Window) wird in Signalprozessen und Zeitreihendatensätzen verwendet.

    Wir haben bereits einen Artikel über rolling(), seine Syntax, das Rolling-Window-Feature und seinen Arbeitsprozess geschrieben, indem wir verschiedene Rolling-Funktionen demonstriert haben. Das können Sie hier nachlesen.

    Wir verwenden die Funktion apply(), um eine benutzerdefinierte Funktion (in unserem Fall calculate_median()) auf die angegebenen Daten anzuwenden.

  • Hier ist der komplette Quellcode.
    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)

    Ausgang:

    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 Mit Lambda

Betrachten Sie den folgenden Code:

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)
    )
)

Ausgang:

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]

Da x in der lambda-Funktion eine (rollierende) Reihe/ndarray darstellt, kann die Funktion wie folgt geschrieben werden (wobei x[-1] sich auf den aktuellen rollierenden Datenpunkt bezieht).

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

Verwenden Sie rolling().apply() auf einer Pandas-Serie

Ebenso können wir rolling().apply() für eine Pandas-Serie verwenden. Der folgende Codezaun ist der gleiche, den wir für Pandas-Datenrahmen geschrieben haben, mit Ausnahme eines Unterschieds, wir verwenden hier Serien.

Der vollständige Quellcode ist unten angegeben, aber Sie können über die Serie im Detail hier lesen.

Beispielcode:

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)

Ausgang:

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