પાયથોન પાંડાસમાં ડેટાફ્રેમ્સને મર્જ અને જોઇન કરવા માટેની એક વ્યાપક માર્ગદર્શિકા, જેમાં વૈશ્વિક ડેટા એનાલિસિસ માટે વ્યવહારુ ઉદાહરણો સાથે ઇનર, આઉટર, લેફ્ટ અને રાઇટ જોઇન જેવી વિવિધ વ્યૂહરચનાઓનો સમાવેશ થાય છે.
પાયથોન પાંડાસ મર્જિંગ: ડેટા એનાલિસિસ માટે ડેટાફ્રેમ જોઇનિંગ સ્ટ્રેટેજીમાં નિપુણતા
ડેટા મેનિપ્યુલેશન એ ડેટા એનાલિસિસનું એક નિર્ણાયક પાસું છે, અને પાયથોનમાં પાંડાસ લાઇબ્રેરી આ હેતુ માટે શક્તિશાળી સાધનો પૂરા પાડે છે. આ સાધનોમાં, ડેટાફ્રેમ્સને મર્જ અને જોઇન કરવું એ સામાન્ય કોલમ્સ અથવા ઇન્ડેક્સના આધારે ડેટાસેટ્સને જોડવા માટેની આવશ્યક કામગીરી છે. આ વ્યાપક માર્ગદર્શિકા પાંડાસમાં વિવિધ ડેટાફ્રેમ જોઇનિંગ વ્યૂહરચનાઓનું અન્વેષણ કરે છે, જે તમને વિવિધ સ્રોતોમાંથી ડેટાને અસરકારક રીતે જોડવા અને તેનું વિશ્લેષણ કરવા માટેના જ્ઞાનથી સજ્જ કરે છે.
ડેટાફ્રેમ મર્જિંગ અને જોઇનિંગને સમજવું
ડેટાફ્રેમ્સને મર્જ અને જોઇન કરવામાં બે કે તેથી વધુ ડેટાફ્રેમ્સને એક જ ડેટાફ્રેમમાં વહેંચાયેલ કોલમ અથવા ઇન્ડેક્સના આધારે જોડવાનો સમાવેશ થાય છે. `merge` અને `join` વચ્ચેનો મુખ્ય તફાવત એ છે કે `merge` એ પાંડાસ લાઇબ્રેરીનું એક ફંક્શન છે અને સામાન્ય રીતે કોલમ્સ પર ડેટાફ્રેમ્સને જોડે છે, જ્યારે `join` એ ડેટાફ્રેમ પદ્ધતિ છે જે મુખ્યત્વે ઇન્ડેક્સ પર ડેટાફ્રેમ્સને જોડે છે, જોકે તેનો ઉપયોગ કોલમ્સ સાથે પણ થઈ શકે છે.
મુખ્ય ખ્યાલો
- ડેટાફ્રેમ્સ (DataFrames): સંભવિતપણે વિવિધ પ્રકારના કોલમ્સ સાથે દ્વિ-પરિમાણીય લેબલવાળી ડેટા સ્ટ્રક્ચર્સ.
- સામાન્ય કોલમ્સ/ઇન્ડેક્સ (Common Columns/Indices): કોલમ્સ અથવા ઇન્ડેક્સ જે ડેટાફ્રેમ્સમાં સમાન નામ અને ડેટા પ્રકાર ધરાવે છે, જે મર્જિંગ/જોઇનિંગ માટેના આધાર તરીકે કામ કરે છે.
- જોઇનના પ્રકારો (Join Types): મર્જિંગ/જોઇનિંગ પ્રક્રિયા દરમિયાન મેળ ન ખાતી પંક્તિઓને હેન્ડલ કરવા માટેની વિવિધ વ્યૂહરચનાઓ, જેમાં ઇનર, આઉટર, લેફ્ટ અને રાઇટ જોઇનનો સમાવેશ થાય છે.
`pd.merge()` સાથે ડેટાફ્રેમ મર્જિંગ
`pd.merge()` ફંક્શન કોલમ્સના આધારે ડેટાફ્રેમ્સને મર્જ કરવા માટેનું પ્રાથમિક સાધન છે. તે એક અથવા વધુ સામાન્ય કોલમ્સના આધારે ડેટાને જોડવાની એક લવચીક રીત પ્રદાન કરે છે.
સિન્ટેક્સ (Syntax)
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)
પેરામીટર્સ (Parameters)
- 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` કોલમના આધારે જોડે છે. ફક્ત તે જ ગ્રાહકો કે જેમણે ઓર્ડર આપ્યા છે તે પરિણામમાં શામેલ છે. ગ્રાહક 'David' (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()` નો ઉપયોગ કરવો વધુ અનુકૂળ છે.
સિન્ટેક્સ (Syntax)
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
પેરામીટર્સ (Parameters)
- other: જોડવા માટેનો અન્ય ડેટાફ્રેમ.
- on: જે કોલમ પર જોડાણ કરવું હોય તેનું નામ. જો ઇન્ડેક્સનો ઉપયોગ જોઇન કી તરીકે ન કરવામાં આવ્યો હોય તો આ પાસ કરવું આવશ્યક છે.
- how: ડાબા અને જમણા સેટની કામગીરીને કેવી રીતે હેન્ડલ કરવી. ડિફોલ્ટ 'left' છે.
- lsuffix: ઓવરલેપ થતા કોલમ નામોને ઓવરરાઇડ કરવા માટે ડાબા ડેટાફ્રેમમાંથી ઉપયોગ કરવાનો પ્રત્યય.
- rsuffix: ઓવરલેપ થતા કોલમ નામોને ઓવરરાઇડ કરવા માટે જમણા ડેટાફ્રેમમાંથી ઉપયોગ કરવાનો પ્રત્યય.
- sort: પરિણામી ડેટાફ્રેમને જોઇન કી દ્વારા લેક્સિકોગ્રાફિકલી સૉર્ટ કરો. ડિફોલ્ટ False છે.
ઇન્ડેક્સ પર જોડાણ (Joining on Index)
ઇન્ડેક્સ પર જોડાણ કરતી વખતે, `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()` નો ઉપયોગ કરીને લેફ્ટ જોઇન જેવું જ છે, પરંતુ જોડાણ કોલમને બદલે ઇન્ડેક્સ પર આધારિત છે.
કોલમ પર જોડાણ (Joining on Column)
`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
આ ઉદાહરણ `df_orders` ને `df_customers` સાથે `customer_id` કોલમનો ઉપયોગ કરીને જોડવાનું દર્શાવે છે. નોંધ લો કે જોડાણ કરતા પહેલા `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` પેરામીટર્સ જેવી અદ્યતન સુવિધાઓનો લાભ લો.