Mestre Pandas: En dypdykk i tilpassede funksjoner med apply(), map() og applymap()

I en verden av datavitenskap og analyse er Pythons Pandas-bibliotek et uunnværlig verktøy. Det tilbyr kraftige, fleksible og effektive datastrukturer designet for å gjøre arbeidet med strukturerte data både enkelt og intuitivt. Mens Pandas kommer med et rikt sett med innebygde funksjoner for aggregering, filtrering og transformasjon, kommer det et tidspunkt i enhver dataeksperts reise når disse ikke er nok. Du må bruke din egen tilpassede logikk, en unik forretningsregel eller en kompleks transformasjon som ikke er lett tilgjengelig.

Det er her evnen til å bruke tilpassede funksjoner blir en superkraft. Pandas tilbyr imidlertid flere måter å oppnå dette på, primært gjennom metodene apply(), map() og applymap(). For nykommeren kan disse funksjonene virke forvirrende like. Hvilken bør du bruke? Når? Og hva er ytelsesimplikasjonene av valget ditt?

Denne omfattende guiden vil avmystifisere disse kraftige metodene. Vi vil utforske hver enkelt i detalj, forstå deres spesifikke brukstilfeller, og viktigst av alt, lære hvordan vi velger det riktige verktøyet for jobben for å skrive ren, effektiv og lesbar Pandas-kode. Vi vil dekke:

• Metoden map(): Ideell for elementvis transformasjon på en enkelt serie.
• Metoden apply(): Den allsidige arbeidshesten for radvise eller kolonnevise operasjoner på en DataFrame.
• Metoden applymap(): Spesialisten for elementvise operasjoner over en hel DataFrame.
• Ytelseshensyn: Den kritiske forskjellen mellom disse metodene og ekte vektorisering.
• Beste praksis: Et beslutningstakingsrammeverk for å hjelpe deg med å velge den mest effektive metoden hver gang.

Sette scenen: Vårt eksempeldatasett

For å gjøre eksemplene våre praktiske og tydelige, la oss jobbe med et konsistent, globalt relevant datasett. Vi lager en eksempel DataFrame som representerer online salgsdata fra et fiktivt internasjonalt e-handelsselskap.

            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 gir oss en fin blanding av datatyper (numerisk, streng og til og med en manglende verdi) for å demonstrere de fulle mulighetene til målfunksjonene våre.

Metoden `map()`: Elementvis transformasjon for en serie

Hva er `map()`?

Metoden map() er ditt spesialiserte verktøy for å endre verdier i en enkelt kolonne (en Pandas Series). Den opererer på element-for-element-basis. Tenk på det som å si: "For hvert element i denne kolonnen, slå det opp i en ordbok eller send det gjennom denne funksjonen og erstatt det med resultatet."

Den brukes primært til to oppgaver:

1. Erstatte verdier basert på en ordbok (en kartlegging).
2. Bruke en enkel funksjon på hvert element.

Brukstilfelle 1: Kartlegge verdier med en ordbok

Dette er den vanligste og mest effektive bruken av map(). Tenk deg at vi vil lage en bredere 'Department'-kolonne basert på 'Category'-kolonnen vår. Vi kan definere en kartlegging i en Python-ordbok og bruke map() til å bruke 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
              
            
          

Legg merke til hvor elegant dette fungerer. Hver verdi i 'Category'-serien slås opp i `category_to_department`-ordboken, og den tilsvarende verdien brukes til å fylle ut den nye 'Department'-kolonnen. Hvis en nøkkel ikke blir funnet i ordboken, vil map() produsere en NaN-verdi (Not a Number), som ofte er den ønskede oppførselen for ikke-kartlagte kategorier.

Brukstilfelle 2: Bruke en funksjon med `map()`

Du kan også sende en funksjon (inkludert en lambda-funksjon) til map(). Funksjonen vil bli utført for hvert element i serien. La oss lage en ny kolonne som gir oss en beskrivende etikett 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)

# Bruke en lambda-funksjon for en enklere oppgave:
# 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
              
            
          

Når du skal bruke `map()`: Et raskt sammendrag

• Du jobber med en enkelt kolonne (en serie).
• Du må erstatte verdier basert på en ordbok eller en annen serie. Dette er dens primære styrke.
• Du må bruke en enkel elementvis funksjon på en enkelt kolonne.

Metoden `apply()`: Den allsidige arbeidshesten

Hva er `apply()`?

Hvis map() er en spesialist, er apply() den generelle kraftpakken. Den er mer fleksibel fordi den kan operere på både serier og dataframes. Nøkkelen til å forstå apply() er axis-parameteren, som styrer operasjonen:

