pandas
Объединить, объединить и объединить

apache-spark HTML matplotlib MySQL postgresql Python Language R Language Regular Expressions SQL Microsoft SQL Server
Поиск…


Синтаксис

  • 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 выше.



Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow