Каковы аргументы "уровней", "ключей" и имен в функции concat Pandas?

вопросы

  • как использовать pd.concat?
  • что такое
1 62
python pandas

1 ответ:

в процессе ответа на этот вопрос для себя я узнал много вещей, и я хотел собрать каталог примеров и пояснений.

конкретный ответ на вопрос как pd.concat может обрабатывать более двух объектов для слияния.

в случае d1 и d2 параметры выглядеть так:

outer

pd.concat([d1, d2], axis=1, join='outer')

     A    B    C    B    C    D
1  NaN  NaN  NaN  0.4  0.5  0.6
2  0.1  0.2  0.3  0.4  0.5  0.6
3  0.1  0.2  0.3  NaN  NaN  NaN

inner

pd.concat([d1, d2], axis=1, join='inner')

     A    B    C    B    C    D
2  0.1  0.2  0.3  0.4  0.5  0.6

join_axes

четвертый аргумент-это то, что позволяет нам делать наши left слияния и больше.

join_axes: список объектов Index
Конкретные индексы, используемые для других осей n - 1 вместо выполнения внутренней/внешней логики набора.

Левое Слияние

pd.concat([d1, d2, d3], axis=1, join_axes=[d1.index])

     A    B    C    B    C    D    A    B    D
2  0.1  0.2  0.3  0.4  0.5  0.6  NaN  NaN  NaN
3  0.1  0.2  0.3  NaN  NaN  NaN  0.7  0.8  0.9

Право Слияния

pd.concat([d1, d2, d3], axis=1, join_axes=[d3.index])

     A    B    C    B    C    D    A    B    D
1  NaN  NaN  NaN  0.4  0.5  0.6  0.7  0.8  0.9
3  0.1  0.2  0.3  NaN  NaN  NaN  0.7  0.8  0.9

ignore_index

ignore_index: boolean, по умолчанию False
Если True, не используйте значения Индекса вдоль оси сочленения. Полученная ось будет помечена как 0, ..., П - 1. Это полезно, если вы объединяете объекты, где ось объединения не имеет значимой информации индексирования. Обратите внимание, что значения индекса на других осях по-прежнему соблюдаются в соединении.

например, когда я ставлю d1 на d2, если я не забочусь о значениях индекса, я мог бы сбросить их или игнорировать их.

                      |  pd.concat(             |  pd.concat(
                      |      [d1, d2],          |      [d1, d2]
 pd.concat([d1, d2])  |      ignore_index=True) |  ).reset_index(drop=True)
--------------------- | ----------------------- | -------------------------
     A    B    C    D |      A    B    C    D   |      A    B    C    D
2  0.1  0.2  0.3  NaN | 0  0.1  0.2  0.3  NaN   | 0  0.1  0.2  0.3  NaN
3  0.1  0.2  0.3  NaN | 1  0.1  0.2  0.3  NaN   | 1  0.1  0.2  0.3  NaN
1  NaN  0.4  0.5  0.6 | 2  NaN  0.4  0.5  0.6   | 2  NaN  0.4  0.5  0.6
2  NaN  0.4  0.5  0.6 | 3  NaN  0.4  0.5  0.6   | 3  NaN  0.4  0.5  0.6

и при использовании axis=1:

                                   |     pd.concat(
                                   |         [d1, d2], axis=1,
 pd.concat([d1, d2], axis=1)       |         ignore_index=True)
-------------------------------    |    -------------------------------
     A    B    C    B    C    D    |         0    1    2    3    4    5
1  NaN  NaN  NaN  0.4  0.5  0.6    |    1  NaN  NaN  NaN  0.4  0.5  0.6
2  0.1  0.2  0.3  0.4  0.5  0.6    |    2  0.1  0.2  0.3  0.4  0.5  0.6
3  0.1  0.2  0.3  NaN  NaN  NaN    |    3  0.1  0.2  0.3  NaN  NaN  NaN

keys

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

ключи: последовательность, по умолчанию none
Если несколько уровней пройдены, должны содержать кортежи. Построить иерархический индекс, используя переданные ключи как самый внешний уровень

axis=0

сцепя Series объекты вдоль axis=0 (расширение индекса).

эти ключи, становятся новым начальным уровнем a MultiIndex объект в атрибуте индекса.

 #           length 3             length 3           #         length 2        length 2
 #          /--------\         /-----------\         #          /----\         /------\
 pd.concat([s1, s2, s3], keys=['A', 'B', 'C'])       pd.concat([s1, s2], keys=['A', 'B'])
----------------------------------------------      -------------------------------------
A  2    1                                           A  2    1
   3    2                                              3    2
B  1    3                                           B  1    3
   2    4                                              2    4
C  1    5                                           dtype: int64
   3    6
dtype: int64
, мы можем использовать больше, чем скалярные значения в keys аргумент для создания еще более глубокого MultiIndex. Здесь мы проходим tuples длины 2 добавить два новых уровня a MultiIndex: 
 pd.concat(
     [s1, s2, s3],
     keys=[('A', 'X'), ('A', 'Y'), ('B', 'X')])
