[python] Pandas ‘concat 함수에서’레벨 ‘,’키 ‘, 이름 인수는 무엇입니까?

Question 1

질문

어떻게 사용합니까 pd.concat 합니까?
이것은 levels주장 ?
이것은 keys주장 ?
모든 인수를 사용하는 방법을 설명하는 데 도움이되는 많은 예가 있습니까?

Pandas의 concat기능은 병합 유틸리티 의 스위스 군용 칼 입니다. 유용한 상황은 다양합니다. 기존 문서에는 일부 선택적 인수에 대한 몇 가지 세부 정보가 나와 있습니다. 그중에는 levels및 keys인수가 있습니다. 나는 그 주장이 무엇을하는지 알아 내기 시작했다.

.NET의 여러 측면에서 관문 역할을 할 질문을 제기하겠습니다 pd.concat.

데이터 프레임을 고려 d1, d2및 d3:

import pandas as pd

d1 = pd.DataFrame(dict(A=.1, B=.2, C=.3), [2, 3])
d2 = pd.DataFrame(dict(B=.4, C=.5, D=.6), [1, 2])
d3 = pd.DataFrame(dict(A=.7, B=.8, D=.9), [1, 3])

내가 이것들을 함께 연결한다면

pd.concat([d1, d2, d3], keys=['d1', 'd2', 'd3'])

pandas.MultiIndex내 columns개체에 대한 예상 결과를 얻습니다 .

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

그러나 levels인수 문서 를 사용하고 싶었습니다 .

레벨 : 시퀀스 목록, 기본값 없음. MultiIndex를 구성하는 데 사용할 특정 수준 (고유 값)입니다. 그렇지 않으면 키에서 유추됩니다.

그래서 통과했습니다

pd.concat([d1, d2, d3], keys=['d1', 'd2', 'd3'], levels=[['d1', 'd2']])

그리고 KeyError

ValueError: Key d3 not in level Index(['d1', 'd2'], dtype='object')

이것은 의미가 있습니다. 내가 통과 한 레벨은 키로 표시된 필요한 레벨을 설명하기에 부적절했습니다. 위에서 한 것처럼 아무것도 통과하지 못했다면 레벨이 추론됩니다 (문서에 명시된대로). 그러나 더 나은 효과를 위해이 주장을 어떻게 사용할 수 있습니까?

대신 이것을 시도하면 :

pd.concat([d1, d2, d3], keys=['d1', 'd2', 'd3'], levels=[['d1', 'd2', 'd3']])

나는 위와 같은 결과를 얻었습니다. 하지만 레벨에 값을 하나 더 추가하면

df = pd.concat([d1, d2, d3], keys=['d1', 'd2', 'd3'], levels=[['d1', 'd2', 'd3', 'd4']])

나는 똑같은 데이터 프레임으로 끝나지만 그 결과 MultiIndex로 사용되지 않은 수준이 있습니다.

df.index.levels[0]

Index(['d1', 'd2', 'd3', 'd4'], dtype='object')

그래서 level논쟁 의 요점은 무엇이며 내가 사용해야 할keys 다르게 할까요?

Python 3.6 및 Pandas 0.22를 사용하고 있습니다.

Question 2

이 질문에 답하는 과정에서 나는 많은 것을 배웠고 예제 카탈로그와 설명을 모으고 싶었습니다.

levels논쟁 의 요점에 대한 구체적인 대답 은 끝이 될 것입니다.

`pandas.concat`: 누락 된 매뉴얼

현재 문서에 링크

개체 가져 오기 및 정의

import pandas as pd

d1 = pd.DataFrame(dict(A=.1, B=.2, C=.3), index=[2, 3])
d2 = pd.DataFrame(dict(B=.4, C=.5, D=.6), index=[1, 2])
d3 = pd.DataFrame(dict(A=.7, B=.8, D=.9), index=[1, 3])

s1 = pd.Series([1, 2], index=[2, 3])
s2 = pd.Series([3, 4], index=[1, 2])
s3 = pd.Series([5, 6], index=[1, 3])

인수

`objs`

