В чем разница между объединением и объединением в Пандах?

Ответ 1

Я всегда использую join по индексам:

import pandas as pd
left = pd.DataFrame({'key': ['foo', 'bar'], 'val': [1, 2]}).set_index('key')
right = pd.DataFrame({'key': ['foo', 'bar'], 'val': [4, 5]}).set_index('key')
left.join(right, lsuffix='_l', rsuffix='_r')

     val_l  val_r
key            
foo      1      4
bar      2      5

Такую же функциональность можно использовать, используя merge в следующих столбцах:

left = pd.DataFrame({'key': ['foo', 'bar'], 'val': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'bar'], 'val': [4, 5]})
left.merge(right, on=('key'), suffixes=('_l', '_r'))

   key  val_l  val_r
0  foo      1      4
1  bar      2      5

Ответ 2

pandas.merge() - основная функция, используемая для всех pandas.merge() слияния/объединения.

DataFrames предоставляют pandas.DataFrame.merge() и pandas.DataFrame.join() как удобный способ доступа к возможностям pandas.merge(). Например, df1.merge(right=df2,...) эквивалентно pandas.merge(left=df1, right=df2,...).

Это основные различия между df.join() и df.merge():

1. поиск в правой таблице: df1.join(df2) всегда соединяется через индекс df2, но df1.merge(df2) может присоединяться к одному или нескольким столбцам df2 (по умолчанию) или к индексу df2 (с помощью right_index=True),
2. поиск по левой таблице: по умолчанию df1.join(df2) использует индекс df1 а df1.merge(df2) использует столбец df1. Это можно переопределить, указав df1.join(df2, on=key_or_keys) или df1.merge(df2, left_index=True).
3. left vs inner join: df1.join(df2) делает левое соединение по умолчанию (сохраняет все строки df1), но df.merge выполняет внутреннее соединение по умолчанию (возвращает только соответствующие строки df1 и df2).

Итак, общий подход заключается в использовании pandas.merge(df1, df2) или df1.merge(df2). Но для ряда распространенных ситуаций (сохраняя все строки df1 и присоединяясь к индексу в df2), вы можете сохранить некоторую типизацию, используя вместо этого df1.join(df2).

Некоторые замечания по этим вопросам из документации по адресу http://pandas.pydata.org/pandas-docs/stable/merging.html#database-style-dataframe-joining-merging:

merge - это функция в пространстве имен pandas, и она также доступна как метод экземпляра DataFrame, при этом вызывающий DataFrame неявно считается левым объектом в соединении.

Связанный с DataFrame.join метод DataFrame.join использует merge внутри для индексов по индексу и индексам на столбцах (-ов), но по умолчанию по умолчанию объединяется по индексам, а не пытается присоединиться к общим столбцам (поведение по умолчанию для merge). Если вы присоединяетесь к индексу, вы можете использовать DataFrame.join чтобы сэкономить некоторую типизацию.

...

Эти два вызова функций полностью эквивалентны:

left.join(right, on=key_or_keys)
pd.merge(left, right, left_on=key_or_keys, right_index=True, how='left', sort=False)

Ответ 3

Я считаю, что join() - это просто метод удобства. Вместо этого попробуйте df1.merge(df2), что позволяет указать left_on и right_on:

In [30]: left.merge(right, left_on="key1", right_on="key2")
Out[30]: 
  key1  lval key2  rval
0  foo     1  foo     4
1  bar     2  bar     5

Ответ 4

http://pandas.pydata.org/pandas-docs/stable/merging.html#brief-primer-on-merge-methods-relational-algebra

pandas предоставляет единственную функцию, объединяющую в качестве точки входа для всех стандартных операций объединения базы данных между объектами DataFrame:

merge (left, right, how = 'inner', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = True, suffixes = ('_ x', '_y'), copy = True, индикатор = False)

А также:

DataFrame.join - удобный способ объединения столбцов двух потенциально разностно-индексированных DataFrames в единый результат DataFrame. Вот очень простой пример: выравнивание данных здесь относится к индексам (метки строк). Такое же поведение может быть достигнуто с помощью слияния плюс дополнительные аргументы, инструктирующие его использовать индексы: result = pd.merge(left, right, left_index = True, right_index = True, how = 'outer')

Ответ 5

Одно из отличий состоит в том, что merge создает новый индекс, а join сохраняет левый боковой индекс.

Например:

import pandas as pd

df1 = pd.DataFrame({'org_index': [101, 102, 103, 104],
                    'date': [201801, 201801, 201802, 201802],
                    'val': [1, 2, 3, 4]}, index=[101, 102, 103, 104])
df1

       date  org_index  val
101  201801        101    1
102  201801        102    2
103  201802        103    3
104  201802        104    4

-

df2 = pd.DataFrame({'date': [201801, 201802], 'dateval': ['A', 'B']}).set_index('date')
df2

       dateval
date          
201801       A
201802       B

-

df1.merge(df2, on='date')

     date  org_index  val dateval
0  201801        101    1       A
1  201801        102    2       A
2  201802        103    3       B
3  201802        104    4       B

-

df1.join(df2, on='date')
       date  org_index  val dateval
101  201801        101    1       A
102  201801        102    2       A
103  201802        103    3       B
104  201802        104    4       B