A Pandas mesteri használata: Mélyreható betekintés az egyedi függvényekbe az apply(), map() és applymap() metódusokkal

Az adat tudomány és -elemzés világában a Python Pandas könyvtára nélkülözhetetlen eszköz. Erőteljes, rugalmas és hatékony adatstruktúrákat biztosít, amelyek célja, hogy a strukturált adatokkal való munka egyszerű és intuitív legyen. Bár a Pandas számos beépített funkciót kínál aggregálásra, szűrésre és transzformációra, minden adat szakember életében eljön az a pont, amikor ezek már nem elegendőek. Szüksége van saját egyedi logika, egyedi üzleti szabály vagy egy komplex transzformáció alkalmazására, ami nem áll azonnal rendelkezésre.

Itt válik szuperképességgé az egyedi függvények alkalmazásának képessége. A Pandas azonban többféle módot is kínál ennek elérésére, elsősorban az apply(), map() és applymap() metódusokon keresztül. Az újoncok számára ezek a függvények zavaróan hasonlóaknak tűnhetnek. Melyiket érdemes használni? Mikor? És milyen teljesítménybeli következményekkel jár a választása?

Ez az átfogó útmutató tisztázza ezeket az erőteljes metódusokat. Részletesen megvizsgáljuk mindegyiket, megértjük specifikus felhasználási eseteiket, és ami a legfontosabb, megtanuljuk, hogyan válasszuk ki a megfelelő eszközt a tiszta, hatékony és olvasható Pandas kód írásához. Tárgyalni fogjuk:

• A map() metódus: Ideális elemről elemre történő transzformációhoz egyetlen Series-en.
• Az apply() metódus: A sokoldalú igásló soronkénti vagy oszloponkénti műveletekhez egy DataFrame-en.
• Az applymap() metódus: A specialista az elemről elemre történő műveletekhez egy teljes DataFrame-en.
• Teljesítménybeli megfontolások: A kritikus különbség ezek és a valódi vektorizálás között.
• Bevált gyakorlatok: Egy döntéshozatali keretrendszer, amely segít kiválasztani a leghatékonyabb metódust minden alkalommal.

A terep előkészítése: Mintadatkészletünk

Példáink gyakorlatiassá és érthetővé tétele érdekében egy egységes, globálisan releváns adatkészlettel fogunk dolgozni. Létrehozunk egy mintaként szolgáló DataFrame-et, amely egy fiktív nemzetközi e-kereskedelmi vállalat online értékesítési adatait reprezentálja.

            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
              
            
          

Ez a DataFrame kellemesen vegyes adattípusokat (numerikus, string, és még hiányzó érték is) tartalmaz, hogy bemutassuk a célfüggvényeink teljes képességeit.

A `map()` metódus: Elemről elemre történő transzformáció egy Series-hez

Mi az a `map()`?

A map() metódus az Ön specializált eszköze egyetlen oszlopon (egy Pandas Series-en) belüli értékek módosítására. Elemről elemre működik. Gondoljon rá úgy, mint ha azt mondaná: "Az oszlop minden elemére nézve keresse meg egy szótárban, vagy illessze át ezen a függvényen, és cserélje le az eredménnyel."

Elsődlegesen két feladatra használják:

1. Értékek helyettesítése szótár (egy leképezés) alapján.
2. Egyszerű függvény alkalmazása minden elemre.

Felhasználási eset 1: Értékek leképezése szótárral

Ez a map() leggyakoribb és leghatékonyabb felhasználási módja. Képzeljük el, hogy egy szélesebb 'Department' oszlopot szeretnénk létrehozni a 'Category' oszlopunk alapján. Létrehozhatunk egy leképezést egy Python szótárban, és a map() segítségével alkalmazhatjuk azt.

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

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

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

            

              
                Copy
              
            
          

Kimenet:

                  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
              
            
          

