Разница (я) между merge () и concat () в пандах

89

В чем существенное различие между pd.DataFrame.merge()и pd.concat()?

Пока что это то, что я обнаружил, прокомментируйте, пожалуйста, насколько полно и точно я понимаю:

  • .merge()может использовать только столбцы (плюс индексы строк) и семантически подходит для операций в стиле базы данных. .concat()может использоваться с любой осью, используя только индексы, и дает возможность добавления иерархического индекса.

  • Между прочим, это обеспечивает следующую избыточность: оба могут объединять два фрейма данных, используя индексы строк.

  • pd.DataFrame.join() просто предлагает сокращение для подмножества вариантов использования .merge()

(Pandas отлично подходит для решения очень широкого спектра сценариев использования в анализе данных. Может быть немного сложно изучить документацию, чтобы выяснить, как лучше всего выполнить конкретную задачу.)

python pandas join merge concat Музыкальная подвеска
источник
3
Также по теме: stackoverflow.com/a/37891437/1972495 обсуждение вокруг .merge()и .join().
WindChimes 07
2
При слиянии, соединении и объединении я считаю этот ответ очень ясным относительно того, как все они могут использоваться для выполнения одного и того же действия (они кажутся просто альтернативным интерфейсом для одной и той же функциональности). Благодаря вашему вопросу (и ответу, который вы указываете в комментарии) я наконец понимаю, как связаны слияние и присоединение. Мне все еще неясно, использует ли concat другую реализацию или нет (думаю, мне придется посмотреть исходный код ...)
pietroppeter

Ответы:

79

Разница очень высокого уровня заключается в том, что merge()используется для объединения двух (или более) фреймов данных на основе значений общих столбцов (индексы также могут использоваться, использовать left_index=Trueи / или right_index=True) и concat()используется для добавления одного (или нескольких) фреймов данных в один ниже другого (или сбоку, в зависимости от того, установлен ли axisпараметр на 0 или 1).

join()используется для объединения 2 фреймов данных на основе индекса; вместо использования merge()с опцией, которую left_index=Trueмы можем использовать join().

Например:

df1 = pd.DataFrame({'Key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})

df1:
   Key  data1
0   b   0
1   b   1
2   a   2
3   c   3
4   a   4
5   a   5
6   b   6

df2 = pd.DataFrame({'Key': ['a', 'b', 'd'], 'data2': range(3)})

df2:
    Key data2
0   a   0
1   b   1
2   d   2

#Merge
# The 2 dataframes are merged on the basis of values in column "Key" as it is 
# a common column in 2 dataframes

pd.merge(df1, df2)

   Key data1 data2
0   b    0    1
1   b    1    1
2   b    6    1
3   a    2    0
4   a    4    0
5   a    5    0

#Concat
# df2 dataframe is appended at the bottom of df1 

pd.concat([df1, df2])

   Key data1 data2
0   b   0     NaN
1   b   1     NaN
2   a   2     NaN
3   c   3     NaN
4   a   4     NaN
5   a   5     NaN
6   b   6     NaN
0   a   Nan   0
1   b   Nan   1
2   d   Nan   2
Абхишек Савант
источник
Итак, это означает, что аргумент howв mergeдействии и означает совершенно иное, чем то, в чем он заключается concat?
Хемант Бакая
11

pd.concatпринимает в Iterableкачестве аргумента. Следовательно, он не может DataFrameнапрямую принимать s в качестве аргумента. Также Dimensions из DataFrameдолжны совпадать по оси при конкатенации.

pd.mergeможет принимать DataFrames в качестве аргумента и используется для объединения двух DataFrames с одинаковыми столбцами или индексом, что невозможно сделать, pd.concatпоскольку он будет отображать повторяющийся столбец в DataFrame.

В то время как join можно использовать для объединения двух DataFrames с разными индексами.

Пиюш Малхотра Нова_Аутло
источник
7
Мне нравится этот ответ, потому что в нем говорится, что размеры должны совпадать при конкатенации. concatэто не что иное, как приклеивание нескольких фреймов данных поверх / рядом друг с другом. Он не осведомлен о содержании в том смысле, что он просто покажет один и тот же столбец дважды. В то время как mergeфактически объединяет столбцы, когда они одинаковы.
jorijnsmit
3
Думаю, это неправда. Даже ответ выше (от @Abhishek Sawant) дает пример того, concatгде размеры не совпадают.
michcio1234
7

В настоящее время я пытаюсь понять существенные различия между pd.DataFrame.merge()и pd.concat().

Хороший вопрос. Главное отличие:

pd.concat работает по обеим осям.

Другое отличие состоит в том, что у pd.concatнего есть только внутренние соединения по умолчанию и только внешние соединения, тогда как pd.DataFrame.merge()есть левые , правые , внешние и внутренние соединения по умолчанию .

Третье заметное другое отличие: pd.DataFrame.merge()есть возможность устанавливать суффиксы столбцов при объединении столбцов с одинаковыми именами, в то время как pd.concatэто невозможно.

По pd.concatумолчанию вы можете складывать строки из нескольких фреймов данных ( axis=0), а когда вы устанавливаете, axis=1вы имитируете pd.DataFrame.merge()функцию.

Несколько полезных примеров pd.concat:

df2=pd.concat([df]*2, ignore_index=True) #double the rows of a dataframe

df2=pd.concat([df, df.iloc[[0]]]) # add first row to the end

df3=pd.concat([df1,df2], join='inner', ignore_index=True) # concat two df's
Прости
источник
6

На высоком уровне:

  • .concat()просто складывает несколько DataFrameвместе либо по вертикали, либо по горизонтали после выравнивания по индексу
  • .merge()сначала выравнивает два DataFrameвыбранных общих столбца (столбцов) или индекса, а затем выбирает оставшиеся столбцы из выровненных строк каждого DataFrame.

Более конкретно .concat():

  • Функция pandas верхнего уровня
  • Объединяет две или более панд по DataFrame вертикали или горизонтали
  • Выравнивается только по индексу при совмещении по горизонтали
  • Ошибки, когда любой из DataFrameсодержит повторяющийся индекс.
  • По умолчанию используется внешнее соединение с возможностью внутреннего соединения.

И .merge():

  • Существует как функция pandas верхнего уровня, так и DataFrameметод (начиная с pandas 1.0)
  • Сочетает ровно два по DataFrameгоризонтали
  • Выравнивает DataFrameстолбец (столбцы) или индекс вызывающего абонента с другим DataFrameстолбцом (столбцами) или индексом
  • Обрабатывает повторяющиеся значения в соединяемых столбцах или индексе , выполняя декартово произведение
  • По умолчанию используется внутреннее соединение с параметрами для левого, внешнего и правого

Обратите внимание, что при выполнении pd.merge(left, right), если leftесть две строки, содержащие одинаковые значения из соединяемых столбцов или индекса, каждая строка будет объединяться с rightсоответствующей строкой (строками), в результате чего получается декартово произведение. С другой стороны, если .concat()он используется для объединения столбцов, нам нужно убедиться, что ни в одном из них нет повторяющегося индекса DataFrame.

Практически:

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

Ссылка: Pandas 1.x Cookbook

Джейк Ву
источник
2

Основное различие между объединением и объединением состоит в том, что объединение позволяет выполнять более структурированное «объединение» таблиц, где использование объединения более широко и менее структурировано.

Объединить

Ссылаясь на документацию , pd.DataFrame.mergeпринимает right как обязательный аргумент, который вы можете рассматривать как объединение левой таблицы и правой таблицы в соответствии с некоторой предопределенной операцией структурированного соединения. Обратите внимание на определение параметра right .

Обязательные параметры

  • справа : DataFrame или именованная серия

Дополнительные параметры

  • как : {'left', 'right', 'external', 'inner'} по умолчанию 'inner'
  • на : ярлык или список
  • left_on : метка, список или массив
  • right_on : метка или список, или как массив
  • left_index : bool, по умолчанию False
  • right_index : bool, по умолчанию False
  • sort : bool, по умолчанию False
  • суффиксы : кортеж из (str, str), по умолчанию ('_x', '_y')
  • копия : bool, по умолчанию True
  • индикатор : bool или str, по умолчанию False
  • проверить : str, необязательно

Важно: pd.DataFrame.merge требуется право быть объектом pd.DataFrameили именованным pd.Seriesобъектом.

Вывод

  • Возвращает : DataFrame

Кроме того, если мы проверим строку документации для операции слияния на пандах, она будет ниже:

Выполнение операции слияния базы данных (SQL) между двумя объектами DataFrame или Series, используя либо столбцы в качестве ключей, либо их индексы строк.

Concat

Обратитесь к документации по pd.concat, первой нота , что параметр не назван любой из таблицы, data_frame, серии, матрица и т.д., но Objs вместо этого. То есть вы можете передать множество «контейнеров данных», которые определены как:

Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]

Обязательные параметры

  • objs : последовательность или отображение объектов Series или DataFrame

Дополнительные параметры

  • ось : {0 / 'index', 1 / 'columns'}, по умолчанию 0
  • присоединиться : {'внутренний', 'внешний'}, по умолчанию 'внешний'
  • ignore_index : bool, по умолчанию False
  • ключи : последовательность, по умолчанию Нет
  • уровни : список последовательностей, по умолчанию нет
  • имена : список, по умолчанию Нет
  • verify_integrity : bool, по умолчанию False
  • sort : bool, по умолчанию False
  • копия : bool, по умолчанию True

Вывод

  • Возвращает : объект, тип объекта.

пример

Код

import pandas as pd

v1 = pd.Series([1, 5, 9, 13])
v2 = pd.Series([10, 100, 1000, 10000])
v3 = pd.Series([0, 1, 2, 3])

df_left = pd.DataFrame({
    "v1": v1,
    "v2": v2,
    "v3": v3
    })
df_right = pd.DataFrame({
    "v4": [5, 5, 5, 5],
    "v5": [3, 2, 1, 0]
    })


df_concat = pd.concat([v1, v2, v3])

# Performing operations on default

merge_result = df_left.merge(df_right, left_index=True, right_index=True)
concat_result = pd.concat([df_left, df_right], sort=False)
print(merge_result)
print('='*20)
print(concat_result)

Вывод кода

   v1     v2  v3  v4  v5
0   1     10   0   5   3
1   5    100   1   5   2
2   9   1000   2   5   1
3  13  10000   3   5   0
====================
     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0

Однако вы можете добиться первого вывода (слияния) с помощью concat, изменив параметр оси

concat_result = pd.concat([df_left, df_right], sort=False, axis=1)

Обратите внимание на следующее поведение:

concat_result = pd.concat([df_left, df_right, df_left, df_right], sort=False)

выходы;

     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0

, с которым вы не можете выполнить аналогичную операцию со слиянием, поскольку он допускает только один DataFrame или именованный Series.

merge_result = df_left.merge([df_right, df_left, df_right], left_index=True, right_index=True)

выходы;

TypeError: Can only merge Series or DataFrame objects, a <class 'list'> was passed

Заключение

Как вы, возможно, уже заметили, входные и выходные данные могут отличаться для «слияния» и «конкатенации».

Как я упоминал в начале, самое первое (основное) отличие состоит в том, что «слияние» выполняет более структурированное соединение с набором ограниченного набора объектов и параметров, тогда как «concat» выполняет менее строгое / более широкое соединение с более широким набором. объектов и параметров.

В общем, слияние менее терпимо к изменениям / (ввод), а «concat» более свободным / менее чувствительным к изменениям / (ввод). Вы можете добиться «слияния», используя «concat», но обратное не всегда верно.

Операция «слияния» использует столбцы фрейма данных (или имя pd.Seriesобъекта) или индексы строк, и, поскольку он использует только эти сущности, выполняет горизонтальное слияние фреймов данных или серий и не применяет вертикальную операцию в результате.

Если вы хотите увидеть больше, вы можете немного погрузиться в исходный код;

ноль
источник
0

Только функция concat имеет параметр оси. Слияние используется для объединения фреймов данных бок о бок на основе значений в общих столбцах, поэтому параметр оси не требуется.

Хамид лотфи
источник
-2

по умолчанию:
join - это левое соединение по
столбцам pd.merge - это внутреннее соединение по
столбцам pd.concat - внешнее соединение по строкам

pd.concat:
принимает итерируемые аргументы. Таким образом, он не может принимать DataFrames напрямую (используйте [df, df2]).
Размеры DataFrame должны совпадать по оси

Присоединиться и pd.merge:
может принимать аргументы DataFrame

Нажмите, чтобы увидеть изображение, чтобы понять, почему приведенный ниже код делает то же самое.

df1.join(df2)
pd.merge(df1, df2, left_index=True, right_index=True)
pd.concat([df1, df2], axis=1)
Vicpal
источник