[解決済み] Pandasのconcat関数における'levels', 'keys', and namesの引数は何でしょうか？

2022-10-24 05:25:32

質問

の使用方法について教えてください。 pd.concat ?
は何ですか？ levels の引数は何ですか？
は何ですか？ keys の引数は何ですか？
すべての引数の使い方を説明するための例がたくさんあるのですか？

パンダの concat 関数はスイスアーミーナイフのマージ・ユーティリティです。この関数が役に立つ場面は数多くあります。既存のドキュメントでは、いくつかのオプションの引数に関する詳細が省かれています。その中には levels と keys という引数があります。私はこれらの引数が何をするものなのかを理解することにしました。

の多くの側面への入り口として機能するような質問を投げかけてみます。 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 引数ドキュメント :

レベル : シーケンスのリスト、デフォルトは None。 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を使用しています。

どのように解決するのですか？

この質問に自分で答える過程で、いろいろなことを学びましたので、例のカタログといくつかの解説をまとめたいと思います。

の指摘に対する具体的な回答は 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 :

オブジェ : Series、DataFrame、または Panel オブジェクトのシーケンスまたはマッピング。 dictが渡された場合、ソートされたキーがkeysの引数として使用されますが、dictが渡されない場合は、値が選択されます（下記参照）。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`

2つ目の引数は axis で、デフォルト値は 0 :

軸 : {0/'index', 1/'columns'}, デフォルト0 連結する軸を指定する。

2つの `DataFrame` とのことです。 `axis=0` (積み重ね)

の値については 0 または index というのは、「列に沿って整列し、インデックスに追加する」という意味です。

上で示したように axis=0 というのは 0 はデフォルトの値であり、そのインデックスが d2 のインデックスを拡張しています。 d1 の値が重なっているにもかかわらず 2 :

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

2つ `DataFrame` を持つ `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 .

2つ (または3つ) `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

2つ (または3つ) `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` (積み重ね)

を連結して実行する場合 Series と DataFrame に沿って axis=0 に沿って、すべての Series を単一カラムの DataFrame s.

に沿って連結していることに特に注意してください。 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`

第3引数は join で、これは結果のマージが外側マージ（デフォルト）か内側マージかを記述します。

結合 : {'inner', 'outer'}, デフォルトは'outer'。

他の軸のインデックスをどのように扱うか。

結局のところ left または right というオプションを pd.concat はマージする2つ以上のオブジェクトを扱うことができます。

の場合 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`

第4引数は、私たちの left をマージしたりすることができます。

join_axes : インデックスオブジェクトのリスト

内側/外側セットロジックを実行する代わりに、他の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の場合、連結軸に沿ったインデックス値を使用しない。これは、連結軸が意味のあるインデックス情報を持っていないオブジェクトを連結する場合に便利です。他の軸のインデックス値は、結合の際にまだ尊重されることに注意してください。

スタックするときと同じ 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 オブジェクトのインデックス属性になります。

 #           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つの新しいレベルの 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 属性です。

つのバリエーション Series wtih axis=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

これをカラムオブジェクトが1レベルしかない別のデータフレームと連結すると、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 がデフォルト値のままだと None のままにしておくと、Pandasは結果の各レベルの一意な値を取ることになります。 MultiIndex で使用されるオブジェクトとして使用します。 index.levels 属性で使用されるオブジェクトとして使用します。

レベル : シーケンスのリスト、デフォルトはなし

MultiIndexを構築するために使用する特定のレベル(一意な値)。そうでない場合はキーから推測される。

もしPandasがすでにこれらのレベルを推論しているなら、自分で指定する利点は何でしょうか？私は1つの例を示しますが、これが有用である他の理由を考えるのはあなたに任されています。

例

ドキュメントによれば levels の引数は配列のリストです。つまり、別の pandas.Index をそれらの配列の一つとして使うことができるということです。

データフレーム df を連結したものである。 d1 , d2 と d3 :

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

columnsオブジェクトのレベルは

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

しかし、もし ['First', 'Second', 'Fourth'] という名前の別のカテゴリがあったとします。 Third と Fifth ? の結果に含まれるようにしたかったのです。 groupby の集計結果に含めたいのですが？これは、もし pandas.CategoricalIndex . そして、それを先に指定することができるのが levels 引数で指定できます。

そこで、代わりに 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

しかし、columnsオブジェクトの第一階層は

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 .

名前 : リスト、デフォルトはなし

結果として得られる階層インデックスのレベルの名前

 # 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 : boolean, デフォルト 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です。Indexes have overlapping values: [2]

[解決済み] Pandasのconcat関数における'levels', 'keys', and namesの引数は何でしょうか？

質問

質問

どのように解決するのですか？

pandas.concat : ミッシング・マニュアル

インポートとオブジェクトの定義

引数

objs

axis

2つの DataFrame とのことです。 axis=0 (積み重ね)

2つ DataFrame を持つ axis=1 (横並び)

2つ (または3つ) Series と axis=0 (積み重ね)

2つ (または3つ) Series と axis=1 (横並び)

混合 Series と DataFrame と axis=0 (積み重ね)

混合 Series と DataFrame と axis=1 (横並び)

join

outer

inner

join_axes