Figyelje meg, milyen elegánsan működik ez. A 'Category' Series minden értékét megkeresi a `category_to_department` szótárban, és a megfelelő értéket használja az új 'Department' oszlop feltöltésére. Ha egy kulcs nem található a szótárban, a map() egy NaN (nem szám) értéket fog eredményezni, ami gyakran a kívánt viselkedés a nem leképezett kategóriák esetében.

Felhasználási eset 2: Függvény alkalmazása a `map()` segítségével

Függvényt (beleértve a lambda függvényt is) is átadhat a map() metódusnak. A függvény a Series minden elemére végrehajtásra kerül. Hozzunk létre egy új oszlopot, amely leíró címkét ad az árnak.

            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)

# Using a lambda function for a simpler task:
# df['Product_Length'] = df['Product'].map(lambda x: len(x))

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

            

              
                Copy
              
            
          

Kimenet:

                       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
              
            
          

Mikor használjuk a `map()`-et: Gyors összefoglaló

• Egyetlen oszlopon (egy Series-en) dolgozik.
• Értékeket kell helyettesítenie egy szótár vagy egy másik Series alapján. Ez az elsődleges erőssége.
• Egy egyszerű elemről elemre történő függvényt kell alkalmaznia egyetlen oszlopra.

Az `apply()` metódus: A sokoldalú igásló

Mi az a `apply()`?

Ha a map() specialista, akkor az apply() az általános célú erőmű. Rugalmasabb, mert Series-eken és DataFrame-eken egyaránt működhet. Az apply() megértésének kulcsa az axis paraméter, amely irányítja a működését:

• Series-en: Elemről elemre működik, hasonlóan a map()-hez.
• DataFrame-en axis=0 (alapértelmezett) esetén: Függvényt alkalmaz minden oszlopra. A függvény minden oszlopot Series-ként kap meg.
• DataFrame-en axis=1 esetén: Függvényt alkalmaz minden sorra. A függvény minden sort Series-ként kap meg.

`apply()` egy Series-en

Series-en használva az apply() nagyon hasonlóan viselkedik a map()-hez. Függvényt alkalmaz minden elemre. Például megismételhetnénk az árkategória-példánkat.

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

            

              
                Copy
              
            
          

Bár itt felcserélhetőnek tűnnek, a map() gyakran kissé gyorsabb az egyszerű szótár-helyettesítések és az elemről elemre történő műveletek esetében egy Series-en, mert optimalizáltabb útvonallal rendelkezik ezekhez a specifikus feladatokhoz.

`apply()` egy DataFrame-en (Oszloponként, `axis=0`)

Ez a DataFrame alapértelmezett üzemmódja. Az Ön által megadott függvény minden oszlopra egyszer kerül meghívásra. Ez hasznos oszloponkénti aggregációk vagy transzformációk esetén.

Keressük meg a maximális és minimális érték közötti különbséget (a tartományt) mindegyik numerikus oszlopunk esetében.

            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
              
            
          

Kimenet:

            Price_USD    1175.0
Quantity        2.0
dtype: float64

            

              
                Copy
              
            
          

Itt a get_range függvény először a 'Price_USD' Series-t kapta meg, kiszámította a tartományát, majd a 'Quantity' Series-t, és ugyanezt tette, egy új Series-t visszaadva az eredményekkel.

`apply()` egy DataFrame-en (Soronként, `axis=1`)

Ez vitathatatlanul az apply() legerősebb és leggyakoribb felhasználási esete. Ha új értéket kell számítania ugyanazon sor több oszlopa alapján, akkor az apply() az axis=1 paraméterrel a legmegfelelőbb megoldás.

Az átadott függvény minden sort Series-ként kap meg, ahol az index az oszlopneveket tartalmazza. Számoljuk ki az egyes rendelések teljes költségét.

            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
              
            
          

Kimenet:

                       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
              
            
          

Ez olyasmi, amit a map() egyszerűen nem tud megtenni, mivel egyetlen oszlopra korlátozódik. Nézzünk egy komplexebb példát. Szeretnénk kategorizálni az egyes rendelések szállítási prioritását a kategória és az ország alapján.

            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
              
            
          