-----------------------------------------------
A  X  2    1
      3    2
   Y  1    3
      2    4
B  X  1    5
      3    6
dtype: int64

axis=1

это немного отличается при расширении вдоль столбцов. Когда мы использовали axis=0 (см. выше) наши keys выступила MultiIndex уровни в дополнение к существующему индексу. Ибо axis=1, мы имеем в виду ось, которая Series объектов нет, а именно .

Вариации из двух Series wtih axis=1

обратите внимание, что называя s1 и s2 имеет значение, пока нет keys are передано, но оно переопределяется, если есть.

               |                       |                        |  pd.concat(
               |  pd.concat(           |  pd.concat(            |      [s1.rename('U'),
 pd.concat(    |      [s1, s2],        |      [s1.rename('U'),  |       s2.rename('V')],
     [s1, s2], |      axis=1,          |       s2.rename('V')], |       axis=1,
     axis=1)   |      keys=['X', 'Y']) |       axis=1)          |       keys=['X', 'Y'])
-------------- | --------------------- | ---------------------- | ----------------------
     0    1    |      X    Y           |      U    V            |      X    Y
1  NaN  3.0    | 1  NaN  3.0           | 1  NaN  3.0            | 1  NaN  3.0
2  1.0  4.0    | 2  1.0  4.0           | 2  1.0  4.0            | 2  1.0  4.0
3  2.0  NaN    | 3  2.0  NaN           | 3  2.0  NaN            | 3  2.0  NaN
MultiIndex с Series и axis=1 
 pd.concat(
     [s1, s2],
     axis=1,
     keys=[('W', 'X'), ('W', 'Y')])
-----------------------------------
     W
     X    Y
1  NaN  3.0
2  1.0  4.0
3  2.0  NaN
Два DataFrame С axis=1

С axis=0 примеры keys добавить уровни к MultiIndex, но на этот раз к объекту, хранящемуся в .

 pd.concat(                     |  pd.concat(
     [d1, d2],                  |      [d1, d2],
     axis=1,                    |      axis=1,
     keys=['X', 'Y'])           |      keys=[('First', 'X'), ('Second', 'X')])
------------------------------- | --------------------------------------------
     X              Y           |   First           Second
     A    B    C    B    C    D |       X                X
1  NaN  NaN  NaN  0.4  0.5  0.6 |       A    B    C      B    C    D
2  0.1  0.2  0.3  0.4  0.5  0.6 | 1   NaN  NaN  NaN    0.4  0.5  0.6
3  0.1  0.2  0.3  NaN  NaN  NaN | 2   0.1  0.2  0.3    0.4  0.5  0.6
                                | 3   0.1  0.2  0.3    NaN  NaN  NaN
Series и DataFrame С axis=1

это сложно. В этом случае скалярное значение ключа не может выступать в качестве единственного уровня индекса для на Series объект как источник имени столбца.

 pd.concat(           |  pd.concat(
     [s1, d1],        |      [s1.rename('Z'), d1],
     axis=1,          |      axis=1,
     keys=['X', 'Y']) |      keys=['X', 'Y'])
--------------------- | --------------------------
   X    Y             |    X    Y
   0    A    B    C   |    Z    A    B    C
2  1  0.1  0.2  0.3   | 2  1  0.1  0.2  0.3
3  2  0.1  0.2  0.3   | 3  2  0.1  0.2  0.3
Ограничения keys и MultiIndex вывод.

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

d1_ = pd.concat(
    [d1], axis=1,
    keys=['One'])
d1_

   One
     A    B    C
2  0.1  0.2  0.3
3  0.1  0.2  0.3

затем объедините это с другим фреймом данных только с одним уровнем в объекте столбцов, и панды откажутся пытаться сделать кортежи MultiIndex объект и объединить все фреймы данных, как если бы один уровень объектов, скаляров и кортежей.

pd.concat([d1_, d2], axis=1)

   (One, A)  (One, B)  (One, C)    B    C    D
1       NaN       NaN       NaN  0.4  0.5  0.6
2       0.1       0.2       0.3  0.4  0.5  0.6
3       0.1       0.2       0.3  NaN  NaN  NaN

передает dict вместо list

при передаче словаря,pandas.concat будет использовать ключи из словаря, как keys параметр.

 # axis=0               |  # axis=1
 pd.concat(             |  pd.concat(
     {0: d1, 1: d2})    |      {0: d1, 1: d2}, axis=1)
----------------------- | -------------------------------
       A    B    C    D |      0              1
0 2  0.1  0.2  0.3  NaN |      A    B    C    B    C    D
  3  0.1  0.2  0.3  NaN | 1  NaN  NaN  NaN  0.4  0.5  0.6
1 1  NaN  0.4  0.5  0.6 | 2  0.1  0.2  0.3  0.4  0.5  0.6
  2  NaN  0.4  0.5  0.6 | 3  0.1  0.2  0.3  NaN  NaN  NaN

levels

это используется в сочетании с

68