• På en serie: Den fungerer elementvis, omtrent som map().
• På en dataframe med axis=0 (standard): Den bruker en funksjon på hver kolonne. Funksjonen mottar hver kolonne som en serie.
• På en dataframe med axis=1: Den bruker en funksjon på hver rad. Funksjonen mottar hver rad som en serie.

`apply()` på en serie

Når den brukes på en serie, oppfører apply() seg veldig likt map(). Den bruker en funksjon på hvert element. For eksempel kan vi replikere vårt priseksempel.

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

            

              
                Copy
              
            
          

Selv om de virker utskiftbare her, er map() ofte litt raskere for enkle ordboksubstitusjoner og elementvise operasjoner på en serie, fordi den har en mer optimalisert bane for de spesifikke oppgavene.

`apply()` på en dataframe (kolonnevis, `axis=0`)

Dette er standardmodusen for en dataframe. Funksjonen du oppgir, kalles én gang for hver kolonne. Dette er nyttig for kolonnevise aggregeringer eller transformasjoner.

La oss finne forskjellen mellom maksimums- og minimumsverdien (området) for hver av våre 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 mottok funksjonen get_range først 'Price_USD'-serien, beregnet rekkevidden, mottok deretter 'Quantity'-serien og gjorde det samme, og returnerte en ny serie med resultatene.

`apply()` på en dataframe (radvis, `axis=1`)

Dette er uten tvil det kraftigste og vanligste bruksområdet for apply(). Når du trenger å beregne en ny verdi basert på flere kolonner i samme rad, er apply() med axis=1 din foretrukne løsning.

Funksjonen du sender vil motta hver rad som en serie, der indeksen er kolonnenavnene. La oss beregne den totale kostnaden for hver ordre.

            def calculate_total_cost(row):
    # 'row' is a Series representing a single row
    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 noe map() rett og slett ikke kan gjøre, siden den er begrenset til en enkelt kolonne. La oss se et mer komplekst eksempel. Vi ønsker å kategorisere hver ordres fraktprioritet basert på 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
              
            
          

Når du skal bruke `apply()`: Et raskt sammendrag

• Når logikken din er avhengig av flere kolonner i en rad (bruk axis=1). Dette er dens viktigste funksjon.
• Når du trenger å bruke en aggregeringsfunksjon ned kolonner eller over rader.
• Som et generell funksjonsapplikasjonsverktøy når map() ikke passer.

En spesiell omtale: Metoden `applymap()`

Hva er `applymap()`?

Metoden applymap() er en annen spesialist, men dens domene er hele dataframen. Den bruker en funksjon på hvert eneste element i en dataframe. Den fungerer ikke på en serie – det er en metode kun for dataframes.

Tenk på det som å kjøre en map() på hver kolonne samtidig. Det er nyttig for brede, feiende transformasjoner, som formatering eller typekonvertering, over alle celler.

Et praktisk eksempel

La oss si at vi har en under-dataframe med bare våre numeriske kolonner, og vi vil formatere dem alle som valutastrenger for en rapport.

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

# Bruke en lambda-funksjon til å formatere hvert tall
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 annen vanlig bruk er å rydde opp i en dataframe med strengdata ved for eksempel å konvertere alt til små bokstaver.

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

# Sørg for at alle verdier er strenger for å forhindre feil
string_df = string_df.astype(str)

lower_df = string_df.applymap(str.lower)

print(lower_df)

            

              
                Copy
              
            
          

Når du skal bruke `applymap()`: Et raskt sammendrag

• Når du trenger å bruke en enkelt, enkel funksjon på hvert element i en dataframe.
• For oppgaver som datatypekonvertering, strengformatering eller enkle matematiske transformasjoner over hele dataframen.
• Husk at den er avskrevet til fordel for DataFrame.map() i nyere Pandas-versjoner.

Ytelsesdykk: Vektorisering vs. Iterasjon

Den "skjulte" løkken

Dette er det viktigste konseptet å forstå for å skrive Pandas-kode med høy ytelse. Mens apply(), map() og applymap() er praktiske, er de egentlig bare fancy omslag rundt en Python-løkke. Når du bruker df.apply(..., axis=1), itererer Pandas gjennom dataframen din rad for rad, og sender hver enkelt til funksjonen din. Denne prosessen har betydelig overhead og er mye tregere enn operasjoner som er optimalisert i C eller Cython.

Kraften i vektorisering

Vektorisering er praksisen med å utføre operasjoner på hele arrays (eller serier) samtidig, i stedet for på individuelle elementer. Pandas og dets underliggende bibliotek, NumPy, er spesielt designet for å være utrolig raske på vektoriserte operasjoner.