Mikor használjuk az `apply()`-t: Gyors összefoglaló

• Amikor a logika egy sor több oszlopától függ (használja az axis=1-et). Ez a fő erőssége.
• Amikor aggregációs függvényt kell alkalmaznia oszlopokra vagy sorokra.
• Általános célú függvényalkalmazási eszközként, ha a map() nem megfelelő.

Külön említés: Az `applymap()` metódus

Mi az a `applymap()`?

Az applymap() metódus egy másik specialista, de hatóköre a teljes DataFrame. Függvényt alkalmaz a DataFrame minden egyes elemére. Nem működik Series-en – ez egy kizárólag DataFrame-re vonatkozó metódus.

Gondoljon rá úgy, mint ha a map()-et futtatná minden oszlopon egyszerre. Hasznos széles körű, átfogó transzformációkhoz, mint például formázás vagy típuskonverzió, az összes cellán keresztül.

Gyakorlati példa

Tegyük fel, hogy van egy al-DataFrame-ünk csak a numerikus oszlopainkkal, és mindegyiket pénznemként szeretnénk formázni egy jelentéshez.

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

# Using a lambda function to format each number
formatted_df = numeric_df.applymap(lambda x: f'${x:,.2f}')

print(formatted_df)

            

              
                Copy
              
            
          

Kimenet:

               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
              
            
          

Egy másik gyakori felhasználás a string adatokkal teli DataFrame tisztítása, például minden karakter kisbetűssé alakításával.

            string_df = df[['Product', 'Category', 'Country']].copy() # Create a copy to avoid SettingWithCopyWarning

# Ensure all values are strings to prevent errors
string_df = string_df.astype(str)

lower_df = string_df.applymap(str.lower)

print(lower_df)

            

              
                Copy
              
            
          

Mikor használjuk az `applymap()`-et: Gyors összefoglaló

• Ha egyetlen, egyszerű függvényt kell alkalmaznia egy DataFrame minden elemére.
• Olyan feladatokhoz, mint az adattípus-konverzió, string formázás vagy egyszerű matematikai transzformációk az egész DataFrame-en.
• Emlékezzen a deprecation-re a DataFrame.map() javára a legújabb Pandas verziókban.

Teljesítmény mélyrepülés: Vektorizálás vs. Iteráció

A "rejtett" ciklus

Ez a legkritikusabb fogalom a nagy teljesítményű Pandas kód írásához. Bár az apply(), map() és applymap() kényelmesek, lényegében csak elegáns burkolatok egy Python ciklus körül. Amikor a df.apply(..., axis=1)-et használja, a Pandas sorról sorra iterálja a DataFrame-et, minden egyes sort átadva a függvényének. Ez a folyamat jelentős többletterheléssel jár, és sokkal lassabb, mint a C-ben vagy Cythonban optimalizált műveletek.

A vektorizálás ereje

A vektorizálás az a gyakorlat, amikor műveleteket hajtunk végre teljes tömbökön (vagy Series-eken) egyszerre, nem pedig egyedi elemeken. A Pandas és mögöttes könyvtára, a NumPy, kifejezetten arra tervezték, hogy hihetetlenül gyors legyen a vektorizált műveletekben.

Tekintsük újra a 'Total_Cost' számításunkat. Az apply()-t használtuk, de van-e vektorizált módja?

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

# Method 2: Vectorized Operation
df['Total_Cost_Vect'] = df['Price_USD'] * df['Quantity']

# Check if the results are the same
print(df['Total_Cost'].equals(df['Total_Cost_Vect'])) # Output: True

            

              
                Copy
              
            
          

A második módszer vektorizált. Az egész 'Price_USD' Series-t veszi, és megszorozza az egész 'Quantity' Series-szel egyetlen, nagymértékben optimalizált műveletben. Ha ezeket a két módszert egy nagy DataFrame-en (milliók sor) időzítené, a vektorizált megközelítés nem csak gyorsabb lenne – nagyságrendekkel gyorsabb lenne. Másodpercekről percekre, vagy percekre órákra beszélünk.