우리가 접하는 첫 번째 주장은 objs다음과 같습니다.

objs : Series, DataFrame 또는 Panel 객체의 시퀀스 또는 매핑 dict가 전달되면 정렬 된 키가 전달되지 않는 한 keys 인수로 사용됩니다.이 경우 값이 선택됩니다 (아래 참조). None 객체는 모두 None이 아니면 ValueError가 발생하지 않는 한 자동으로 삭제됩니다.

일반적으로 Series또는 DataFrame개체 목록과 함께 사용 됩니다.
이것도 dict매우 유용 할 수 있음을 보여 드리겠습니다 .
발전기도 사용할 수 있으며 다음과 같이 사용할 때 유용 할 수 있습니다 map.map(f, list_of_df)

지금은 위에서 정의한 일부 DataFrame및 Series개체 목록을 계속 사용하겠습니다 . MultiIndex나중에 매우 유용한 결과 를 제공하기 위해 사전을 활용하는 방법을 보여 드리겠습니다 .

pd.concat([d1, d2])

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

`axis`

두 번째 인수는 axis기본값이 0다음과 같습니다.

axis : {0 / ‘index’, 1 / ‘columns’}, 기본값 0 연결할 축입니다.

(스택)이있는 2 `DataFrame`초`axis=0`

0또는 값의 경우 index“열을 따라 정렬하고 색인에 추가”를 의미합니다.

를 사용했던 위와 같이 는 기본값 axis=0이므로 의 인덱스가 값이 겹치는 경우에도 0의 인덱스를 d2확장하는 것을 볼 수 있습니다 .d12

pd.concat([d1, d2], axis=0)

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

두 `DataFrame`s `axis=1`(나란히)

값의 1경우 columns“색인을 따라 정렬하고 열에 추가”라는 뜻입니다.

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

     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

결과 색인은 색인의 합집합이고 결과 열은의 열에 d1의해 확장 된 열임을 알 수 d2있습니다.

두 (또는 세) `Series`와 `axis=0`(스택)

pandas.Series함께 결합 axis=0하면 pandas.Series. 결과의 이름이 Series될 것입니다 None모든 않는 Series결합 된 존재가 같은 이름을 가지고있다. 'Name: A'결과를 인쇄 할 때 주의 하십시오 Series. 존재하지 않는 경우 Series이름은 None.

               |                       |                        |  pd.concat(
               |  pd.concat(           |  pd.concat(            |      [s1.rename('A'),
 pd.concat(    |      [s1.rename('A'), |      [s1.rename('A'),  |       s2.rename('B'),
     [s1, s2]) |       s2])            |       s2.rename('A')]) |       s3.rename('A')])
-------------- | --------------------- | ---------------------- | ----------------------
2    1         | 2    1                | 2    1                 | 2    1
3    2         | 3    2                | 3    2                 | 3    2
1    3         | 1    3                | 1    3                 | 1    3
2    4         | 2    4                | 2    4                 | 2    4
dtype: int64   | dtype: int64          | Name: A, dtype: int64  | 1    5
               |                       |                        | 3    6
               |                       |                        | dtype: int64

두 (또는 세) `Series`와`axis=1` (나란히)

pandas.Series함께 결합 할 때 결과에서 열 이름을 추론하기 위해 참조 axis=1하는 name속성입니다 pandas.DataFrame.

                       |                       |  pd.concat(
                       |  pd.concat(           |      [s1.rename('X'),
 pd.concat(            |      [s1.rename('X'), |       s2.rename('Y'),
     [s1, s2], axis=1) |       s2], axis=1)    |       s3.rename('Z')], axis=1)
---------------------- | --------------------- | ------------------------------
     0    1            |      X    0           |      X    Y    Z
1  NaN  3.0            | 1  NaN  3.0           | 1  NaN  3.0  5.0
2  1.0  4.0            | 2  1.0  4.0           | 2  1.0  4.0  NaN
3  2.0  NaN            | 3  2.0  NaN           | 3  2.0  NaN  6.0

혼합 `Series`과 `DataFrame`함께 `axis=0`(적층)

a Series와 DataFramealong 의 연결을 수행 할 때 axis=0모두 Series단일 열로 변환합니다 DataFrame.

이것은 함께 연결된다는 점에 유의하십시오 axis=0. 이는 열을 정렬하면서 인덱스 (행)를 확장하는 것을 의미합니다. 아래 예에서 인덱스가 [2, 3, 2, 3]무차별 적으로 인덱스를 추가하는 것을 볼 수 있습니다. Series인수가 있는 열의 이름을 다음 과 같이 지정하지 않으면 열이 겹치지 않습니다 to_frame.

 pd.concat(               |
     [s1.to_frame(), d1]) |  pd.concat([s1, d1])
------------------------- | ---------------------
     0    A    B    C     |      0    A    B    C
2  1.0  NaN  NaN  NaN     | 2  1.0  NaN  NaN  NaN
3  2.0  NaN  NaN  NaN     | 3  2.0  NaN  NaN  NaN
2  NaN  0.1  0.2  0.3     | 2  NaN  0.1  0.2  0.3
3  NaN  0.1  0.2  0.3     | 3  NaN  0.1  0.2  0.3

결과는 pd.concat([s1, d1])마치 내가 수행 한 것과 동일하다는 것을 알 수 있습니다.to_frame 나 자신을 .

그러나 매개 변수를 사용하여 결과 열의 이름을 to_frame. 메서드를 Series사용하여의 이름을 rename변경해도 결과의 열 이름은 제어 되지 않습니다DataFrame .

 # Effectively renames       |                            |
 # `s1` but does not align   |  # Does not rename.  So    |  # Renames to something
 # with columns in `d1`      |  # Pandas defaults to `0`  |  # that does align with `d1`
 pd.concat(                  |  pd.concat(                |  pd.concat(
     [s1.to_frame('X'), d1]) |      [s1.rename('X'), d1]) |      [s1.to_frame('B'), d1])
---------------------------- | -------------------------- | ----------------------------
     A    B    C    X        |      0    A    B    C      |      A    B    C
2  NaN  NaN  NaN  1.0        | 2  1.0  NaN  NaN  NaN      | 2  NaN  1.0  NaN
3  NaN  NaN  NaN  2.0        | 3  2.0  NaN  NaN  NaN      | 3  NaN  2.0  NaN
2  0.1  0.2  0.3  NaN        | 2  NaN  0.1  0.2  0.3      | 2  0.1  0.2  0.3
3  0.1  0.2  0.3  NaN        | 3  NaN  0.1  0.2  0.3      | 3  0.1  0.2  0.3

혼합 `Series`및 `DataFrame`함께 `axis=1`(나란히)

이것은 상당히 직관적입니다. Series열 이름 Series은 name속성을 사용할 수없는 경우 이러한 개체 의 열거 형으로 기본 설정됩니다 .

                    |  pd.concat(
 pd.concat(         |      [s1.rename('X'),
     [s1, d1],      |       s2, s3, d1],
     axis=1)        |      axis=1)
------------------- | -------------------------------
   0    A    B    C |      X    0    1    A    B    C
2  1  0.1  0.2  0.3 | 1  NaN  3.0  5.0  NaN  NaN  NaN
3  2  0.1  0.2  0.3 | 2  1.0  4.0  NaN  0.1  0.2  0.3
                    | 3  2.0  NaN  6.0  0.1  0.2  0.3

`join`

세 번째 인수는 join결과 병합이 외부 병합 (기본값)인지 내부 병합인지를 설명하는 것입니다.

join : { ‘inner’, ‘outer’}, 기본값 ‘outer’
다른 축에서 인덱스를 처리하는 방법.

