电子商务网站模板/营销渠道的三个类型

在为我自己回答这个问题的过程中，我学到了很多东西，并且我想整理出一系列示例和一些说明。

有关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。

两个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

两个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的列的扩展。

axis=0两个(或三个) Series (堆叠)

当沿着axis=0组合pandas.Series ，我们得到一个pandas.Series 。 除非合并的所有Series具有相同的名称，否则所得Series的名称将为“ None 。 当我们打印出所得的Series时，请注意'Name: A' 。 当它不存在时，我们可以假定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

axis=1两个(或三个) Series (并排)

当沿着axis=1组合pandas.Series ，它是我们引用的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

axis=0混合Series和DataFrame (堆叠)

当沿着axis=0对Series和DataFrame进行串联时，我们将所有Series转换为单列DataFrame 。

请特别注意，这是沿axis=0的串联； 这意味着在对齐列时扩展索引(行)。 在下面的示例中，我们看到索引变为[2, 3, 2, 3] 2、3、2、3 [2, 3, 2, 3] ，这是对索引的不加选择的附加。 这些列不会重叠，除非我用to_frame的参数强行命名Series列：

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 。

但是，我可以使用to_frame的参数来控制结果列的名称。 使用重rename方法重命名Series 不会控制结果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

axis=1混合Series和DataFrame (并排)

这是相当直观的。 当name属性不可用时， Series列名称默认为此类Series对象的枚举。

| 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 ：索引对象的列表

用于其他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。如果要在串联轴没有有意义的索引信息的对象上串联，这将很有用。 请注意，联接中仍会考虑其他轴上的索引值。

就像在d2上堆叠d1时一样，如果我不在乎索引值，则可以重置它们或忽略它们。

| 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

当沿axis=0串联Series对象时(扩展索引)。

这些键成为index属性中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 。 在这里，我们将长度为2的tuples传递给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属性。

axis=1的两个Series变化axis=1

请注意，只要不传递任何keys ，命名s1和s2就很重要，但是如果传递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

具有Series和axis=1 MultiIndex axis=1

pd.concat( [s1, s2], axis=1, keys=[('W', 'X'), ('W', 'Y')]) ----------------------------------- W XY 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')]) ------------------------------- | -------------------------------------------- XY | First Second ABCBCD | XX 1 NaN NaN NaN 0.4 0.5 0.6 | ABCBCD 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将再次使用Series对象的name属性作为列名称的来源。

pd.concat( | pd.concat( [s1, d1], | [s1.rename('Z'), d1], axis=1, | axis=1, keys=['X', 'Y']) | keys=['X', 'Y']) --------------------- | -------------------------- XY | XY 0 ABC | ZABC 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 name推断出列名，但是当在具有不同列级别数的数据帧之间进行类似的串联时，Pandas不会填空。

d1_ = pd.concat( [d1], axis=1, keys=['One']) d1_ One ABC 2 0.1 0.2 0.3 3 0.1 0.2 0.3

然后，将其与只有一个级别的column对象中的另一个数据帧连接，Pandas将拒绝尝试制作MultiIndex对象的元组，并组合所有数据帧，就好像对象，标量和元组的单个级别一样。

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

传递dict而不是list

传递字典时， pandas.concat将使用字典中的keys作为keys参数。

# axis=0 | # axis=1 pd.concat( | pd.concat( {0: d1, 1: d2}) | {0: d1, 1: d2}, axis=1) ----------------------- | ------------------------------- ABCD | 0 1 0 2 0.1 0.2 0.3 NaN | ABCBCD 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的特定级别(唯一值)。 否则，将从按键推断出它们。

如果熊猫已经推断出这些水平应该是多少，那么自己指定它有什么优势？ 我将举一个例子，让您自己思考可能有用的其他原因。

例

根据文档， levels参数是序列的列表。 这意味着我们可以使用另一个pandas.Index作为这些序列之一。

考虑数据帧df ，它是d1 ， d2和d3的串联：

df = pd.concat( [d1, d2, d3], axis=1, keys=['First', 'Second', 'Fourth']) df First Second Fourth ABCBCDABD 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

列对象的级别为：

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

如果我们在groupby使用sum ， groupby得到：

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

Index(['First', 'Second', 'Fourth'], dtype='object')

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

但是，如果不是['First', 'Second', 'Fourth']不是另一个缺少的类别，称为Third和Fifth怎么办？ 我想将它们包括在groupby聚合结果中吗？ 如果我们有pandas.CategoricalIndex则可以执行此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

但是column对象的第一级是：

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

我们的groupby看起来像：

df.columns.levels[0]

CategoricalIndex(

['First', 'Second', 'Third', 'Fourth', 'Fifth'],

categories=['First', 'Second', 'Third', 'Fourth', 'Fifth'],

ordered=True, dtype='category')

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']) ----------------------------- | ---------------------------------- ABCD | lvl0 0 1 lvl0 lvl1 | lvl1 ABCBCD 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]) ABCD 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])

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

> ValueError：索引的值重叠：[2]