Mikor elkerülhetetlen az `apply()`?

Ha a vektorizálás sokkal gyorsabb, miért léteznek ezek a többi metódusok? Mert néha a logika túl komplex ahhoz, hogy vektorizálható legyen. Az apply() a szükséges és helyes eszköz, amikor:

• Komplex feltételes logika: A logika bonyolult `if/elif/else` utasításokat tartalmaz, amelyek több oszloptól függenek, mint az `assign_shipping_priority` példánkban. Bár ennek egy része elérhető `np.select()` segítségével, ez olvashatatlanná válhat.
• Külső könyvtári függvények: Külső könyvtárból származó függvényt kell alkalmaznia az adataira. Például egy geospaciális könyvtár függvényének alkalmazása távolság kiszámítására szélességi és hosszúsági oszlopok alapján, vagy egy természetes nyelvi feldolgozó könyvtár (például NLTK) függvényének alkalmazása hangulatelemzés elvégzésére egy szöveges oszlopon.
• Iteratív folyamatok: Egy adott sor számítása egy előző sorban kiszámított értéktől függ (bár ez ritka, és gyakran annak a jele, hogy más adatstruktúrára van szükség).

Bevált gyakorlat: Először vektorizálás, másodszor `apply()`

Ez vezet a Pandas teljesítmény aranyszabályához:

Mindig keressen először vektorizált megoldást. Használja az `apply()`-t erős, rugalmas alternatívaként, ha a vektorizált megoldás nem praktikus vagy nem lehetséges.

Összegzés és fő tanulságok: A megfelelő eszköz kiválasztása

Tömörítsük tudásunkat egy világos döntéshozatali keretrendszerbe. Amikor egy egyedi transzformációs feladattal szembesül, tegye fel magának ezeket a kérdéseket:

Összehasonlító táblázat

Döntési folyamatábra

1. Kifejezhető-e a műveletem alapvető aritmetikai (+, -, *, /) vagy logikai (&, |, ~) operátorokkal teljes oszlopokon?
   → Igen? Használjon vektorizált megközelítést. Ez a leggyorsabb. (pl.: `df['col1'] * df['col2']`)
2. Csak egy oszlopon dolgozom, és az a fő célom, hogy értékeket helyettesítsek egy szótár alapján?
   → Igen? Használja a Series.map()-et. Ez erre optimalizált.
3. Alkalmaznom kell egy függvényt a DataFrame minden egyes elemére?
   → Igen? Használja a DataFrame.applymap()-et (vagy DataFrame.map()-et újabb Pandas verziókban).
4. A logikám komplex, és egyetlen eredmény kiszámításához több oszlop értékei szükségesek az egyes sorokban?
   → Igen? Használja a DataFrame.apply(..., axis=1)-et. Ez az Ön eszköze a komplex, soronkénti logikához.

Összegzés

A Pandas egyedi függvények alkalmazására szolgáló lehetőségei közötti navigálás minden adat szakember számára egyfajta beavatás. Bár első pillantásra felcserélhetőnek tűnhetnek, a map(), apply() és applymap() különálló eszközök, mindegyiknek megvannak a saját erősségei és ideális felhasználási esetei. Különbségeik megértésével olyan kódot írhat, amely nemcsak helyes, hanem olvashatóbb, karbantarthatóbb és lényegesen nagyobb teljesítményű is.

Emlékezzen a hierarchiára: részesítse előnyben a vektorizálást a nyers sebessége miatt, használja a map()-et a hatékony Series helyettesítésre, válassza az applymap()-et a DataFrame-szintű transzformációkhoz, és használja ki az apply() erejét és rugalmasságát a komplex, soronkénti vagy oszloponkénti logika esetén, amelyet nem lehet vektorizálni. Ezzel a tudással felvértezve most már jobban felkészült arra, hogy bármilyen adatmanipulációs kihívással megbirkózzon, nyers adatokat alakítva át erőteljes felismerésekké ügyességgel és hatékonysággal.