밝혀졌습니다. left또는 right옵션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 : 부울, 기본값 False
True 인 경우 연결 축을 따라 인덱스 값을 사용하지 않습니다. 결과 축은 0, …, n-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`

해당 MultiIndex에 튜플 또는 스칼라 값을 할당하기 위해 스칼라 값 또는 튜플 목록을 전달할 수 있습니다. 전달 된 목록의 길이는 연결되는 항목 수와 길이가 같아야합니다.

키 : 시퀀스, 기본값 없음
여러 수준이 전달 된 경우 튜플을 포함해야합니다. 전달 된 키를 가장 바깥 쪽 수준으로 사용하여 계층 적 인덱스 생성

`axis=0`

Series객체를 연결할 때 axis=0(인덱스 확장).

이러한 키 MultiIndex는 index 속성에서 개체 의 새로운 초기 수준이 됩니다.

 #           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, 즉 columns속성을 참조합니다.

두의 변형 Serieswtihaxis=1

전달 되지 않는 한 s1및 s2문제의 이름을 지정 keys하지만 전달되면 무시됩니다 keys.

               |                       |                        |  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하지만 이번에는 columns속성에 저장된 개체에 수준을 추가 합니다.

 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도의 처음 단계로 동작하면서 컬럼지면 오브젝트 MultiIndex대한 DataFrame. 따라서 Pandas는 다시 개체 의 name속성을 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 추론.

Pandas는 이름에서 열 이름을 유추하는 것처럼 보이지만 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

그런 다음 열 개체에 한 수준 만있는 다른 데이터 프레임과 연결하면 Pandas는 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`

이것은 keys인수 와 함께 사용 levels됩니다.이 기본값으로 남아 있으면 NonePandas는 결과의 각 수준의 고유 값을 가져와 MultiIndex결과 index.levels속성에 사용되는 개체로 사용 합니다.

levels : 시퀀스 목록, 기본값 없음
MultiIndex를 구성하는 데 사용할 특정 수준 (고유 값). 그렇지 않으면 키에서 유추됩니다.

Pandas가 이미 이러한 수준이 무엇인지 추론한다면 직접 지정하면 어떤 이점이 있습니까? 한 가지 예를 보여주고 이것이 유용한 다른 이유를 생각하도록 남겨 두겠습니다.

예

문서에 따르면 levels인수는 시퀀스 목록입니다. 이것은 우리 pandas.Index가 그 시퀀스 중 하나로 다른 것을 사용할 수 있음을 의미합니다 .

, 및 df의 연결 인 데이터 프레임 을 고려하십시오 .d1d2d3

df = pd.concat(
    [d1, d2, d3], axis=1,
    keys=['First', 'Second', 'Fourth'])

df

  First           Second           Fourth
      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
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

열 개체의 수준은 다음과 같습니다.

print(df, *df.columns.levels, sep='\n')

Index(['First', 'Second', 'Fourth'], dtype='object')
Index(['A', 'B', 'C', 'D'], dtype='object')

sum내에서 사용 하면 다음 groupby을 얻습니다.

df.groupby(axis=1, level=0).sum()

   First  Fourth  Second
1    0.0     2.4     1.5
2    0.6     0.0     1.5
3    0.6     2.4     0.0

하지만 그 대신에 and ['First', 'Second', 'Fourth']라는 이름의 또 다른 누락 된 카테고리가 있다면 어떨까요? 그리고 집계 결과에 포함되기를 원합니까? 우리가 . 그리고 우리는 인수로 미리 지정할 수 있습니다 .ThirdFifthgroupbypandas.CategoricalIndexlevels

따라서 대신 다음 df과 같이 정의하겠습니다 .

cats = ['First', 'Second', 'Third', 'Fourth', 'Fifth']
lvl = pd.CategoricalIndex(cats, categories=cats, ordered=True)

df = pd.concat(
    [d1, d2, d3], axis=1,
    keys=['First', 'Second', 'Fourth'],
    levels=[lvl]
)

df

   First  Fourth  Second
1    0.0     2.4     1.5
2    0.6     0.0     1.5
3    0.6     2.4     0.0

그러나 열 개체의 첫 번째 수준은 다음과 같습니다.

df.columns.levels[0]

CategoricalIndex(
    ['First', 'Second', 'Third', 'Fourth', 'Fifth'],
    categories=['First', 'Second', 'Third', 'Fourth', 'Fifth'],
    ordered=True, dtype='category')

그리고 우리의 groupby요약은 다음과 같습니다.

df.groupby(axis=1, level=0).sum()

   First  Second  Third  Fourth  Fifth
