Mestring af Pandas: En dybdegående gennemgang af brugerdefinerede funktioner med apply(), map() og applymap()

I en verden af datavidenskab og analyse er Pythons Pandas-bibliotek et uundværligt værktøj. Det leverer kraftfulde, fleksible og effektive datastrukturer, der er designet til at gøre arbejdet med strukturerede data både nemt og intuitivt. Selvom Pandas leveres med et omfattende sæt indbyggede funktioner til aggregering, filtrering og transformation, kommer der et tidspunkt i enhver dataprofessionels rejse, hvor disse ikke er nok. Du er nødt til at anvende din egen brugerdefinerede logik, en unik forretningsregel eller en kompleks transformation, der ikke er umiddelbart tilgængelig.

Det er her, evnen til at anvende brugerdefinerede funktioner bliver en superkraft. Pandas tilbyder dog flere måder at opnå dette på, primært gennem metoderne apply(), map() og applymap(). For nybegynderen kan disse funktioner virke forvirrende ens. Hvilken skal du bruge? Hvornår? Og hvad er ydeevnemæssige konsekvenser af dit valg?

Denne omfattende guide vil afmystificere disse kraftfulde metoder. Vi vil udforske hver enkelt i detaljer, forstå deres specifikke anvendelsestilfælde og, vigtigst af alt, lære at vælge det rigtige værktøj til jobbet for at skrive ren, effektiv og læsbar Pandas-kode. Vi vil dække:

• map()-metoden: Ideel til elementvis transformation på en enkelt Series.
• apply()-metoden: Den alsidige arbejdshest til rækkevise eller kolonnevise operationer på en DataFrame.
• applymap()-metoden: Specialisten til elementvise operationer på tværs af en hel DataFrame.
• Ydeevneovervejelser: Den kritiske forskel mellem disse metoder og ægte vektorisering.
• Bedste praksis: En beslutningsramme, der hjælper dig med at vælge den mest effektive metode hver gang.

Scenensættelse: Vores eksempeldatasæt

For at gøre vores eksempler praktiske og klare, lad os arbejde med et konsistent, globalt relevant datasæt. Vi opretter en eksempel-DataFrame, der repræsenterer onlinesalgsdata fra en fiktiv international e-handelsvirksomhed.

            import pandas as pd
import numpy as np

