Pandas & NumPy Academy · Lektion

apply() auf Spalten und Zeilen

Verwenden Sie DataFrame.apply() mit axis=0 und axis=1, um eine benutzerdefinierte Funktion auf jede Spalte oder jede Zeile anzuwenden.

Lektion 1 von 413 Schritte

apply() auf Spalten und Zeilen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Wann apply() verwendet wird

DataFrame.apply() führt eine benutzerdefinierte Python-Funktion für jede Spalte (axis=0) oder jede Zeile (axis=1) aus. Es ist das Mittel der letzten Wahl – langsamer als integrierte vektorisierte Operationen –, aber unverzichtbar, wenn sich eine Berechnung nicht mit NumPy-Arithmetik, boolescher Indexierung oder integrierten Aggregationsfunktionen ausdrücken lässt. Verwenden Sie es, wenn Sie komplexe bedingte Logik, eine benutzerdefinierte String-Analyse oder mehrstufige Berechnungen benötigen, die jeweils auf einer einzelnen Zeile oder Spalte arbeiten.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'price': [10.5, 25.0, 8.3, 100.0],
    'quantity': [3, 1, 5, 2],
    'tax_rate': [0.05, 0.10, 0.05, 0.15]
})
print(df)

apply() auf Spalten anwenden (axis=0)

Mit axis=0 (der Standardeinstellung) übergibt apply() jede Spalte als Series an die Funktion. Die Funktion erhält jeweils eine Spalte und sollte einen Skalar (für eine Aggregation) oder eine Series (für eine Transformation) zurückgeben. Das ist nützlich, um in einem Aufruf einheitlich auf alle numerischen Spalten eine benutzerdefinierte Normalisierung oder Bereinigung anzuwenden.

# Custom range normalisation (0 to 1) for each column
def min_max_scale(col):
    return (col - col.min()) / (col.max() - col.min())

df_scaled = df[['price', 'quantity']].apply(min_max_scale, axis=0)
print(df_scaled)

apply() auf Zeilen anwenden (axis=1)

Mit axis=1 übergibt apply() jede Zeile als Series an die Funktion. Der Index der Zeile entspricht dem Spaltennamen, sodass Sie über den Namen auf Werte zugreifen können. Das ist ideal für Berechnungen auf Zeilenebene, die von mehreren Spalten abhängen, etwa für die Berechnung des Gesamtumsatzes nach Steuern, wenn jede Zeile ihren eigenen Steuersatz enthält.

def revenue_after_tax(row):
    subtotal = row['price'] * row['quantity']
    return subtotal * (1 + row['tax_rate'])

df['revenue_after_tax'] = df.apply(revenue_after_tax, axis=1)
print(df)

Mehrere Werte mit apply() zurückgeben

Eine an apply(axis=1) übergebene Funktion kann eine pd.Series mit benannten Einträgen zurückgeben, die Pandas in mehrere neue Spalten aufteilt. Das ist übersichtlicher, als apply() zweimal für zwei neue Spalten aufzurufen. Alternativ kann die Funktion ein dict zurückgeben, das Pandas ebenfalls in Spalten aufteilt.

def compute_totals(row):
    subtotal = row['price'] * row['quantity']
    tax = subtotal * row['tax_rate']
    return pd.Series({'subtotal': subtotal, 'tax': tax, 'total': subtotal + tax})

result = df.apply(compute_totals, axis=1)
print(result)

Benutzerdefinierte Aggregation von Spalten mit apply()

Verwenden Sie apply(func, axis=0), um für jede Spalte eine benutzerdefinierte Kennzahl zu berechnen und eine zusammenfassende Series zurückzugeben. Sie können beispielsweise in einem Aufruf für jede numerische Spalte den Variationskoeffizienten (Standardabweichung geteilt durch Mittelwert) berechnen. Das Ergebnis ist eine nach Spaltennamen indizierte Series, die sich für eine schnelle Diagnose pro Spalte eignet.

def coeff_of_variation(col):
    return col.std() / col.mean() if col.mean() != 0 else np.nan

cv = df[['price', 'quantity']].apply(coeff_of_variation, axis=0)
print('Coefficient of variation per column:')
print(cv)

apply() mit vektorisierten Alternativen vergleichen

Prüfen Sie vor der Verwendung von apply() immer, ob eine vektorisierte Alternative existiert. Für die Berechnung des Umsatzes nach Steuern bewirkt df['price'] * df['quantity'] * (1 + df['tax_rate']) dasselbe wie die Variante mit apply(axis=1), läuft aber 10- bis 100-mal schneller, da sie Schleifen auf C-Ebene von NumPy verwendet. Verwenden Sie apply() nur in Fällen, in denen vektorisierte Logik unleserlich komplex wäre.

import time

start = time.time()
df['vectorised'] = df['price'] * df['quantity'] * (1 + df['tax_rate'])
print('Vectorised:', time.time() - start, 's')

start = time.time()
df['apply_result'] = df.apply(revenue_after_tax, axis=1)
print('apply():', time.time() - start, 's')

apply() mit einer Lambda-Funktion

