pandas
Объединить, объединить и объединить
Поиск…
Синтаксис
DataFrame. merge ( right, how = 'inner', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = False, suffixes = ('_ x', '_y'), copy = True, индикатор = False )
Объедините объекты DataFrame, выполнив операцию объединения в стиле базы данных по столбцам или индексам.
При объединении столбцов в столбцах индексы DataFrame будут игнорироваться. В противном случае при объединении индексов по индексам или индексам в столбце или столбцах индекс будет передан.
параметры
| параметры | объяснение |
|---|---|
| право | DataFrame |
| как | {'left', 'right', 'outer', 'inner'}, default 'inner' |
| вышел на | ярлык или список или массив. Имена полей для объединения в левом DataFrame. Может быть вектором или списком векторов длины DataFrame для использования конкретного вектора в качестве ключа соединения вместо столбцов |
| Право на | ярлык или список или массив. Имена полей для присоединения в правом формате DataFrame или вектора / списка векторов на left_on docs |
| left_index | boolean, по умолчанию False. Используйте индекс из левого DataFrame в качестве ключа (ов) соединения. Если это MultiIndex, количество ключей в другом DataFrame (либо в индексе, либо в количестве столбцов) должно соответствовать количеству уровней |
| right_index | boolean, по умолчанию False. Используйте индекс из нужного DataFrame в качестве ключа соединения. Те же оговорки, что и left_index |
| Сортировать | boolean, по умолчанию Fals. Сортируйте ключи соединения лексикографически в результате DataFrame |
| суффиксы | 2-строчная последовательность (кортеж, список, ...). Суффикс применяется для перекрытия имен столбцов в левой и правой частях, соответственно |
| копия | boolean, по умолчанию True. Если False, не копируйте данные без необходимости |
| индикатор | boolean или string, по умолчанию False. Если True, добавляет столбец для вывода DataFrame с именем «_merge» с информацией об источнике каждой строки. Если строка, колонка с информацией об источнике каждой строки будет добавлена к выходу DataFrame, а столбцу будет присвоено значение string. Информационный столбец является категориальным и принимает значение «left_only» для наблюдений, чей ключ слияния появляется только в «левом» DataFrame, «right_only» для наблюдений, чей ключ слияния отображается только в «правильном» DataFrame и «both», если ключ слияния наблюдения находится в обоих. |
сливаться
Например, даны две таблицы,
T1
id x y
8 42 1.9
9 30 1.9
T2
id signal
8 55
8 56
8 59
9 57
9 58
9 60
Цель состоит в том, чтобы получить новую таблицу T3:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Который должен создавать столбцы s1 , s2 и s3 , каждый из которых соответствует строке (количество строк на id всегда фиксировано и равно 3)
Применяя join (который принимает необязательный аргумент, который может быть столбцом или несколькими именами столбцов, который указывает, что переданный DataFrame должен быть выровнен по этому столбцу в DataFrame). Таким образом, решение может быть таким, как показано ниже:
df = df1.merge (df2.groupby ('id') ['signal']. apply (lambda x: x.reset_index (drop = True)). unstack (). reset_index ())
df
Out[63]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Если я их разделю:
df2t = df2.groupby('id')['signal'].apply(lambda x: x.reset_index(drop=True)).unstack().reset_index()
df2t
Out[59]:
id 0 1 2
0 8 55 56 59
1 9 57 58 60
df = df1.merge(df2t)
df
Out[61]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Объединение двух DataFrames
In [1]: df1 = pd.DataFrame({'x': [1, 2, 3], 'y': ['a', 'b', 'c']})
In [2]: df2 = pd.DataFrame({'y': ['b', 'c', 'd'], 'z': [4, 5, 6]})
In [3]: df1
Out[3]:
x y
0 1 a
1 2 b
2 3 c
In [4]: df2
Out[4]:
y z
0 b 4
1 c 5
2 d 6
Внутреннее соединение:
Использует пересечение ключей из двух DataFrames.
In [5]: df1.merge(df2) # by default, it does an inner join on the common column(s)
Out[5]:
x y z
0 2 b 4
1 3 c 5
В качестве альтернативы укажите пересечение ключей из двух Dataframes.
In [5]: merged_inner = pd.merge(left=df1, right=df2, left_on='y', right_on='y')
Out[5]:
x y z
0 2 b 4
1 3 c 5
Внешнее соединение:
Использует объединение ключей из двух DataFrames.
In [6]: df1.merge(df2, how='outer')
Out[6]:
x y z
0 1.0 a NaN
1 2.0 b 4.0
2 3.0 c 5.0
3 NaN d 6.0
Левое соединение:
Использует только ключи из левого DataFrame.
In [7]: df1.merge(df2, how='left')
Out[7]:
x y z
0 1 a NaN
1 2 b 4.0
2 3 c 5.0
Право Присоединиться
Использует только ключи от правого DataFrame.
In [8]: df1.merge(df2, how='right')
Out[8]:
x y z
0 2.0 b 4
1 3.0 c 5
2 NaN d 6
Объединение / объединение / объединение нескольких кадров данных (по горизонтали и по вертикали)
генерировать образцы данных:
In [57]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [58]: df1 = pd.DataFrame({'col1':[11,12,13], 'col2': [21,22,23]})
In [59]: df2 = pd.DataFrame({'col1':[111,112,113], 'col2': [121,122,123]})
In [60]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [61]: df1
Out[61]:
col1 col2
0 11 21
1 12 22
2 13 23
In [62]: df2
Out[62]:
col1 col2
0 111 121
1 112 122
2 113 123
In [63]: df3
Out[63]:
col1 col2
0 211 221
1 212 222
2 213 223
объединить / объединить / объединить кадры данных [df1, df2, df3] по вертикали - добавить строки
In [64]: pd.concat([df1,df2,df3], ignore_index=True)
Out[64]:
col1 col2
0 11 21
1 12 22
2 13 23
3 111 121
4 112 122
5 113 123
6 211 221
7 212 222
8 213 223
объединить / объединить / объединить кадры данных по горизонтали (выравнивание по индексу):
In [65]: pd.concat([df1,df2,df3], axis=1)
Out[65]:
col1 col2 col1 col2 col1 col2
0 11 21 111 121 211 221
1 12 22 112 122 212 222
2 13 23 113 123 213 223
Объединить, присоединиться и присоединиться
Слияние имен ключей одинаково
pd.merge(df1, df2, on='key')
Слияние имен ключей различно
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Различные типы присоединения
pd.merge(df1, df2, on='key', how='left')
Объединение нескольких клавиш
pd.merge(df1, df2, on=['key1', 'key2'])
Обработка перекрывающихся столбцов
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Использование индекса строки вместо слияния ключей
pd.merge(df1, df2, right_index=True, left_index=True)
Избегайте использования синтаксиса .join поскольку он дает исключение для перекрывающихся столбцов
Объединение по левому индексу данных и правильному столбцу данных
pd.merge(df1, df2, right_index=True, left_on='l_key')
Конкретные информационные кадры
Клеены вертикально
pd.concat([df1, df2, df3], axis=0)
Клеены горизонтально
pd.concat([df1, df2, df3], axis=1)
В чем разница между объединением и объединением
Рассмотрим рамки данных left и right
left = pd.DataFrame([['a', 1], ['b', 2]], list('XY'), list('AB'))
left
A B
X a 1
Y b 2
right = pd.DataFrame([['a', 3], ['b', 4]], list('XY'), list('AC'))
right
A C
X a 3
Y b 4
join
Подумайте о том, чтобы join как хотите объединиться с dataframes на основе их соответствующих индексов. Если есть перекрывающиеся столбцы, join захочет, чтобы вы добавили суффикс к совпадающему имени столбца из левого фрейма. Наши два блока данных имеют перекрывающееся имя столбца A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Обратите внимание, что индекс сохраняется, и у нас есть 4 столбца. 2 столбца left и 2 right .
Если индексы не выровнены
left.join(right.reset_index(), lsuffix='_', how='outer')
A_ B index A C
0 NaN NaN X a 3.0
1 NaN NaN Y b 4.0
X a 1.0 NaN NaN NaN
Y b 2.0 NaN NaN NaN
Я использовал внешнее соединение, чтобы лучше проиллюстрировать суть. Если индексы не выравниваются, результатом будет объединение индексов.
Мы можем сказать, что join к использованию конкретного столбца в левом фрейме данных для использования в качестве ключа соединения, но он по-прежнему будет использовать индекс справа.
left.reset_index().join(right, on='index', lsuffix='_')
index A_ B A C
0 X a 1 a 3
1 Y b 2 b 4
merge
Подумайте о merge с выравниванием по столбцам. По умолчанию merge будет искать перекрывающиеся столбцы для объединения. merge дает лучший контроль над ключами слияния, позволяя пользователю указывать подмножество перекрывающихся столбцов для использования с параметром on или отдельно разрешать спецификацию столбцов слева и столбцов справа для слияния.
merge вернет комбинированный блок данных, в котором индекс будет уничтожен.
Этот простой пример находит перекрывающий столбец 'A' и объединяет его на основе.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Обратите внимание, что индекс [0, 1] и больше ['X', 'Y']
Вы можете явно указать, что вы объединяетесь с индексом с параметром left_index или right_index
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
И это выглядит точно так же, как пример join выше.