പൈത്തൺ പാൻഡാസിൽ ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതിനും യോജിപ്പിക്കുന്നതിനുമുള്ള ഒരു സമഗ്ര ഗൈഡ്. ഇന്നർ, ഔട്ടർ, ലെഫ്റ്റ്, റൈറ്റ് ജോയിനുകൾ പോലുള്ള വിവിധ തന്ത്രങ്ങൾ ഇതിൽ ഉൾപ്പെടുന്നു.
പൈത്തൺ പാൻഡാസ് മെർജിംഗ്: ഡാറ്റാ അനാലിസിസിനായുള്ള ഡാറ്റാഫ്രെയിം ജോയിനിംഗ് തന്ത്രങ്ങളിൽ പ്രാവീണ്യം നേടാം
ഡാറ്റാ അനാലിസിസിൽ ഡാറ്റാ മാനിപുലേഷൻ ഒരു നിർണായക ഘടകമാണ്, ഇതിനായി പൈത്തണിലെ പാൻഡാസ് ലൈബ്രറി ശക്തമായ ടൂളുകൾ നൽകുന്നു. ഈ ടൂളുകളിൽ, പൊതുവായ കോളങ്ങളെയോ ഇൻഡെക്സുകളെയോ അടിസ്ഥാനമാക്കി ഡാറ്റാസെറ്റുകൾ സംയോജിപ്പിക്കുന്നതിനുള്ള പ്രധാന പ്രവർത്തനങ്ങളാണ് ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതും (merging) യോജിപ്പിക്കുന്നതും (joining). പാൻഡാസിലെ വിവിധ ഡാറ്റാഫ്രെയിം ജോയിനിംഗ് തന്ത്രങ്ങൾ ഈ സമഗ്രമായ ഗൈഡ് വിശദീകരിക്കുന്നു, ഇത് വിവിധ സ്രോതസ്സുകളിൽ നിന്നുള്ള ഡാറ്റ കാര്യക്ഷമമായി സംയോജിപ്പിക്കാനും വിശകലനം ചെയ്യാനും നിങ്ങളെ സഹായിക്കും.
ഡാറ്റാഫ്രെയിം മെർജിംഗും ജോയിനിംഗും മനസ്സിലാക്കാം
രണ്ടോ അതിലധികമോ ഡാറ്റാഫ്രെയിമുകളെ ഒരു പൊതുവായ കോളത്തിന്റെയോ ഇൻഡെക്സിന്റെയോ അടിസ്ഥാനത്തിൽ ഒരൊറ്റ ഡാറ്റാഫ്രെയിമാക്കി മാറ്റുന്ന പ്രക്രിയയാണ് മെർജിംഗും ജോയിനിംഗും. `merge`-ഉം `join`-ഉം തമ്മിലുള്ള പ്രധാന വ്യത്യാസം, `merge` എന്നത് പാൻഡാസ് ലൈബ്രറിയുടെ ഒരു ഫംഗ്ഷനാണ്, അത് സാധാരണയായി കോളങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിമുകളെ യോജിപ്പിക്കുന്നു. അതേസമയം, `join` എന്നത് ഡാറ്റാഫ്രെയിമിന്റെ ഒരു മെത്തേഡാണ്, ഇത് പ്രധാനമായും ഇൻഡെക്സുകളെ അടിസ്ഥാനമാക്കി യോജിപ്പിക്കുന്നു, എന്നിരുന്നാലും ഇത് കോളങ്ങൾക്കൊപ്പവും ഉപയോഗിക്കാം.
പ്രധാന ആശയങ്ങൾ
- ഡാറ്റാഫ്രെയിമുകൾ: വ്യത്യസ്ത തരം ഡാറ്റകൾ അടങ്ങിയ കോളങ്ങളുള്ള, ദ്വിമാന ലേബൽ ചെയ്ത ഡാറ്റാ സ്ട്രക്ച്ചറുകൾ.
- പൊതുവായ കോളങ്ങൾ/ഇൻഡെക്സുകൾ: ഡാറ്റാഫ്രെയിമുകളിലുടനീളം ഒരേ പേരും ഡാറ്റാ ടൈപ്പും പങ്കിടുന്ന കോളങ്ങൾ അല്ലെങ്കിൽ ഇൻഡെക്സുകൾ. ഇവയാണ് ലയിപ്പിക്കുന്നതിനും/യോജിപ്പിക്കുന്നതിനും അടിസ്ഥാനമായി വർത്തിക്കുന്നത്.
- ജോയിൻ തരങ്ങൾ: ലയിപ്പിക്കുമ്പോൾ/യോജിപ്പിക്കുമ്പോൾ പൊരുത്തമില്ലാത്ത വരികളെ കൈകാര്യം ചെയ്യുന്നതിനുള്ള വ്യത്യസ്ത തന്ത്രങ്ങൾ. ഇതിൽ ഇന്നർ, ഔട്ടർ, ലെഫ്റ്റ്, റൈറ്റ് ജോയിനുകൾ ഉൾപ്പെടുന്നു.
`pd.merge()` ഉപയോഗിച്ച് ഡാറ്റാഫ്രെയിം ലയിപ്പിക്കൽ
കോളങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതിനുള്ള പ്രധാന ടൂൾ `pd.merge()` ഫംഗ്ഷനാണ്. ഒന്നോ അതിലധികമോ പൊതുവായ കോളങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റ സംയോജിപ്പിക്കാൻ ഇത് വഴക്കമുള്ള ഒരു മാർഗം നൽകുന്നു.
സിൻടാക്സ്
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
പാരാമീറ്ററുകൾ
- left: ലയിപ്പിക്കേണ്ട ഇടത് ഡാറ്റാഫ്രെയിം.
- right: ലയിപ്പിക്കേണ്ട വലത് ഡാറ്റാഫ്രെയിം.
- how: ഏത് തരം മെർജ് ആണ് നടത്തേണ്ടത് ('inner', 'outer', 'left', 'right'). ഡിഫോൾട്ട് 'inner' ആണ്.
- on: ജോയിൻ ചെയ്യേണ്ട കോളത്തിന്റെ (കോളങ്ങളുടെ) പേര്. ഇത് രണ്ട് ഡാറ്റാഫ്രെയിമുകളിലും ഉണ്ടായിരിക്കണം.
- left_on: ഇടത് ഡാറ്റാഫ്രെയിമിൽ ജോയിൻ കീകളായി ഉപയോഗിക്കേണ്ട കോളത്തിന്റെ (കോളങ്ങളുടെ) പേര്.
- right_on: വലത് ഡാറ്റാഫ്രെയിമിൽ ജോയിൻ കീകളായി ഉപയോഗിക്കേണ്ട കോളത്തിന്റെ (കോളങ്ങളുടെ) പേര്.
- left_index: True ആണെങ്കിൽ, ഇടത് ഡാറ്റാഫ്രെയിമിലെ ഇൻഡെക്സ് ജോയിൻ കീ(കളായി) ഉപയോഗിക്കുക.
- right_index: True ആണെങ്കിൽ, വലത് ഡാറ്റാഫ്രെയിമിലെ ഇൻഡെക്സ് ജോയിൻ കീ(കളായി) ഉപയോഗിക്കുക.
- sort: ജോയിൻ കീകൾ ഉപയോഗിച്ച് ഫലമായുണ്ടാകുന്ന ഡാറ്റാഫ്രെയിം അക്ഷരമാലാക്രമത്തിൽ അടുക്കുക. ഡിഫോൾട്ട് False ആണ്.
- suffixes: ഓവർലാപ്പ് ചെയ്യുന്ന കോളങ്ങളുടെ പേരുകളിൽ പ്രയോഗിക്കാനുള്ള സ്ട്രിംഗ് സഫിക്സുകളുടെ ഒരു ടപ്പിൾ. ഡിഫോൾട്ട് ('_x', '_y') ആണ്.
- copy: False ആണെങ്കിൽ, സാധ്യമാകുന്നിടത്ത് പുതിയ ഡാറ്റാഫ്രെയിമിലേക്ക് ഡാറ്റ പകർത്തുന്നത് ഒഴിവാക്കുക. ഡിഫോൾട്ട് True ആണ്.
- indicator: True ആണെങ്കിൽ, ഓരോ വരിയുടെയും ഉറവിടം സൂചിപ്പിക്കുന്ന '_merge' എന്നൊരു കോളം ചേർക്കുന്നു.
- validate: മെർജ് നിർദ്ദിഷ്ട തരത്തിലുള്ളതാണോയെന്ന് പരിശോധിക്കുന്നു. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
ജോയിൻ തരങ്ങൾ വിശദീകരിക്കുന്നു
`pd.merge()`-ലെ `how` പാരാമീറ്റർ ആണ് ഏത് തരം ജോയിൻ ആണ് നടത്തേണ്ടതെന്ന് തീരുമാനിക്കുന്നത്. വ്യത്യസ്ത ജോയിൻ തരങ്ങൾ പൊരുത്തമില്ലാത്ത വരികളെ വ്യത്യസ്ത രീതികളിൽ കൈകാര്യം ചെയ്യുന്നു.
ഇന്നർ ജോയിൻ (Inner Join)
ഒരു ഇന്നർ ജോയിൻ, ജോയിൻ കീകളെ അടിസ്ഥാനമാക്കി രണ്ട് ഡാറ്റാഫ്രെയിമുകളിലും പൊരുത്തപ്പെടുന്ന മൂല്യങ്ങളുള്ള വരികൾ മാത്രം നൽകുന്നു. പൊരുത്തമില്ലാത്ത മൂല്യങ്ങളുള്ള വരികളെ ഫലത്തിൽ നിന്ന് ഒഴിവാക്കുന്നു.
ഉദാഹരണം:
രണ്ട് ഡാറ്റാഫ്രെയിമുകൾ പരിഗണിക്കുക:
import pandas as pd
# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
ഈ ഉദാഹരണത്തിൽ, ഇന്നർ ജോയിൻ `df_orders`, `df_customers` എന്നീ ഡാറ്റാഫ്രെയിമുകളെ `customer_id` കോളം അടിസ്ഥാനമാക്കി സംയോജിപ്പിക്കുന്നു. ഓർഡറുകൾ നൽകിയിട്ടുള്ള ഉപഭോക്താക്കളെ മാത്രമേ ഫലത്തിൽ ഉൾപ്പെടുത്തിയിട്ടുള്ളൂ. 'ഡേവിഡ്' എന്ന ഉപഭോക്താവിന് (customer_id 106) ഓർഡറുകളൊന്നും ഇല്ലാത്തതിനാൽ അദ്ദേഹത്തെ ഒഴിവാക്കിയിരിക്കുന്നു.
ഔട്ടർ ജോയിൻ (Outer Join / Full Outer Join)
ഒരു ഔട്ടർ ജോയിൻ, പൊരുത്തമില്ലാത്ത വരികൾ ഉൾപ്പെടെ രണ്ട് ഡാറ്റാഫ്രെയിമുകളിൽ നിന്നുമുള്ള എല്ലാ വരികളും നൽകുന്നു. ഒരു വരിക്ക് മറ്റേ ഡാറ്റാഫ്രെയിമിൽ പൊരുത്തമില്ലെങ്കിൽ, അതിന് അനുയോജ്യമായ കോളങ്ങളിൽ `NaN` (Not a Number) മൂല്യങ്ങൾ അടങ്ങിയിരിക്കും.
ഉദാഹരണം:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
ഔട്ടർ ജോയിനിൽ എല്ലാ ഉപഭോക്താക്കളെയും എല്ലാ ഓർഡറുകളെയും ഉൾപ്പെടുത്തിയിരിക്കുന്നു. 104, 105 ഉപഭോക്താക്കൾക്ക് ഓർഡറുകളുണ്ട്, പക്ഷേ ഉപഭോക്തൃ വിവരങ്ങളില്ല. അതുപോലെ, 106 എന്ന ഉപഭോക്താവിന് വിവരങ്ങളുണ്ട്, പക്ഷേ ഓർഡറുകളില്ല. കാണാതായ മൂല്യങ്ങളെ `NaN` ആയി പ്രതിനിധീകരിക്കുന്നു.
ലെഫ്റ്റ് ജോയിൻ (Left Join)
ഒരു ലെഫ്റ്റ് ജോയിൻ ഇടത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള എല്ലാ വരികളും വലത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള പൊരുത്തമുള്ള വരികളും നൽകുന്നു. ഇടത് ഡാറ്റാഫ്രെയിമിലെ ഒരു വരിക്ക് വലത് ഡാറ്റാഫ്രെയിമിൽ പൊരുത്തമില്ലെങ്കിൽ, വലത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള അനുബന്ധ കോളങ്ങളിൽ `NaN` മൂല്യങ്ങൾ ഉണ്ടാകും.
ഉദാഹരണം:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
ലെഫ്റ്റ് ജോയിൻ `df_orders`-ൽ നിന്നുള്ള എല്ലാ ഓർഡറുകളും ഉൾക്കൊള്ളുന്നു. 104, 105 ഉപഭോക്താക്കൾക്ക് ഓർഡറുകളുണ്ട്, എന്നാൽ ഉപഭോക്തൃ വിവരങ്ങളില്ല. അതിനാൽ ആ ഓർഡറുകൾക്ക് `customer_name`, `country` കോളങ്ങൾ `NaN` ആണ്.
റൈറ്റ് ജോയിൻ (Right Join)
ഒരു റൈറ്റ് ജോയിൻ വലത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള എല്ലാ വരികളും ഇടത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള പൊരുത്തമുള്ള വരികളും നൽകുന്നു. വലത് ഡാറ്റാഫ്രെയിമിലെ ഒരു വരിക്ക് ഇടത് ഡാറ്റാഫ്രെയിമിൽ പൊരുത്തമില്ലെങ്കിൽ, ഇടത് ഡാറ്റാഫ്രെയിമിൽ നിന്നുള്ള അനുബന്ധ കോളങ്ങളിൽ `NaN` മൂല്യങ്ങൾ ഉണ്ടാകും.
ഉദാഹരണം:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
റൈറ്റ് ജോയിൻ `df_customers`-ൽ നിന്നുള്ള എല്ലാ ഉപഭോക്താക്കളെയും ഉൾക്കൊള്ളുന്നു. 106-ാമത്തെ ഉപഭോക്താവിന് വിവരങ്ങളുണ്ട്, പക്ഷേ ഓർഡറുകളില്ല. അതിനാൽ ആ ഉപഭോക്താവിനുള്ള `order_id`, `product_id`, `quantity` എന്നീ കോളങ്ങൾ `NaN` ആണ്.
`df.join()` ഉപയോഗിച്ച് ഡാറ്റാഫ്രെയിം യോജിപ്പിക്കൽ
`df.join()` മെത്തേഡ് പ്രധാനമായും ഡാറ്റാഫ്രെയിമുകളെ അവയുടെ ഇൻഡെക്സുകൾ അടിസ്ഥാനമാക്കി യോജിപ്പിക്കാനാണ് ഉപയോഗിക്കുന്നത്. ഇത് കോളങ്ങളെ അടിസ്ഥാനമാക്കി യോജിപ്പിക്കാനും ഉപയോഗിക്കാം, എന്നാൽ കോളങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ള ജോയിനുകൾക്ക് `pd.merge()` ഉപയോഗിക്കുന്നതാണ് കൂടുതൽ സൗകര്യം.
സിൻടാക്സ്
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
പാരാമീറ്ററുകൾ
- other: യോജിപ്പിക്കേണ്ട മറ്റൊരു ഡാറ്റാഫ്രെയിം.
- on: യോജിപ്പിക്കേണ്ട കോളത്തിന്റെ പേര്. ഇൻഡെക്സ് ജോയിൻ കീയായി ഉപയോഗിക്കുന്നില്ലെങ്കിൽ ഇത് നൽകണം.
- how: ഇടത്, വലത് സെറ്റുകളുടെ പ്രവർത്തനം എങ്ങനെ കൈകാര്യം ചെയ്യണം. ഡിഫോൾട്ട് 'left' ആണ്.
- lsuffix: ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങളുടെ പേരുകൾ മാറ്റാൻ ഇടത് ഡാറ്റാഫ്രെയിമിൽ ഉപയോഗിക്കേണ്ട സഫിക്സ്.
- rsuffix: ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങളുടെ പേരുകൾ മാറ്റാൻ വലത് ഡാറ്റാഫ്രെയിമിൽ ഉപയോഗിക്കേണ്ട സഫിക്സ്.
- sort: ജോയിൻ കീകൾ ഉപയോഗിച്ച് ഫലമായുണ്ടാകുന്ന ഡാറ്റാഫ്രെയിം അക്ഷരമാലാക്രമത്തിൽ അടുക്കുക. ഡിഫോൾട്ട് False ആണ്.
ഇൻഡെക്സിൽ യോജിപ്പിക്കൽ
ഇൻഡെക്സിൽ യോജിപ്പിക്കുമ്പോൾ, `on` പാരാമീറ്റർ ഉപയോഗിക്കുന്നില്ല.
ഉദാഹരണം:
# DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')
# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
ഔട്ട്പുട്ട്:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
ഈ ഉദാഹരണത്തിൽ, `join()` മെത്തേഡ് ഉപയോഗിച്ച് ഇൻഡെക്സിൽ (`customer_id`) ഒരു ലെഫ്റ്റ് ജോയിൻ നടത്തുന്നു. ഫലം `pd.merge()` ഉപയോഗിച്ചുള്ള ലെഫ്റ്റ് ജോയിനിന് സമാനമാണ്, പക്ഷേ ഇവിടെ ജോയിൻ ഒരു കോളത്തെ അടിസ്ഥാനമാക്കിയല്ല, ഇൻഡെക്സിനെ അടിസ്ഥാനമാക്കിയാണ്.
കോളത്തിൽ യോജിപ്പിക്കൽ
`df.join()` ഉപയോഗിച്ച് ഒരു കോളത്തിൽ യോജിപ്പിക്കാൻ, നിങ്ങൾ `on` പാരാമീറ്റർ വ്യക്തമാക്കേണ്ടതുണ്ട്.
ഉദാഹരണം:
# Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
ഈ ഉദാഹരണം `customer_id` കോളം ഉപയോഗിച്ച് `df_orders`-നെയും `df_customers`-നെയും യോജിപ്പിക്കുന്നത് കാണിക്കുന്നു. ശ്രദ്ധിക്കുക, ജോയിൻ ചെയ്യുന്നതിന് മുമ്പ് `df_customers`-ൽ `customer_id` ഇൻഡെക്സായി സജ്ജീകരിച്ചിരിക്കുന്നു.
ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങൾ കൈകാര്യം ചെയ്യൽ
ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുകയോ യോജിപ്പിക്കുകയോ ചെയ്യുമ്പോൾ, ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങളുടെ പേരുകൾ (രണ്ട് ഡാറ്റാഫ്രെയിമുകളിലും ഒരേ പേരുള്ള കോളങ്ങൾ) സാധാരണയായി കാണാറുണ്ട്. ഈ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ `pd.merge()`-ൽ `suffixes` പാരാമീറ്ററും `df.join()`-ൽ `lsuffix`, `rsuffix` പാരാമീറ്ററുകളും പാൻഡാസ് നൽകുന്നു.
`pd.merge()`-ൽ `suffixes` ഉപയോഗിക്കുന്നത്
`suffixes` പാരാമീറ്റർ ഉപയോഗിച്ച് ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങളുടെ പേരുകൾക്ക് പിന്നിൽ ചേർക്കാൻ സഫിക്സുകൾ വ്യക്തമാക്കാം, അതുവഴി അവയെ തിരിച്ചറിയാൻ സാധിക്കും.
ഉദാഹരണം:
# DataFrame 1: Product Information
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
ഔട്ട്പുട്ട്:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
ഈ ഉദാഹരണത്തിൽ, `product_name`, `price` എന്നീ കോളങ്ങൾ രണ്ട് ഡാറ്റാഫ്രെയിമുകളിലും ഉണ്ട്. `suffixes` പാരാമീറ്റർ ഉപയോഗിച്ച് ഇടത്, വലത് ഡാറ്റാഫ്രെയിമുകളിലെ കോളങ്ങളെ വേർതിരിച്ചറിയാൻ `_old`, `_new` എന്നീ സഫിക്സുകൾ ചേർക്കുന്നു.
`df.join()`-ൽ `lsuffix`, `rsuffix` ഉപയോഗിക്കുന്നത്
`lsuffix`, `rsuffix` എന്നീ പാരാമീറ്ററുകൾ `df.join()`-നായി സമാനമായ പ്രവർത്തനം നൽകുന്നു. `lsuffix` ഇടത് ഡാറ്റാഫ്രെയിമിലെ ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങൾക്കും `rsuffix` വലത് ഡാറ്റാഫ്രെയിമിലെ ഓവർലാപ്പുചെയ്യുന്ന കോളങ്ങൾക്കും സഫിക്സ് ചേർക്കുന്നു.
ഉദാഹരണം:
# Join with lsuffix and rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
ഔട്ട്പുട്ട്:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗങ്ങളും
ഡാറ്റാ അനാലിസിസിലെ വിവിധ സാഹചര്യങ്ങളിൽ ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതും യോജിപ്പിക്കുന്നതും വ്യാപകമായി ഉപയോഗിക്കുന്നു. ചില പ്രായോഗിക ഉദാഹരണങ്ങൾ താഴെ നൽകുന്നു:
വിൽപ്പന ഡാറ്റയും ഉൽപ്പന്ന വിവരങ്ങളും സംയോജിപ്പിക്കുന്നു
വിൽപ്പന ഡാറ്റയും ഉൽപ്പന്ന വിവരങ്ങളും സംയോജിപ്പിക്കുന്നത് ഒരു സാധാരണ ഉപയോഗമാണ്. നിങ്ങളുടെ പക്കൽ വിൽപ്പന ഇടപാടുകൾ അടങ്ങിയ ഒരു ഡാറ്റാഫ്രെയിമും ഉൽപ്പന്ന വിശദാംശങ്ങൾ അടങ്ങിയ മറ്റൊരു ഡാറ്റാഫ്രെയിമും ഉണ്ടെന്ന് കരുതുക. ഈ ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിച്ച് വിൽപ്പന ഡാറ്റയെ കൂടുതൽ വിവരങ്ങളാൽ സമ്പന്നമാക്കാം.
ഉദാഹരണം:
# Sales Transactions Data
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Product Information Data
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
ഔട്ട്പുട്ട്:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
ലഭിച്ച `df_sales_enriched` എന്ന ഡാറ്റാഫ്രെയിമിൽ വിൽപ്പന ഇടപാടുകളും അവയുടെ ഉൽപ്പന്ന വിവരങ്ങളും അടങ്ങിയിരിക്കുന്നു. ഇത് വിൽപ്പനയുടെ പ്രവണതകളും ഉൽപ്പന്നങ്ങളുടെ പ്രകടനവും കൂടുതൽ വിശദമായി വിശകലനം ചെയ്യാൻ സഹായിക്കുന്നു.
ഉപഭോക്തൃ ഡാറ്റയും ജനസംഖ്യാപരമായ വിവരങ്ങളും സംയോജിപ്പിക്കുന്നു
ഉപഭോക്തൃ ഡാറ്റയും ജനസംഖ്യാപരമായ വിവരങ്ങളും സംയോജിപ്പിക്കുന്നത് മറ്റൊരു സാധാരണ ഉപയോഗമാണ്. ഇത് ജനസംഖ്യാപരമായ ഘടകങ്ങളെ അടിസ്ഥാനമാക്കി ഉപഭോക്താക്കളുടെ പെരുമാറ്റം വിശകലനം ചെയ്യാൻ സഹായിക്കുന്നു.
ഉദാഹരണം:
# Customer Data
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demographic Information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
ഔട്ട്പുട്ട്:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
ലഭിച്ച `df_customer_demographics` എന്ന ഡാറ്റാഫ്രെയിമിൽ ഉപഭോക്തൃ ഡാറ്റയും അവരുടെ നഗരങ്ങളിലെ ജനസംഖ്യാപരമായ വിവരങ്ങളും അടങ്ങിയിരിക്കുന്നു. ഇത് നഗരങ്ങളിലെ ജനസംഖ്യാപരമായ വിവരങ്ങളെ അടിസ്ഥാനമാക്കി ഉപഭോക്താക്കളുടെ പെരുമാറ്റം വിശകലനം ചെയ്യാൻ സഹായിക്കുന്നു.
ആഗോള വിതരണ ശൃംഖലയുടെ ഡാറ്റ വിശകലനം ചെയ്യൽ
വിവിധ പട്ടികകളിലായി ചിതറിക്കിടക്കുന്ന ആഗോള വിതരണ ശൃംഖലയുടെ ഡാറ്റ വിശകലനം ചെയ്യുന്നതിന് പാൻഡാസ് മെർജിംഗ് വളരെ വിലപ്പെട്ടതാണ്. ഉദാഹരണത്തിന്, വിതരണക്കാരുടെ ഡാറ്റ, ഷിപ്പിംഗ് വിവരങ്ങൾ, വിൽപ്പന കണക്കുകൾ എന്നിവ ബന്ധിപ്പിക്കുന്നതിലൂടെ തടസ്സങ്ങൾ കണ്ടെത്താനും ലോജിസ്റ്റിക്സ് ഒപ്റ്റിമൈസ് ചെയ്യാനും കഴിയും.
ഉദാഹരണം:
# Supplier Data
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Shipping Data
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
ഔട്ട്പുട്ട്:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
അഡ്വാൻസ്ഡ് മെർജിംഗ് ടെക്നിക്കുകൾ
ഒന്നിലധികം കോളങ്ങളിൽ ലയിപ്പിക്കൽ
കോളങ്ങളുടെ പേരുകളുടെ ഒരു ലിസ്റ്റ് `on` പാരാമീറ്ററിലേക്ക് നൽകി ഒന്നിലധികം കോളങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കാം.
ഉദാഹരണം:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
ഔട്ട്പുട്ട്:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
വ്യത്യസ്ത കോളം പേരുകൾ ഉപയോഗിച്ച് ലയിപ്പിക്കൽ
രണ്ട് ഡാറ്റാഫ്രെയിമുകളിലും ജോയിൻ കോളങ്ങൾക്ക് വ്യത്യസ്ത പേരുകളാണെങ്കിൽ, ലയിപ്പിക്കുന്നതിനായി ഉപയോഗിക്കേണ്ട കോളങ്ങളുടെ പേരുകൾ വ്യക്തമാക്കാൻ `left_on`, `right_on` പാരാമീറ്ററുകൾ ഉപയോഗിക്കാം.
ഉദാഹരണം:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
ഔട്ട്പുട്ട്:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
മെർജ് അനാലിസിസിനായി `indicator` ഉപയോഗിക്കുന്നത്
`pd.merge()`-ലെ `indicator` പാരാമീറ്റർ, ലഭിക്കുന്ന ഡാറ്റാഫ്രെയിമിലേക്ക് `_merge` എന്നൊരു കോളം ചേർക്കുന്നു, ഇത് ഓരോ വരിയുടെയും ഉറവിടം സൂചിപ്പിക്കുന്നു. ഏതൊക്കെ വരികൾ പൊരുത്തപ്പെട്ടു, ഏതൊക്കെ പൊരുത്തപ്പെട്ടില്ല എന്ന് മനസ്സിലാക്കാൻ ഇത് ഉപയോഗപ്രദമാണ്.
ഉദാഹരണം:
# Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
ഔട്ട്പുട്ട്:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
`_merge` കോളം സൂചിപ്പിക്കുന്നത് വരി രണ്ട് ഡാറ്റാഫ്രെയിമുകളിൽ നിന്നാണോ (`both`), അതോ ഇടത് ഡാറ്റാഫ്രെയിമിൽ നിന്ന് മാത്രമാണോ (`left_only`), അതോ വലത് ഡാറ്റാഫ്രെയിമിൽ നിന്ന് മാത്രമാണോ (`right_only`) എന്നാണ്.
മെർജ് തരങ്ങൾ സാധൂകരിക്കൽ
`validate` പാരാമീറ്റർ, മെർജ് പ്രവർത്തനം ഡാറ്റാഫ്രെയിമുകൾ തമ്മിലുള്ള പ്രതീക്ഷിക്കുന്ന ബന്ധത്തിന്റെ തരങ്ങളുമായി ('one_to_one', 'one_to_many' പോലുള്ളവ) യോജിക്കുന്നുണ്ടോ എന്ന് ഉറപ്പാക്കുന്നു. ഇത് ഡാറ്റയിലെ പൊരുത്തക്കേടുകളും പിശകുകളും തടയാൻ സഹായിക്കുന്നു.
ഉദാഹരണം:
# Example with one-to-one validation
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
മെർജ് നിർദ്ദിഷ്ട സാധൂകരണത്തെ ലംഘിക്കുകയാണെങ്കിൽ (ഉദാഹരണത്തിന്, 'one_to_one' വ്യക്തമാക്കുമ്പോൾ ഒരു many-to-one ബന്ധം ഉണ്ടായാൽ), ഒരു `MergeError` ഉണ്ടാകും, ഇത് ഡാറ്റയുടെ സമഗ്രതയിലെ പ്രശ്നങ്ങളെക്കുറിച്ച് നിങ്ങളെ അറിയിക്കും.
പ്രകടനവുമായി ബന്ധപ്പെട്ട പരിഗണനകൾ
ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതും യോജിപ്പിക്കുന്നതും, പ്രത്യേകിച്ച് വലിയ ഡാറ്റാസെറ്റുകളിൽ, കമ്പ്യൂട്ടേഷണലി എക്സ്പെൻസീവ് ആകാം. പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനുള്ള ചില നുറുങ്ങുകൾ താഴെ നൽകുന്നു:
- ഉചിതമായ ജോയിൻ തരം ഉപയോഗിക്കുക: ശരിയായ ജോയിൻ തരം തിരഞ്ഞെടുക്കുന്നത് പ്രകടനത്തെ കാര്യമായി ബാധിക്കും. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് പൊരുത്തമുള്ള വരികൾ മാത്രം മതിയെങ്കിൽ, ഒരു ഇന്നർ ജോയിൻ ഉപയോഗിക്കുക.
- ജോയിൻ കോളങ്ങൾ ഇൻഡെക്സ് ചെയ്യുക: ജോയിൻ കോളങ്ങൾ ഇൻഡെക്സ് ചെയ്യുന്നത് ലയിപ്പിക്കൽ പ്രക്രിയ വേഗത്തിലാക്കും.
- ഉചിതമായ ഡാറ്റാ തരങ്ങൾ ഉപയോഗിക്കുക: ജോയിൻ കോളങ്ങൾക്ക് അനുയോജ്യമായ ഡാറ്റാ തരങ്ങൾ ഉണ്ടെന്ന് ഉറപ്പാക്കുക.
- അനാവശ്യമായ കോപ്പികൾ ഒഴിവാക്കുക: ഡാറ്റയുടെ അനാവശ്യമായ കോപ്പികൾ ഉണ്ടാക്കുന്നത് ഒഴിവാക്കാൻ `pd.merge()`, `df.join()` എന്നിവയിൽ `copy=False` എന്ന് സജ്ജീകരിക്കുക.
ഉപസംഹാരം
ഡാറ്റാ അനാലിസിസിലെ അടിസ്ഥാന പ്രവർത്തനങ്ങളാണ് ഡാറ്റാഫ്രെയിമുകൾ ലയിപ്പിക്കുന്നതും യോജിപ്പിക്കുന്നതും. വിവിധ ജോയിൻ തരങ്ങളും ടെക്നിക്കുകളും മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് വിവിധ സ്രോതസ്സുകളിൽ നിന്നുള്ള ഡാറ്റ ഫലപ്രദമായി സംയോജിപ്പിക്കാനും വിശകലനം ചെയ്യാനും കഴിയും, ഇത് വിലപ്പെട്ട ഉൾക്കാഴ്ചകൾ നൽകുകയും അറിവോടെയുള്ള തീരുമാനങ്ങൾ എടുക്കാൻ സഹായിക്കുകയും ചെയ്യും. വിൽപ്പന ഡാറ്റയെ ഉൽപ്പന്ന വിവരങ്ങളുമായി സംയോജിപ്പിക്കുന്നത് മുതൽ ആഗോള വിതരണ ശൃംഖലകൾ വിശകലനം ചെയ്യുന്നത് വരെ, ഈ ടെക്നിക്കുകളിൽ പ്രാവീണ്യം നേടുന്നത് സങ്കീർണ്ണമായ ഡാറ്റാ മാനിപുലേഷൻ ജോലികൾ ആത്മവിശ്വാസത്തോടെ നേരിടാൻ നിങ്ങളെ പ്രാപ്തരാക്കും. വലിയ ഡാറ്റാസെറ്റുകളുമായി പ്രവർത്തിക്കുമ്പോൾ പ്രകടനത്തെക്കുറിച്ചുള്ള കാര്യങ്ങൾ പരിഗണിക്കുക, കൂടാതെ കൂടുതൽ ശക്തവും ഉൾക്കാഴ്ചയുള്ളതുമായ വിശകലനത്തിനായി `indicator`, `validate` പോലുള്ള അഡ്വാൻസ്ഡ് ഫീച്ചറുകൾ പ്രയോജനപ്പെടുത്തുക.