Für kurze Transformationen in einer Zeile übergeben Sie direkt eine lambda-Funktion an apply(), statt eine benannte Funktion zu definieren. Lambdas sind für einfache Operationen kompakt, sollten aber bei komplexer Logik vermieden werden, wenn eine benannte Funktion mit Kommentaren leichter zu verstehen und zu testen ist. Verwenden Sie Lambdas sparsam – sie lassen sich nicht einfach über ihren Namen in Unit-Tests prüfen oder profilieren.

# Clip revenue between 0 and 200, then round to nearest 10
df['revenue_clean'] = df['revenue_after_tax'].apply(lambda x: round(min(max(x, 0), 200) / 10) * 10)
print(df[['revenue_after_tax', 'revenue_clean']])

Zusätzliche Argumente an apply() übergeben

Übergeben Sie zusätzliche Argumente mit dem args-Tupel oder als Schlüsselwortargumente in apply(func, args=(val,), axis=1) an Ihre Funktion. Dadurch vermeiden Sie globale Variablen innerhalb der Funktion und können die Funktion mit unterschiedlichen Parameterwerten wiederverwenden. In Python 3.8 und höher können Sie auch functools.partial verwenden, um eine teilweise angewendete Version der Funktion zu erstellen.

def discount_price(row, discount_pct, threshold):
    if row['quantity'] >= threshold:
        return row['price'] * (1 - discount_pct)
    return row['price']

df['discounted_price'] = df.apply(
    discount_price, axis=1,
    args=(0.1, 3)  # 10% discount for quantity >= 3
)
print(df[['price', 'quantity', 'discounted_price']])

apply() zur Typkonvertierung

Wenn eine Spalte gemischte Typen enthält – einige Ganzzahlen, einige Gleitkommazahlen und einige Zeichenfolgen –, löst astype() einen Fehler aus. Verwenden Sie apply(pd.to_numeric, errors='coerce'), um die Konvertierung zeilenweise zu versuchen und für nicht konvertierbare Werte NaN zurückzugeben. Dies ist ein sicheres Muster für Spalten, die numerisch sein sollten, aber gelegentlich nichtnumerische Einträge aufgrund von Eingabefehlern enthalten.

messy = pd.Series(['10', '20.5', 'N/A', '100', '--'])
clean = messy.apply(pd.to_numeric, errors='coerce')
print(clean)

Leistung: apply() im Vergleich zu np.vectorize

Wenn eine auf Skalarwerte angewendete Funktion elementweise ausgeführt werden muss, ist np.vectorize(func)(array) typischerweise schneller als Series.apply(func), da NumPys vectorize über C dispatcht und dadurch den Overhead von Python-Funktionsaufrufen vermeidet. np.vectorize ist jedoch weiterhin langsamer als echtes Broadcasting und daher nur dann sinnvoll, wenn sich die Logik nicht durch einen Broadcasting-Ausdruck abbilden lässt.

def classify_size(price):
    if price < 15:
        return 'small'
    elif price < 50:
        return 'medium'
    return 'large'

# np.vectorize approach
classify_v = np.vectorize(classify_size)
df['size_class'] = classify_v(df['price'].values)
print(df[['price', 'size_class']])

Wann apply() die richtige Wahl ist

Apply ist das richtige Werkzeug, wenn: (1) die Logik gleichzeitig Verzweigungen anhand mehrerer Spaltenwerte erfordert; (2) die Funktion pro Zeile eine externe API oder Datenbank aufruft, was unvermeidlich sequenziell erfolgt; (3) die Funktion eine komplexe Zeichenfolge wie ein in einer Zelle gespeichertes JSON-Objekt analysiert; oder (4) die Funktion ein Objekt variabler Länge wie eine Liste zurückgibt. In allen anderen Fällen sollten Sie aus Gründen der Geschwindigkeit und Lesbarkeit vektorisierte Operationen bevorzugen.

import json

# Parse a JSON metadata column row by row
df['metadata'] = ['{"color": "red"}', '{"color": "blue"}', '{}', '{"color": "green"}']
df['color'] = df['metadata'].apply(lambda s: json.loads(s).get('color', 'unknown'))
print(df[['metadata', 'color']])

Kurzüberprüfung

Testen Sie Ihr Verständnis der Konzepte zur Datenanalyse aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie Folgendes gelernt: mit apply(axis=0) spaltenbezogene benutzerdefinierte Statistiken zu berechnen, mit apply(axis=1) zeilenbezogene Berechnungen mit mehreren Spalten als Eingabe durchzuführen und zu erkennen, wann aus Performance-Gründen vektorisierte Alternativen vorzuziehen sind. Als Nächstes sehen wir uns apply() mit GroupBy für komplexe Aggregationen auf Gruppenebene an.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „apply() auf Spalten und Zeilen“ kostenlos?

Ja — der vollständige Text von „apply() auf Spalten und Zeilen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „apply() auf Spalten und Zeilen“?

Verwenden Sie DataFrame.apply() mit axis=0 und axis=1, um eine benutzerdefinierte Funktion auf jede Spalte oder jede Zeile anzuwenden. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „apply() auf Spalten und Zeilen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. apply() auf Spalten und Zeilen
  2. apply() mit GroupBy
  3. map() und applymap() für elementweise Operationen
  4. Method Chaining mit pipe()
← Zurück zu Pandas & NumPy Academy