data = {
    'OrderID': [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
    'Product': ['Laptop', 'Mouse', 'Keyboard', 'Monitor', 'Webcam', 'Headphones', 'Docking Station', 'Mouse'],
    'Category': ['Electronics', 'Accessories', 'Accessories', 'Electronics', 'Accessories', 'Audio', 'Electronics', 'Accessories'],
    'Price_USD': [1200, 25, 75, 300, 50, 150, 250, 30],
    'Quantity': [1, 2, 1, 2, 1, 1, 1, 3],
    'Country': ['USA', 'Canada', 'USA', 'Germany', 'Japan', 'Canada', 'Germany', np.nan]
}

df = pd.DataFrame(data)

print(df)

            

              
                Copy
              
            
          

Denne DataFrame giver os en fin blanding af datatyper (numerisk, streng og endda en manglende værdi) til at demonstrere de fulde muligheder i vores målfunktioner.

map()-metoden: Elementvis transformation for en Series

Hvad er map()?

map()-metoden er dit specialiserede værktøj til at ændre værdier inden for en enkelt kolonne (en Pandas Series). Den fungerer på element-for-element basis. Tænk på det som at sige: "For hvert element i denne kolonne, slå det op i en ordbog eller send det gennem denne funktion og erstat det med resultatet."

Den bruges primært til to opgaver:

1. Erstatning af værdier baseret på en ordbog (en mapping).
2. Anvendelse af en simpel funktion på hvert element.

Anvendelsestilfælde 1: Mapping af værdier med en ordbog

Dette er den mest almindelige og effektive brug af map(). Forestil dig, at vi vil oprette en bredere 'Department'-kolonne baseret på vores 'Category'-kolonne. Vi kan definere en mapping i en Python-ordbog og bruge map() til at anvende den.

            category_to_department = {
    'Electronics': 'Technology',
    'Accessories': 'Peripherals',
    'Audio': 'Technology'
}

df['Department'] = df['Category'].map(category_to_department)

print(df[['Category', 'Department']])

            

              
                Copy
              
            
          

Output:

                  Category   Department
0  Electronics   Technology
1  Accessories  Peripherals
2  Accessories  Peripherals
3  Electronics   Technology
4  Accessories  Peripherals
5        Audio   Technology
6  Electronics   Technology
7  Accessories  Peripherals

            

              
                Copy
              
            
          

Læg mærke til, hvor elegant dette fungerer. Hver værdi i 'Category'-serien slås op i `category_to_department`-ordbogen, og den tilsvarende værdi bruges til at udfylde den nye 'Department'-kolonne. Hvis en nøgle ikke findes i ordbogen, vil map() producere en NaN-værdi (Not a Number), hvilket ofte er den ønskede adfærd for ikke-mappede kategorier.

Anvendelsestilfælde 2: Anvendelse af en funktion med map()

Du kan også sende en funktion (inklusive en lambda-funktion) til map(). Funktionen vil blive udført for hvert element i serien. Lad os oprette en ny kolonne, der giver os en beskrivende etiket for prisen.

            def price_label(price):
    if price > 200:
        return 'High-Value'
    elif price > 50:
        return 'Mid-Value'
    else:
        return 'Low-Value'

df['Price_Label'] = df['Price_USD'].map(price_label)

# Brug af en lambda-funktion til en simplere opgave:
# df['Product_Length'] = df['Product'].map(lambda x: len(x))

print(df[['Product', 'Price_USD', 'Price_Label']])

            

              
                Copy
              
            
          

Output:

                       Product  Price_USD  Price_Label
0           Laptop       1200   High-Value
1            Mouse         25    Low-Value
2         Keyboard         75    Mid-Value
3          Monitor        300   High-Value
4           Webcam         50    Low-Value
5       Headphones        150    Mid-Value
6  Docking Station        250   High-Value
7            Mouse         30    Low-Value

            

              
                Copy
              
            
          

Hvornår skal du bruge map(): En hurtig opsummering

• Du arbejder på en enkelt kolonne (en Series).
• Du skal erstatte værdier baseret på en ordbog eller en anden Series. Dette er dens primære styrke.
• Du skal anvende en simpel elementvis funktion på en enkelt kolonne.

apply()-metoden: Den alsidige arbejdshest

Hvad er apply()?

Hvis map() er en specialist, er apply() den generelle arbejdshest. Den er mere fleksibel, fordi den kan fungere på både Series og DataFrames. Nøglen til at forstå apply() er axis-parameteren, som dirigerer dens funktion:

• På en Series: Den fungerer elementvis, ligesom map().
• På en DataFrame med axis=0 (standard): Den anvender en funktion på hver kolonne. Funktionen modtager hver kolonne som en Series.
• På en DataFrame med axis=1: Den anvender en funktion på hver række. Funktionen modtager hver række som en Series.

apply() på en Series

Når den bruges på en Series, opfører apply() sig meget ligesom map(). Den anvender en funktion på hvert element. For eksempel kunne vi replikere vores prisetikette-eksempel.

            df['Price_Label_apply'] = df['Price_USD'].apply(price_label)
print(df['Price_Label_apply'].equals(df['Price_Label'])) # Output: True

            

              
                Copy
              
            
          

Selvom de virker udskiftelige her, er map() ofte lidt hurtigere til simple ordbogserstatninger og elementvise operationer på en Series, fordi den har en mere optimeret sti til disse specifikke opgaver.

apply() på en DataFrame (kolonnevis, axis=0)

Dette er standardtilstanden for en DataFrame. Den funktion, du leverer, kaldes en gang for hver kolonne. Dette er nyttigt til kolonnevise aggregeringer eller transformationer.

Lad os finde forskellen mellem maksimum- og minimumværdien (intervallet) for hver af vores numeriske kolonner.

            numeric_cols = df[['Price_USD', 'Quantity']]

def get_range(column_series):
    return column_series.max() - column_series.min()

column_ranges = numeric_cols.apply(get_range, axis=0)

print(column_ranges)

            

              
                Copy
              
            
          

Output:

            Price_USD    1175.0
Quantity        2.0
dtype: float64

            

              
                Copy
              
            
          

Her modtog funktionen get_range først 'Price_USD'-serien, beregnede dens interval, modtog derefter 'Quantity'-serien og gjorde det samme og returnerede en ny serie med resultaterne.

apply() på en DataFrame (rækkevis, axis=1)

Dette er uden tvivl det mest kraftfulde og almindelige anvendelsestilfælde for apply(). Når du skal beregne en ny værdi baseret på flere kolonner i samme række, er apply() med axis=1 din go-to-løsning.

Den funktion, du sender, vil modtage hver række som en Series, hvor indekset er kolonnenavnene. Lad os beregne de samlede omkostninger for hver ordre.

            def calculate_total_cost(row):
    # 'row' er en Series, der repræsenterer en enkelt række
    price = row['Price_USD']
    quantity = row['Quantity']
    return price * quantity

df['Total_Cost'] = df.apply(calculate_total_cost, axis=1)

print(df[['Product', 'Price_USD', 'Quantity', 'Total_Cost']])

            

              
                Copy
              
            
          

Output:

                       Product  Price_USD  Quantity  Total_Cost
0           Laptop       1200         1        1200
1            Mouse         25         2          50
2         Keyboard         75         1          75
3          Monitor        300         2         600
4           Webcam         50         1          50
5       Headphones        150         1         150
6  Docking Station        250         1         250
7            Mouse         30         3          90

            

              
                Copy
              
            
          

Dette er noget, som map() simpelthen ikke kan gøre, da den er begrænset til en enkelt kolonne. Lad os se et mere komplekst eksempel. Vi vil kategorisere hver ordres forsendelsesprioritet baseret på dens kategori og land.

            def assign_shipping_priority(row):
    if row['Category'] == 'Electronics' and row['Country'] == 'USA':
        return 'High Priority'
    elif row['Total_Cost'] > 500:
        return 'High Priority'
    elif row['Country'] == 'Japan':
        return 'Medium Priority'
    else:
        return 'Standard'

df['Shipping_Priority'] = df.apply(assign_shipping_priority, axis=1)

print(df[['Category', 'Country', 'Total_Cost', 'Shipping_Priority']])

            

              
                Copy
              
            
          

Hvornår skal du bruge apply(): En hurtig opsummering

• Når din logik afhænger af flere kolonner i en række (brug axis=1). Dette er dens killer feature.
• Når du skal anvende en aggregeringsfunktion ned ad kolonner eller på tværs af rækker.
• Som et generelt værktøj til funktionsanvendelse, når map() ikke passer.

En særlig omtale: applymap()-metoden

Hvad er applymap()?

applymap()-metoden er en anden specialist, men dens domæne er hele DataFrame. Den anvender en funktion på hvert eneste element i en DataFrame. Den fungerer ikke på en Series—det er en metode, der kun gælder for DataFrames.

Tænk på det som at køre en map() på hver kolonne samtidigt. Det er nyttigt til brede, omfattende transformationer, som formatering eller typekonvertering, på tværs af alle celler.

Et praktisk eksempel

Lad os sige, at vi har en under-DataFrame med kun vores numeriske kolonner, og vi vil formatere dem alle som valutastreng for en rapport.

            numeric_df = df[['Price_USD', 'Quantity', 'Total_Cost']]

# Brug af en lambda-funktion til at formatere hvert tal
formatted_df = numeric_df.applymap(lambda x: f'${x:,.2f}')

print(formatted_df)

            

              
                Copy
              
            
          

Output:

               Price_USD Quantity Total_Cost
0  $1,200.00    $1.00  $1,200.00
1      $25.00    $2.00     $50.00
2      $75.00    $1.00     $75.00
3     $300.00    $2.00    $600.00
4      $50.00    $1.00     $50.00
5     $150.00    $1.00    $150.00
6     $250.00    $1.00    $250.00
7      $30.00    $3.00     $90.00

            

              
                Copy
              
            
          

En anden almindelig brug er at rydde op i en DataFrame med strengdata ved for eksempel at konvertere alt til små bogstaver.

            string_df = df[['Product', 'Category', 'Country']].copy() # Opret en kopi for at undgå SettingWithCopyWarning

# Sørg for, at alle værdier er strenge for at forhindre fejl
string_df = string_df.astype(str)

lower_df = string_df.applymap(str.lower)

print(lower_df)

            

              
                Copy
              
            
          

Hvornår skal du bruge applymap(): En hurtig opsummering

• Når du skal anvende en enkelt, simpel funktion på hvert element i en DataFrame.
• Til opgaver som datatypekonvertering, strengformatering eller simple matematiske transformationer på tværs af hele DataFrame.
• Husk dens udfasning til fordel for DataFrame.map() i nyere Pandas-versioner.

Ydeevne dybdegående: Vektorisering vs. Iteration

Den "skjulte" løkke

Dette er det mest kritiske koncept at forstå for at skrive højtydende Pandas-kode. Selvom apply(), map() og applymap() er praktiske, er de dybest set bare smarte indpakninger omkring en Python-løkke. Når du bruger df.apply(..., axis=1), itererer Pandas gennem din DataFrame række for række og sender hver enkelt til din funktion. Denne proces har betydelige overheadomkostninger og er meget langsommere end operationer, der er optimeret i C eller Cython.

Kraften i vektorisering

Vektorisering er praksis med at udføre operationer på hele arrays (eller Series) på én gang i stedet for på individuelle elementer. Pandas og dets underliggende bibliotek, NumPy, er specifikt designet til at være utroligt hurtige til vektoriserede operationer.

Lad os vende tilbage til vores 'Total_Cost'-beregning. Vi brugte apply(), men er der en vektoriseret måde?

            # Metode 1: Brug af apply() (Iteration)
df['Total_Cost'] = df.apply(lambda row: row['Price_USD'] * row['Quantity'], axis=1)

# Metode 2: Vektoriseret Operation
df['Total_Cost_Vect'] = df['Price_USD'] * df['Quantity']

# Kontroller, om resultaterne er de samme
print(df['Total_Cost'].equals(df['Total_Cost_Vect'])) # Output: True

            

              
                Copy
              
            
          

Den anden metode er vektoriseret. Den tager hele 'Price_USD'-serien og multiplicerer den med hele 'Quantity'-serien i en enkelt, stærkt optimeret operation. Hvis du skulle time disse to metoder på en stor DataFrame (millioner af rækker), ville den vektoriserede tilgang ikke bare være hurtigere—den ville være størrelsesordener hurtigere. Vi taler sekunder versus minutter eller minutter versus timer.

Hvornår er apply() uundgåelig?

Hvis vektorisering er så meget hurtigere, hvorfor findes disse andre metoder så? Fordi nogle gange er din logik for kompleks til at blive vektoriseret. apply() er det nødvendige og korrekte værktøj, når:

• Kompleks betinget logik: Din logik involverer indviklede if/elif/else-udsagn, der afhænger af flere kolonner, ligesom vores assign_shipping_priority-eksempel. Selvom noget af dette kan opnås med np.select(), kan det blive ulæseligt.
• Eksterne biblioteksfunktioner: Du skal anvende en funktion fra et eksternt bibliotek på dine data. For eksempel at anvende en funktion fra et geospatialt bibliotek til at beregne afstand baseret på bredde- og længdegradskolonner eller en funktion fra et naturligt sprogbehandlingsbibliotek (som NLTK) til at udføre sentimentanalyse på en tekstkolonne.
• Iterative processer: Beregningen for en given række afhænger af en værdi, der er beregnet i en tidligere række (selvom dette er sjældent og ofte et tegn på, at der er brug for en anden datastruktur).

Bedste praksis: Vektoriser først, apply() som nummer to

Dette fører til den gyldne regel for Pandas-ydeevne:

Se altid efter en vektoriseret løsning først. Brug apply() som dit kraftfulde, fleksible fallback, når en vektoriseret løsning ikke er praktisk eller mulig.

Oversigt og vigtigste takeaways: Valg af det rigtige værktøj

Lad os konsolidere vores viden i en klar beslutningsramme. Når du står over for en brugerdefineret transformationsopgave, skal du stille dig selv disse spørgsmål:

Sammenligningstabel

Et beslutningsflowdiagram

1. Kan min operation udtrykkes ved hjælp af grundlæggende aritmetik (+, -, *, /) eller logiske operatorer (&, |, ~) på hele kolonner?
   → Ja? Brug en vektoriseret tilgang. Dette er det hurtigste. (f.eks. `df['col1'] * df['col2']`)
2. Arbejder jeg kun på en enkelt kolonne, og er mit hovedmål at erstatte værdier baseret på en ordbog?
   → Ja? Brug Series.map(). Den er optimeret til dette.
3. Skal jeg anvende en funktion på hvert eneste element i hele min DataFrame?
   → Ja? Brug DataFrame.applymap() (eller DataFrame.map() i nyere Pandas).
4. Er min logik kompleks og kræver værdier fra flere kolonner i hver række for at beregne et enkelt resultat?
   → Ja? Brug DataFrame.apply(..., axis=1). Dette er dit værktøj til kompleks, rækkevis logik.

Konklusion

At navigere i mulighederne for at anvende brugerdefinerede funktioner i Pandas er en overgangsrite for enhver datapraktiker. Selvom de ved første øjekast kan virke udskiftelige, er map(), apply() og applymap() distinkte værktøjer, hver med sine egne styrker og ideelle anvendelsestilfælde. Ved at forstå deres forskelle kan du skrive kode, der ikke kun er korrekt, men også mere læsbar, vedligeholdelig og betydeligt mere performant.

Husk hierarkiet: foretræk vektorisering for dens rå hastighed, brug map() for dens effektive Series-erstatning, vælg applymap() til DataFrame-dækkende transformationer, og udnyt kraften og fleksibiliteten i apply() til kompleks rækkevis eller kolonnevis logik, der ikke kan vektoriseres. Bevæbnet med denne viden er du nu bedre rustet til at tackle enhver datamanipulationsudfordring, der kommer din vej, og transformere rådata til stærk indsigt med dygtighed og effektivitet.