La oss gå tilbake til beregningen av 'Total_Cost'. Vi brukte apply(), men finnes det en vektorisert måte?

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

# Metode 2: Vektorisert operasjon
df['Total_Cost_Vect'] = df['Price_USD'] * df['Quantity']

# Sjekk om resultatene er de samme
print(df['Total_Cost'].equals(df['Total_Cost_Vect'])) # Output: True

            

              
                Copy
              
            
          

Den andre metoden er vektorisert. Den tar hele 'Price_USD'-serien og multipliserer den med hele 'Quantity'-serien i en enkelt, høyt optimalisert operasjon. Hvis du skulle tidsberegne disse to metodene på en stor dataframe (millioner av rader), ville den vektoriserte tilnærmingen ikke bare være raskere – den ville være størrelsesordener raskere. Vi snakker sekunder mot minutter, eller minutter mot timer.

Når er `apply()` uunngåelig?

Hvis vektorisering er så mye raskere, hvorfor finnes disse andre metodene? Fordi noen ganger er logikken din for kompleks til å bli vektorisert. apply() er det nødvendige og riktige verktøyet når:

• Kompleks betinget logikk: Logikken din involverer intrikate if/elif/else-setninger som er avhengig av flere kolonner, som vårt `assign_shipping_priority`-eksempel. Selv om noe av dette kan oppnås med np.select(), kan det bli uleselig.
• Eksterne biblioteksfunksjoner: Du må bruke en funksjon fra et eksternt bibliotek på dataene dine. For eksempel bruke en funksjon fra et geospatialt bibliotek til å beregne avstand basert på bredde- og lengdegradskolonner, eller en funksjon fra et naturlig språkbehandlingsbibliotek (som NLTK) for å utføre sentimentanalyse på en tekstkolonne.
• Iterative prosesser: Beregningen for en gitt rad er avhengig av en verdi beregnet i en forrige rad (selv om dette er sjeldent og ofte et tegn på at en annen datastruktur er nødvendig).

Beste praksis: Vektoriser først, `apply()` sekund

Dette fører til gullregelen for Pandas-ytelse:

Se alltid etter en vektorisert løsning først. Bruk apply() som din kraftige, fleksible fallback når en vektorisert løsning ikke er praktisk eller mulig.

Sammendrag og viktige punkter: Velge riktig verktøy

La oss konsolidere kunnskapen vår til et tydelig beslutningstakingsrammeverk. Når du står overfor en tilpasset transformasjonsoppgave, still deg selv disse spørsmålene:

Sammenligningstabell

Et beslutningsflytskjema

1. Kan operasjonen min uttrykkes ved hjelp av grunnleggende aritmetikk (+, -, *, /) eller logiske operatorer (&, |, ~) på hele kolonner?
   → Ja? Bruk en vektorisert tilnærming. Dette er det raskeste. (f.eks. `df['col1'] * df['col2']`)
2. Jobber jeg bare med en enkelt kolonne, og er hovedmålet mitt å erstatte verdier basert på en ordbok?
   → Ja? Bruk Series.map(). Den er optimalisert for dette.
3. Trenger jeg å bruke en funksjon på hvert eneste element i hele dataframen min?
   → Ja? Bruk DataFrame.applymap() (eller DataFrame.map() i nyere Pandas).
4. Er logikken min kompleks og krever verdier fra flere kolonner i hver rad for å beregne et enkelt resultat?
   → Ja? Bruk DataFrame.apply(..., axis=1). Dette er verktøyet ditt for kompleks, radvis logikk.

Konklusjon

Å navigere i alternativene for å bruke tilpassede funksjoner i Pandas er en overgangsrite for enhver datapraktiker. Selv om de kan virke utskiftbare ved første øyekast, er map(), apply() og applymap() distinkte verktøy, hver med sine egne styrker og ideelle bruksområder. Ved å forstå forskjellene deres, kan du skrive kode som ikke bare er korrekt, men også mer lesbar, vedlikeholdbar og betydelig mer ytelsesdyktig.

Husk hierarkiet: foretrekk vektorisering for sin rå hastighet, bruk map() for sin effektive serieerstatning, velg applymap() for dataframe-omfattende transformasjoner, og utnytt kraften og fleksibiliteten til apply() for kompleks radvis eller kolonnevis logikk som ikke kan vektoriseres. Bevæpnet med denne kunnskapen er du nå bedre rustet til å takle enhver datamanipulasjonsutfordring som kommer din vei, og transformere rådata til kraftig innsikt med dyktighet og effektivitet.