1    0.0     1.5    0.0     2.4    0.0
2    0.6     1.5    0.0     0.0    0.0
3    0.6     0.0    0.0     2.4    0.0

`names`

이것은 결과의 수준 이름을 지정하는 데 사용됩니다 MultiIndex. names목록 의 길이 는 결과의 수준 수와 일치해야합니다 MultiIndex.

names : list, default 없음
결과 계층 인덱스의 수준 이름

 # axis=0                     |  # axis=1
 pd.concat(                   |  pd.concat(
     [d1, d2],                |      [d1, d2],
     keys=[0, 1],             |      axis=1, keys=[0, 1],
     names=['lvl0', 'lvl1'])  |      names=['lvl0', 'lvl1'])
----------------------------- | ----------------------------------
             A    B    C    D | lvl0    0              1
lvl0 lvl1                     | lvl1    A    B    C    B    C    D
0    2     0.1  0.2  0.3  NaN | 1     NaN  NaN  NaN  0.4  0.5  0.6
     3     0.1  0.2  0.3  NaN | 2     0.1  0.2  0.3  0.4  0.5  0.6
1    1     NaN  0.4  0.5  0.6 | 3     0.1  0.2  0.3  NaN  NaN  NaN
     2     NaN  0.4  0.5  0.6 |

`verify_integrity`

자체 설명 문서

verify_integrity : 부울, 기본값 False
새로 연결된 축에 중복 항목이 있는지 확인합니다. 이것은 실제 데이터 연결에 비해 매우 비쌀 수 있습니다.

결과 색인이 연결 d1되고 d2고유하지 않기 때문에 무결성 검사에 실패합니다.

pd.concat([d1, d2])

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

과

pd.concat([d1, d2], verify_integrity=True)

> ValueError : 인덱스에 겹치는 값이 있습니다 : [2]

[python] Pandas ‘concat 함수에서’레벨 ‘,’키 ‘, 이름 인수는 무엇입니까?

질문

답변

`pandas.concat`: 누락 된 매뉴얼

개체 가져 오기 및 정의

인수

`objs`

`axis`

(스택)이있는 2 `DataFrame`초`axis=0`

두 `DataFrame`s `axis=1`(나란히)

두 (또는 세) `Series`와 `axis=0`(스택)

두 (또는 세) `Series`와`axis=1` (나란히)

혼합 `Series`과 `DataFrame`함께 `axis=0`(적층)

혼합 `Series`및 `DataFrame`함께 `axis=1`(나란히)

`join`

`outer`

`inner`

`join_axes`

왼쪽 병합

오른쪽 병합

`ignore_index`

`keys`

`axis=0`

`axis=1`

`dict`대신에 전달`list`

`levels`

예

`names`

`verify_integrity`

답변

질문

답변

pandas.concat: 누락 된 매뉴얼

개체 가져 오기 및 정의

인수

objs

axis

(스택)이있는 2 DataFrame초axis=0

두 DataFrames axis=1(나란히)

두 (또는 세) Series와 axis=0(스택)

두 (또는 세) Series와axis=1 (나란히)

혼합 Series과 DataFrame함께 axis=0(적층)

혼합 Series및 DataFrame함께 axis=1(나란히)

join

outer

inner

join_axes

왼쪽 병합

오른쪽 병합

ignore_index

keys

axis=0

axis=1

dict대신에 전달list

levels

예

names

verify_integrity

답변

`pandas.concat`: 누락 된 매뉴얼

`objs`

`axis`

(스택)이있는 2 `DataFrame`초`axis=0`

두 `DataFrame`s `axis=1`(나란히)

두 (또는 세) `Series`와 `axis=0`(스택)

두 (또는 세) `Series`와`axis=1` (나란히)

혼합 `Series`과 `DataFrame`함께 `axis=0`(적층)

혼합 `Series`및 `DataFrame`함께 `axis=1`(나란히)

`join`

`outer`

`inner`

`join_axes`

`ignore_index`

`keys`

`axis=0`

`axis=1`

`dict`대신에 전달`list`

`levels`

`names`

`verify_integrity`