കസ്റ്റം ഫംഗ്ഷനുകൾ പഠിച്ച് പാണ്ടസിന്റെ മുഴുവൻ സാധ്യതകളും കണ്ടെത്തുക. പ്രൊഫഷണൽ ഡാറ്റാ വിശകലനത്തിനായി apply(), map(), applymap() എന്നിവയുടെ വ്യത്യാസങ്ങൾ, പ്രകടനം, ഉപയോഗങ്ങൾ എന്നിവ ഈ ഗൈഡ് വിശദമാക്കുന്നു.
പാണ്ടസ് പഠിക്കാം: apply(), map(), applymap() എന്നിവ ഉപയോഗിച്ച് കസ്റ്റം ഫംഗ്ഷനുകളിലേക്ക് ഒരു ആഴത്തിലുള്ള പഠനം
ഡാറ്റാ സയൻസിന്റെയും വിശകലനത്തിന്റെയും ലോകത്ത്, പൈത്തണിന്റെ പാണ്ടസ് ലൈബ്രറി ഒഴിച്ചുകൂടാനാവാത്ത ഒരു ഉപകരണമാണ്. ഇത് ഘടനാപരമായ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നത് എളുപ്പവും അവബോധപരവുമാക്കാൻ രൂപകൽപ്പന ചെയ്ത ശക്തവും, വഴക്കമുള്ളതും, കാര്യക്ഷമവുമായ ഡാറ്റാ ഘടനകൾ നൽകുന്നു. അഗ്രഗേഷൻ, ഫിൽട്ടറിംഗ്, ട്രാൻസ്ഫോർമേഷൻ എന്നിവയ്ക്കായി പാണ്ടസിൽ ധാരാളം ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ഉണ്ടെങ്കിലും, ഓരോ ഡാറ്റാ പ്രൊഫഷണലിന്റെയും യാത്രയിൽ ഇവ മാത്രം മതിയാകാത്ത ഒരു സമയമെത്തും. നിങ്ങളുടെ സ്വന്തം കസ്റ്റം ലോജിക്, ഒരു പ്രത്യേക ബിസിനസ്സ് റൂൾ, അല്ലെങ്കിൽ എളുപ്പത്തിൽ ലഭ്യമല്ലാത്ത ഒരു സങ്കീർണ്ണമായ ട്രാൻസ്ഫോർമേഷൻ എന്നിവ പ്രയോഗിക്കേണ്ടി വന്നേക്കാം.കസ്റ്റം ഫംഗ്ഷനുകൾ പ്രയോഗിക്കാനുള്ള കഴിവ് ഒരു സൂപ്പർപവറായി മാറുന്നത് ഇവിടെയാണ്. എന്നിരുന്നാലും, പാണ്ടസ് ഇത് നേടാൻ നിരവധി മാർഗ്ഗങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, പ്രധാനമായും apply(), map(), applymap() എന്നീ മെത്തേഡുകളിലൂടെ. പുതിയതായി വരുന്നവർക്ക് ഈ ഫംഗ്ഷനുകൾ ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന തരത്തിൽ സമാനമായി തോന്നിയേക്കാം. ഏതാണ് ഉപയോഗിക്കേണ്ടത്? എപ്പോൾ? നിങ്ങളുടെ തിരഞ്ഞെടുപ്പിന് എന്തെല്ലാം പ്രകടനപരമായ പ്രത്യാഘാതങ്ങളുണ്ട്?
ഈ സമഗ്രമായ ഗൈഡ് ഈ ശക്തമായ മെത്തേഡുകളെക്കുറിച്ച് നിങ്ങൾക്ക് വ്യക്തത നൽകും. ഓരോന്നിനെയും വിശദമായി ഞങ്ങൾ പരിശോധിക്കും, അവയുടെ പ്രത്യേക ഉപയോഗ സാഹചര്യങ്ങൾ മനസ്സിലാക്കും, ഏറ്റവും പ്രധാനമായി, വൃത്തിയുള്ളതും കാര്യക്ഷമവും വായിക്കാൻ എളുപ്പമുള്ളതുമായ പാണ്ടസ് കോഡ് എഴുതുന്നതിന് ശരിയായ ഉപകരണം എങ്ങനെ തിരഞ്ഞെടുക്കാമെന്ന് പഠിക്കും. ഞങ്ങൾ ഉൾക്കൊള്ളുന്നത്:
map()മെത്തേഡ്: ഒരു സിംഗിൾ സീരീസിലെ എലമെന്റ്-വൈസ് ട്രാൻസ്ഫോർമേഷനുകൾക്ക് അനുയോജ്യം.apply()മെത്തേഡ്: ഒരു ഡാറ്റാഫ്രെയിമിലെ റോ-വൈസ് അല്ലെങ്കിൽ കോളം-വൈസ് പ്രവർത്തനങ്ങൾക്കുള്ള ബഹുമുഖമായ ഒരു ടൂൾ.applymap()മെത്തേഡ്: ഒരു മുഴുവൻ ഡാറ്റാഫ്രെയിമിലുമുള്ള എലമെന്റ്-വൈസ് പ്രവർത്തനങ്ങൾക്കുള്ള ഒരു സ്പെഷ്യലിസ്റ്റ്.- പ്രകടനപരമായ പരിഗണനകൾ: ഈ മെത്തേഡുകളും യഥാർത്ഥ വെക്ടറൈസേഷനും തമ്മിലുള്ള നിർണ്ണായകമായ വ്യത്യാസം.
- മികച്ച രീതികൾ: ഓരോ തവണയും ഏറ്റവും കാര്യക്ഷമമായ രീതി തിരഞ്ഞെടുക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന ഒരു തീരുമാനമെടുക്കൽ ചട്ടക്കൂട്.
അടിത്തറ ഒരുക്കുന്നു: നമ്മുടെ സാമ്പിൾ ഡാറ്റാസെറ്റ്
നമ്മുടെ ഉദാഹരണങ്ങൾ പ്രായോഗികവും വ്യക്തവുമാക്കാൻ, സ്ഥിരവും ആഗോള തലത്തിൽ പ്രാധാന്യമുള്ളതുമായ ഒരു ഡാറ്റാസെറ്റിൽ പ്രവർത്തിക്കാം. ഒരു സാങ്കൽപ്പിക അന്താരാഷ്ട്ര ഇ-കൊമേഴ്‌സ് കമ്പനിയിൽ നിന്നുള്ള ഓൺലൈൻ വിൽപ്പന ഡാറ്റയെ പ്രതിനിധീകരിക്കുന്ന ഒരു സാമ്പിൾ ഡാറ്റാഫ്രെയിം ഞങ്ങൾ സൃഷ്ടിക്കും.
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)
ഈ ഡാറ്റാഫ്രെയിം നമ്മുടെ ടാർഗെറ്റ് ഫംഗ്ഷനുകളുടെ മുഴുവൻ കഴിവുകളും പ്രദർശിപ്പിക്കുന്നതിന് ഡാറ്റാ ടൈപ്പുകളുടെ (ന്യൂമെറിക്, സ്ട്രിംഗ്, ഒരു മിസ്സിംഗ് മൂല്യം പോലും) ഒരു മികച്ച മിശ്രിതം നൽകുന്നു.
map() മെത്തേഡ്: ഒരു സീരീസിനുള്ള എലമെന്റ്-വൈസ് ട്രാൻസ്ഫോർമേഷൻ
എന്താണ് map()?
ഒരു സിംഗിൾ കോളത്തിലെ (ഒരു പാണ്ടസ് Series) മൂല്യങ്ങൾ പരിഷ്കരിക്കുന്നതിനുള്ള നിങ്ങളുടെ പ്രത്യേക ഉപകരണമാണ് map() മെത്തേഡ്. ഇത് എലമെന്റ്-ബൈ-എലമെന്റ് അടിസ്ഥാനത്തിലാണ് പ്രവർത്തിക്കുന്നത്. ഇത് ഇങ്ങനെ പറയുന്നതായി സങ്കൽപ്പിക്കുക: "ഈ കോളത്തിലെ ഓരോ ഇനത്തിനും, ഒരു നിഘണ്ടുവിൽ നോക്കുക അല്ലെങ്കിൽ ഈ ഫംഗ്ഷനിലൂടെ കടത്തിവിട്ട് ഫലം ഉപയോഗിച്ച് അതിനെ മാറ്റിസ്ഥാപിക്കുക."
ഇത് പ്രധാനമായും രണ്ട് കാര്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു:
- ഒരു നിഘണ്ടുവിന്റെ (ഒരു മാപ്പിംഗ്) അടിസ്ഥാനത്തിൽ മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കുക.
- ഓരോ എലമെന്റിലും ഒരു ലളിതമായ ഫംഗ്ഷൻ പ്രയോഗിക്കുക.
ഉപയോഗ കേസ് 1: ഒരു നിഘണ്ടു ഉപയോഗിച്ച് മൂല്യങ്ങൾ മാപ്പ് ചെയ്യുന്നു
map() ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും സാധാരണവും കാര്യക്ഷമവുമായ രീതിയാണിത്. നമ്മുടെ 'Category' കോളത്തെ അടിസ്ഥാനമാക്കി ഒരു വിശാലമായ 'Department' കോളം സൃഷ്ടിക്കാൻ നമ്മൾ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക. ഒരു പൈത്തൺ നിഘണ്ടുവിൽ ഒരു മാപ്പിംഗ് നിർവചിക്കാനും അത് പ്രയോഗിക്കാൻ map() ഉപയോഗിക്കാനും നമുക്ക് കഴിയും.
category_to_department = {
'Electronics': 'Technology',
'Accessories': 'Peripherals',
'Audio': 'Technology'
}
df['Department'] = df['Category'].map(category_to_department)
print(df[['Category', 'Department']])
ഔട്ട്പുട്ട്:
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
ഇത് എത്ര മനോഹരമായി പ്രവർത്തിക്കുന്നുവെന്ന് ശ്രദ്ധിക്കുക. 'Category' സീരീസിലെ ഓരോ മൂല്യവും category_to_department നിഘണ്ടുവിൽ തിരയുന്നു, കൂടാതെ അനുബന്ധ മൂല്യം പുതിയ 'Department' കോളം പൂരിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. നിഘണ്ടുവിൽ ഒരു കീ കണ്ടെത്തിയില്ലെങ്കിൽ, map() ഒരു NaN (സംഖ്യയല്ലാത്തത്) മൂല്യം ഉത്പാദിപ്പിക്കും, ഇത് പലപ്പോഴും മാപ്പ് ചെയ്യാത്ത വിഭാഗങ്ങൾക്ക് ആവശ്യമുള്ള സ്വഭാവമാണ്.
ഉപയോഗ കേസ് 2: map() ഉപയോഗിച്ച് ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു
നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ (ഒരു ലാംഡ ഫംഗ്ഷൻ ഉൾപ്പെടെ) map() ലേക്ക് കൈമാറാനും കഴിയും. സീരീസിലെ ഓരോ എലമെന്റിനും ഫംഗ്ഷൻ പ്രവർത്തിക്കും. വിലയ്ക്ക് ഒരു വിവരണാത്മക ലേബൽ നൽകുന്ന ഒരു പുതിയ കോളം നമുക്ക് സൃഷ്ടിക്കാം.
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']])
ഔട്ട്പുട്ട്:
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
map() എപ്പോൾ ഉപയോഗിക്കണം: ഒരു ദ്രുത സംഗ്രഹം
- നിങ്ങൾ ഒരു സിംഗിൾ കോളത്തിൽ (ഒരു സീരീസ്) പ്രവർത്തിക്കുമ്പോൾ.
- ഒരു നിഘണ്ടുവിനെയോ മറ്റൊരു സീരീസിനെയോ അടിസ്ഥാനമാക്കി മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കേണ്ടി വരുമ്പോൾ. ഇതാണ് ഇതിന്റെ പ്രധാന ശക്തി.
- ഒരു സിംഗിൾ കോളത്തിൽ ഒരു ലളിതമായ എലമെന്റ്-വൈസ് ഫംഗ്ഷൻ പ്രയോഗിക്കേണ്ടി വരുമ്പോൾ.
apply() മെത്തേഡ്: ബഹുമുഖമായ ഉപകരണം
എന്താണ് apply()?
map() ഒരു സ്പെഷ്യലിസ്റ്റ് ആണെങ്കിൽ, apply() ഒരു പൊതുവായ ഉപയോഗത്തിനുള്ള ശക്തമായ ഒന്നാണ്. ഇത് സീരീസുകളിലും ഡാറ്റാഫ്രെയിമുകളിലും പ്രവർത്തിക്കാൻ കഴിയുന്നത് കൊണ്ട് കൂടുതൽ വഴക്കമുള്ളതാണ്. apply() നെ മനസ്സിലാക്കുന്നതിനുള്ള താക്കോൽ axis പാരാമീറ്ററാണ്, ഇത് അതിന്റെ പ്രവർത്തനത്തെ നയിക്കുന്നു:
- ഒരു സീരീസിൽ: ഇത്
map()നെപ്പോലെ എലമെന്റ്-വൈസ് ആയി പ്രവർത്തിക്കുന്നു. axis=0(ഡിഫോൾട്ട്) ഉള്ള ഒരു ഡാറ്റാഫ്രെയിമിൽ: ഇത് ഓരോ കോളത്തിലും ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു. ഫംഗ്ഷന് ഓരോ കോളവും ഒരു സീരീസായി ലഭിക്കുന്നു.axis=1ഉള്ള ഒരു ഡാറ്റാഫ്രെയിമിൽ: ഇത് ഓരോ വരിയിലും ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു. ഫംഗ്ഷന് ഓരോ വരിയും ഒരു സീരീസായി ലഭിക്കുന്നു.
ഒരു സീരീസിലെ apply()
ഒരു സീരീസിൽ ഉപയോഗിക്കുമ്പോൾ, apply(), map() നെപ്പോലെ തന്നെ പ്രവർത്തിക്കുന്നു. ഇത് ഓരോ എലമെന്റിലും ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, നമ്മുടെ വില ലേബൽ ഉദാഹരണം ഇതിലൂടെയും ചെയ്യാൻ കഴിയും.
df['Price_Label_apply'] = df['Price_USD'].apply(price_label)
print(df['Price_Label_apply'].equals(df['Price_Label'])) # Output: True
ഇവിടെ അവ പരസ്പരം മാറ്റാവുന്നവയായി തോന്നുമെങ്കിലും, ഒരു സീരീസിലെ ലളിതമായ നിഘണ്ടു മാറ്റിസ്ഥാപിക്കലുകൾക്കും എലമെന്റ്-വൈസ് പ്രവർത്തനങ്ങൾക്കും map() പലപ്പോഴും അല്പം വേഗതയുള്ളതാണ്, കാരണം ആ പ്രത്യേക ജോലികൾക്കായി ഇതിന് കൂടുതൽ ഒപ്റ്റിമൈസ് ചെയ്ത ഒരു പാതയുണ്ട്.
ഒരു ഡാറ്റാഫ്രെയിമിലെ apply() (കോളം-വൈസ്, axis=0)
ഇത് ഒരു ഡാറ്റാഫ്രെയിമിന്റെ ഡിഫോൾട്ട് മോഡാണ്. നിങ്ങൾ നൽകുന്ന ഫംഗ്ഷൻ ഓരോ കോളത്തിലും ഒരിക്കൽ വീതം വിളിക്കപ്പെടുന്നു. കോളം-വൈസ് അഗ്രഗേഷനുകൾക്കോ ട്രാൻസ്ഫോർമേഷനുകൾക്കോ ഇത് ഉപയോഗപ്രദമാണ്.
നമ്മുടെ ഓരോ ന്യൂമെറിക് കോളത്തിലെയും പരമാവധി, ഏറ്റവും കുറഞ്ഞ മൂല്യങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം (റേഞ്ച്) കണ്ടെത്താം.
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)
ഔട്ട്പുട്ട്:
Price_USD 1175.0
Quantity 2.0
dtype: float64
ഇവിടെ, get_range ഫംഗ്ഷൻ ആദ്യം 'Price_USD' സീരീസ് സ്വീകരിച്ചു, അതിന്റെ റേഞ്ച് കണക്കാക്കി, തുടർന്ന് 'Quantity' സീരീസ് സ്വീകരിച്ച് അതേ പ്രവർത്തനം നടത്തുകയും ഫലങ്ങളോടുകൂടിയ ഒരു പുതിയ സീരീസ് തിരികെ നൽകുകയും ചെയ്തു.
ഒരു ഡാറ്റാഫ്രെയിമിലെ apply() (റോ-വൈസ്, axis=1)
ഇത് apply() ന്റെ ഏറ്റവും ശക്തവും സാധാരണവുമായ ഉപയോഗ കേസാണ്. ഒരേ വരിയിലെ ഒന്നിലധികം കോളങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ മൂല്യം കണക്കാക്കേണ്ടി വരുമ്പോൾ, apply() വിത്ത് axis=1 ആണ് നിങ്ങളുടെ ഏറ്റവും മികച്ച പരിഹാരം.
നിങ്ങൾ കൈമാറുന്ന ഫംഗ്ഷന് ഓരോ വരിയും ഒരു സീരീസായി ലഭിക്കും, അതിൽ ഇൻഡക്സ് കോളം പേരുകളാണ്. ഓരോ ഓർഡറിനുമുള്ള മൊത്തം ചെലവ് നമുക്ക് കണക്കാക്കാം.
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']])
ഔട്ട്പുട്ട്:
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
ഒരു സിംഗിൾ കോളത്തിൽ മാത്രം ഒതുങ്ങിനിൽക്കുന്നതിനാൽ map() ന് ഇത് ചെയ്യാൻ കഴിയില്ല. കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം നോക്കാം. ഓരോ ഓർഡറിന്റെയും ഷിപ്പിംഗ് മുൻഗണന അതിന്റെ വിഭാഗത്തെയും രാജ്യത്തെയും അടിസ്ഥാനമാക്കി തരംതിരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
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']])
apply() എപ്പോൾ ഉപയോഗിക്കണം: ഒരു ദ്രുത സംഗ്രഹം
- നിങ്ങളുടെ ലോജിക് ഒരു വരിയിലെ ഒന്നിലധികം കോളങ്ങളെ ആശ്രയിച്ചിരിക്കുമ്പോൾ (
axis=1ഉപയോഗിക്കുക). ഇതാണ് ഇതിന്റെ പ്രധാന സവിശേഷത. - കോളങ്ങളിലോ വരികളിലോ ഒരു അഗ്രഗേഷൻ ഫംഗ്ഷൻ പ്രയോഗിക്കേണ്ടി വരുമ്പോൾ.
map()അനുയോജ്യമല്ലാത്തപ്പോൾ ഒരു പൊതു ആവശ്യത്തിനുള്ള ഫംഗ്ഷൻ ആപ്ലിക്കേഷൻ ടൂളായി.
ഒരു പ്രത്യേക പരാമർശം: applymap() മെത്തേഡ്
എന്താണ് applymap()?
applymap() മെത്തേഡ് മറ്റൊരു സ്പെഷ്യലിസ്റ്റ് ആണ്, എന്നാൽ അതിന്റെ ഡൊമെയ്ൻ മുഴുവൻ ഡാറ്റാഫ്രെയിം ആണ്. ഇത് ഒരു ഡാറ്റാഫ്രെയിമിലെ ഓരോ എലമെന്റിലും ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു. ഇത് ഒരു സീരീസിൽ പ്രവർത്തിക്കുന്നില്ല—ഇതൊരു ഡാറ്റാഫ്രെയിം-മാത്രം മെത്തേഡാണ്.
എല്ലാ കോളങ്ങളിലും ഒരേ സമയം ഒരു map() പ്രവർത്തിപ്പിക്കുന്നതായി ഇതിനെ കണക്കാക്കുക. എല്ലാ സെല്ലുകളിലും ഫോർമാറ്റിംഗ് അല്ലെങ്കിൽ ടൈപ്പ് കൺവേർഷൻ പോലുള്ള വിശാലമായ ട്രാൻസ്ഫോർമേഷനുകൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.
DataFrame.applymap() ഉപയോഗിക്കരുത്. പുതിയ ശുപാർശ ചെയ്യുന്ന രീതി DataFrame.map() ഉപയോഗിക്കുക എന്നതാണ്. പ്രവർത്തനക്ഷമത സമാനമാണ്. അനുയോജ്യതയ്ക്കായി ഞങ്ങൾ ഇവിടെ applymap() ഉപയോഗിക്കും, എന്നാൽ ഭാവിയിലെ കോഡിനായി ഈ മാറ്റം ശ്രദ്ധിക്കുക.
ഒരു പ്രായോഗിക ഉദാഹരണം
നമ്മുടെ ന്യൂമെറിക് കോളങ്ങൾ മാത്രമുള്ള ഒരു സബ്-ഡാറ്റാഫ്രെയിം ഉണ്ടെന്ന് കരുതുക, ഒരു റിപ്പോർട്ടിനായി അവയെല്ലാം കറൻസി സ്ട്രിംഗുകളായി ഫോർമാറ്റ് ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
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)
ഔട്ട്പുട്ട്:
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
മറ്റൊരു സാധാരണ ഉപയോഗം സ്ട്രിംഗ് ഡാറ്റയുടെ ഒരു ഡാറ്റാഫ്രെയിം വൃത്തിയാക്കുക എന്നതാണ്, ഉദാഹരണത്തിന്, എല്ലാം ലോവർകേസിലേക്ക് മാറ്റുന്നത്.
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)
ഔട്ട്പുട്ട്:
Product Category Country
0 laptop electronics usa
1 mouse accessories canada
2 keyboard accessories usa
3 monitor electronics germany
4 webcam accessories japan
5 headphones audio canada
6 docking station electronics germany
7 mouse accessories nan
applymap() എപ്പോൾ ഉപയോഗിക്കണം: ഒരു ദ്രുത സംഗ്രഹം
- ഒരു ഡാറ്റാഫ്രെയിമിലെ എല്ലാ എലമെന്റുകളിലും ഒരു ലളിതമായ ഫംഗ്ഷൻ പ്രയോഗിക്കേണ്ടി വരുമ്പോൾ.
- ഡാറ്റാ ടൈപ്പ് കൺവേർഷൻ, സ്ട്രിംഗ് ഫോർമാറ്റിംഗ്, അല്ലെങ്കിൽ മുഴുവൻ ഡാറ്റാഫ്രെയിമിലുമുള്ള ലളിതമായ ഗണിതശാസ്ത്രപരമായ മാറ്റങ്ങൾ എന്നിവ പോലുള്ള ജോലികൾക്ക്.
- പുതിയ പാണ്ടസ് പതിപ്പുകളിൽ
DataFrame.map()ന് അനുകൂലമായി ഇതിന്റെ ഉപയോഗം ഒഴിവാക്കുന്നു എന്നത് ഓർക്കുക.
പ്രകടനത്തെക്കുറിച്ച് ആഴത്തിലുള്ള പഠനം: വെക്ടറൈസേഷൻ വേർസസ് ഇറ്ററേഷൻ
"മറഞ്ഞിരിക്കുന്ന" ലൂപ്പ്
ഉയർന്ന പ്രകടനമുള്ള പാണ്ടസ് കോഡ് എഴുതുന്നതിന് മനസ്സിലാക്കേണ്ട ഏറ്റവും പ്രധാനപ്പെട്ട ആശയമാണിത്. apply(), map(), applymap() എന്നിവ സൗകര്യപ്രദമാണെങ്കിലും, അവ യഥാർത്ഥത്തിൽ ഒരു പൈത്തൺ ലൂപ്പിന് ചുറ്റുമുള്ള ഫാൻസി റാപ്പറുകൾ മാത്രമാണ്. നിങ്ങൾ df.apply(..., axis=1) ഉപയോഗിക്കുമ്പോൾ, പാണ്ടസ് നിങ്ങളുടെ ഡാറ്റാഫ്രെയിമിലൂടെ വരിക്ക് വരിയായി ഇറ്ററേറ്റ് ചെയ്യുകയും ഓരോന്നിനെയും നിങ്ങളുടെ ഫംഗ്ഷനിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു. ഈ പ്രക്രിയയ്ക്ക് കാര്യമായ ഓവർഹെഡ് ഉണ്ട്, കൂടാതെ C അല്ലെങ്കിൽ സൈത്തണിൽ ഒപ്റ്റിമൈസ് ചെയ്ത പ്രവർത്തനങ്ങളേക്കാൾ വളരെ വേഗത കുറഞ്ഞതുമാണ്.
വെക്ടറൈസേഷന്റെ ശക്തി
ഒറ്റപ്പെട്ട എലമെന്റുകളിൽ പ്രവർത്തിക്കുന്നതിന് പകരം മുഴുവൻ അറേകളിലും (അല്ലെങ്കിൽ സീരീസുകളിലും) ഒരേസമയം പ്രവർത്തനങ്ങൾ നടത്തുന്ന രീതിയാണ് വെക്ടറൈസേഷൻ. പാണ്ടസും അതിന്റെ അടിസ്ഥാന ലൈബ്രറിയായ നംപയും, വെക്ടറൈസ്ഡ് പ്രവർത്തനങ്ങളിൽ അവിശ്വസനീയമാംവിധം വേഗതയുള്ളതാക്കാൻ പ്രത്യേകം രൂപകൽപ്പന ചെയ്തവയാണ്.
നമ്മുടെ 'Total_Cost' കണക്കുകൂട്ടൽ വീണ്ടും പരിശോധിക്കാം. നമ്മൾ apply() ഉപയോഗിച്ചു, എന്നാൽ ഇതിനൊരു വെക്ടറൈസ്ഡ് മാർഗ്ഗമുണ്ടോ?
# 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
രണ്ടാമത്തെ രീതി വെക്ടറൈസ്ഡ് ആണ്. ഇത് മുഴുവൻ 'Price_USD' സീരീസ് എടുക്കുകയും അതിനെ മുഴുവൻ 'Quantity' സീരീസ് ഉപയോഗിച്ച് ഒരൊറ്റ, വളരെ ഒപ്റ്റിമൈസ് ചെയ്ത പ്രവർത്തനത്തിലൂടെ ഗുണിക്കുകയും ചെയ്യുന്നു. ഒരു വലിയ ഡാറ്റാഫ്രെയിമിൽ (ദശലക്ഷക്കണക്കിന് വരികൾ) ഈ രണ്ട് രീതികളും നിങ്ങൾ സമയബന്ധിതമായി നോക്കുകയാണെങ്കിൽ, വെക്ടറൈസ്ഡ് സമീപനം വേഗതയുള്ളത് മാത്രമല്ല—അത് നിരവധി മടങ്ങ് വേഗതയുള്ളതായിരിക്കും. നമ്മൾ സംസാരിക്കുന്നത് നിമിഷങ്ങളും മിനിറ്റുകളും തമ്മിൽ, അല്ലെങ്കിൽ മിനിറ്റുകളും മണിക്കൂറുകളും തമ്മിലുള്ള വ്യത്യാസത്തെക്കുറിച്ചാണ്.
apply() ഒഴിവാക്കാനാവാത്തത് എപ്പോഴാണ്?
വെക്ടറൈസേഷൻ വളരെ വേഗതയുള്ളതാണെങ്കിൽ, ഈ മറ്റ് രീതികൾ എന്തിനാണ് നിലനിൽക്കുന്നത്? കാരണം ചിലപ്പോൾ, നിങ്ങളുടെ ലോജിക് വെക്ടറൈസ് ചെയ്യാൻ കഴിയാത്തത്ര സങ്കീർണ്ണമായിരിക്കും. apply() ആവശ്യമായതും ശരിയായതുമായ ഉപകരണമാണ്:
- സങ്കീർണ്ണമായ കണ്ടീഷണൽ ലോജിക്: നമ്മുടെ
assign_shipping_priorityഉദാഹരണം പോലെ, നിങ്ങളുടെ ലോജിക്കിൽ ഒന്നിലധികം കോളങ്ങളെ ആശ്രയിച്ചിരിക്കുന്ന സങ്കീർണ്ണമായ `if/elif/else` സ്റ്റേറ്റ്‌മെന്റുകൾ ഉൾപ്പെടുന്നുണ്ടെങ്കിൽ. ഇത് `np.select()` ഉപയോഗിച്ച് നേടാൻ കഴിയുമെങ്കിലും, അത് വായിക്കാൻ ബുദ്ധിമുട്ടായേക്കാം. - എക്സ്റ്റേണൽ ലൈബ്രറി ഫംഗ്ഷനുകൾ: നിങ്ങളുടെ ഡാറ്റയിലേക്ക് ഒരു എക്സ്റ്റേണൽ ലൈബ്രറിയിൽ നിന്നുള്ള ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കണമെങ്കിൽ. ഉദാഹരണത്തിന്, അക്ഷാംശവും രേഖാംശവും കോളങ്ങളെ അടിസ്ഥാനമാക്കി ദൂരം കണക്കാക്കാൻ ഒരു ജിയോസ്പേഷ്യൽ ലൈബ്രറിയിൽ നിന്നുള്ള ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നത്, അല്ലെങ്കിൽ ഒരു ടെക്സ്റ്റ് കോളത്തിൽ സെന്റിമെന്റ് അനാലിസിസ് നടത്താൻ ഒരു നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് ലൈബ്രറിയിൽ (NLTK പോലുള്ളവ) നിന്നുള്ള ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നത്.
- ഇറ്ററേറ്റീവ് പ്രോസസ്സുകൾ: ഒരു നിർദ്ദിഷ്ട വരിയുടെ കണക്കുകൂട്ടൽ മുൻപത്തെ വരിയിൽ കണക്കാക്കിയ ഒരു മൂല്യത്തെ ആശ്രയിച്ചിരിക്കുമ്പോൾ (ഇത് അപൂർവമാണ്, പലപ്പോഴും ഒരു വ്യത്യസ്ത ഡാറ്റാ ഘടന ആവശ്യമാണെന്നതിന്റെ സൂചനയാണ്).
മികച്ച രീതി: ആദ്യം വെക്ടറൈസ് ചെയ്യുക, രണ്ടാമത് apply()
ഇത് പാണ്ടസ് പ്രകടനത്തിന്റെ സുവർണ്ണ നിയമത്തിലേക്ക് നയിക്കുന്നു:
എല്ലായ്പ്പോഴും ഒരു വെക്ടറൈസ്ഡ് പരിഹാരത്തിനായി ആദ്യം നോക്കുക. ഒരു വെക്ടറൈസ്ഡ് പരിഹാരം പ്രായോഗികമോ സാധ്യമോ അല്ലാത്തപ്പോൾ നിങ്ങളുടെ ശക്തവും വഴക്കമുള്ളതുമായ ഫാൽബാക്കായി apply() ഉപയോഗിക്കുക.
സംഗ്രഹവും പ്രധാന പാഠങ്ങളും: ശരിയായ ഉപകരണം തിരഞ്ഞെടുക്കുന്നു
നമ്മുടെ അറിവ് ഒരു വ്യക്തമായ തീരുമാനമെടുക്കൽ ചട്ടക്കൂടിലേക്ക് ഏകീകരിക്കാം. ഒരു കസ്റ്റം ട്രാൻസ്ഫോർമേഷൻ ടാസ്ക് നേരിടുമ്പോൾ, ഈ ചോദ്യങ്ങൾ സ്വയം ചോദിക്കുക:
താരതമ്യ പട്ടിക
| രീതി | പ്രവർത്തിക്കുന്നത് | പ്രവർത്തനത്തിന്റെ വ്യാപ്തി | ഫംഗ്ഷൻ സ്വീകരിക്കുന്നത് | പ്രധാന ഉപയോഗം |
|---|---|---|---|---|
| വെക്ടറൈസേഷൻ | സീരീസ്, ഡാറ്റാഫ്രെയിം | മുഴുവൻ അറേയും ഒറ്റയടിക്ക് | ലഭ്യമല്ല (പ്രവർത്തനം നേരിട്ടാണ്) | അരിത്മെറ്റിക്, ലോജിക്കൽ പ്രവർത്തനങ്ങൾ. ഏറ്റവും ഉയർന്ന പ്രകടനം. |
.map() |
സീരീസിൽ മാത്രം | എലമെന്റ്-ബൈ-എലമെന്റ് | ഒരൊറ്റ എലമെന്റ് | ഒരു നിഘണ്ടുവിൽ നിന്ന് മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നത്. |
.apply() |
സീരീസ്, ഡാറ്റാഫ്രെയിം | വരിക്ക് വരിയായി അല്ലെങ്കിൽ കോളത്തിന് കോളമായി | ഒരു സീരീസ് (ഒരു വരി അല്ലെങ്കിൽ കോളം) | ഓരോ വരിയിലും ഒന്നിലധികം കോളങ്ങൾ ഉപയോഗിച്ചുള്ള സങ്കീർണ്ണമായ ലോജിക്. |
.applymap() |
ഡാറ്റാഫ്രെയിമിൽ മാത്രം | എലമെന്റ്-ബൈ-എലമെന്റ് | ഒരൊറ്റ എലമെന്റ് | ഒരു ഡാറ്റാഫ്രെയിമിലെ ഓരോ സെല്ലും ഫോർമാറ്റ് ചെയ്യുകയോ മാറ്റം വരുത്തുകയോ ചെയ്യുക. |
ഒരു തീരുമാനമെടുക്കൽ ഫ്ലോചാർട്ട്
- എന്റെ പ്രവർത്തനം മുഴുവൻ കോളങ്ങളിലും അടിസ്ഥാന ഗണിതശാസ്ത്രപരമായ (+, -, *, /) അല്ലെങ്കിൽ ലോജിക്കൽ ഓപ്പറേറ്ററുകൾ (&, |, ~) ഉപയോഗിച്ച് പ്രകടിപ്പിക്കാൻ കഴിയുമോ?
→ അതെ? ഒരു വെക്ടറൈസ്ഡ് സമീപനം ഉപയോഗിക്കുക. ഇതാണ് ഏറ്റവും വേഗതയേറിയത്. (ഉദാഹരണത്തിന്, `df['col1'] * df['col2']`) - ഞാൻ ഒരു സിംഗിൾ കോളത്തിൽ മാത്രമാണോ പ്രവർത്തിക്കുന്നത്, ഒരു നിഘണ്ടുവിന്റെ അടിസ്ഥാനത്തിൽ മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കുക എന്നതാണോ എന്റെ പ്രധാന ലക്ഷ്യം?
→ അതെ?Series.map()ഉപയോഗിക്കുക. ഇതിനായി ഇത് ഒപ്റ്റിമൈസ് ചെയ്തിരിക്കുന്നു. - എന്റെ മുഴുവൻ ഡാറ്റാഫ്രെയിമിലെയും ഓരോ എലമെന്റിലും ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കേണ്ടതുണ്ടോ?
→ അതെ?DataFrame.applymap()ഉപയോഗിക്കുക (അല്ലെങ്കിൽ പുതിയ പാണ്ടസ് പതിപ്പുകളിൽDataFrame.map()). - എന്റെ ലോജിക് സങ്കീർണ്ണവും ഓരോ വരിയിലെയും ഒന്നിലധികം കോളങ്ങളിൽ നിന്നുള്ള മൂല്യങ്ങൾ ഒരു ഒറ്റ ഫലം കണക്കാക്കാൻ ആവശ്യപ്പെടുന്നതുമാണോ?
→ അതെ?DataFrame.apply(..., axis=1)ഉപയോഗിക്കുക. സങ്കീർണ്ണമായ, വരിക്ക് വരി ലോജിക്കിനുള്ള നിങ്ങളുടെ ഉപകരണമാണിത്.
ഉപസംഹാരം
പാണ്ടസിൽ കസ്റ്റം ഫംഗ്ഷനുകൾ പ്രയോഗിക്കുന്നതിനുള്ള ഓപ്ഷനുകൾ മനസ്സിലാക്കുന്നത് ഏതൊരു ഡാറ്റാ പ്രാക്ടീഷണർക്കും ഒരു കടമ്പയാണ്. ഒറ്റനോട്ടത്തിൽ പരസ്പരം മാറ്റാവുന്നവയായി തോന്നാമെങ്കിലും, map(), apply(), applymap() എന്നിവ വ്യത്യസ്ത ഉപകരണങ്ങളാണ്, ഓരോന്നിനും അതിൻ്റേതായ ശക്തികളും അനുയോജ്യമായ ഉപയോഗ സാഹചര്യങ്ങളുമുണ്ട്. അവയുടെ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ശരിയായ കോഡ് മാത്രമല്ല, കൂടുതൽ വായിക്കാൻ കഴിയുന്നതും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, ഗണ്യമായി മികച്ച പ്രകടനമുള്ളതുമായ കോഡ് എഴുതാൻ കഴിയും.
ശ്രേണി ഓർമ്മിക്കുക: അതിന്റെ അസംസ്കൃത വേഗതയ്ക്ക് വെക്ടറൈസേഷൻ തിരഞ്ഞെടുക്കുക, കാര്യക്ഷമമായ സീരീസ് സബ്സ്റ്റിറ്റ്യൂഷനായി map() ഉപയോഗിക്കുക, ഡാറ്റാഫ്രെയിം-വൈഡ് ട്രാൻസ്ഫോർമേഷനുകൾക്ക് applymap() തിരഞ്ഞെടുക്കുക, വെക്ടറൈസ് ചെയ്യാൻ കഴിയാത്ത സങ്കീർണ്ണമായ റോ-വൈസ് അല്ലെങ്കിൽ കോളം-വൈസ് ലോജിക്കിനായി apply() ന്റെ ശക്തിയും വഴക്കവും പ്രയോജനപ്പെടുത്തുക. ഈ അറിവ് കൊണ്ട്, നിങ്ങളുടെ വഴിയിൽ വരുന്ന ഏത് ഡാറ്റാ മാനിപുലേഷൻ വെല്ലുവിളികളെയും നേരിടാൻ നിങ്ങൾ ഇപ്പോൾ കൂടുതൽ സജ്ജരാണ്, അസംസ്കൃത ഡാറ്റയെ വൈദഗ്ധ്യത്തോടെയും കാര്യക്ഷമതയോടെയും ശക്തമായ ഉൾക്കാഴ്ചകളാക്കി മാറ്റുന്നു.