使用 groupby 的 Pandas 占总数的百分比答案

【问题标题】：Pandas percentage of total with groupby使用 groupby 的 Pandas 占总数的百分比
【发布时间】：2014-06-16 03:00:59
【问题描述】：

这显然很简单，但作为一个 numpy 新手，我被卡住了。

我有一个 CSV 文件，其中包含 3 列，即州、办公室 ID 和该办公室的销售额。

我想计算给定州每个办公室的销售额百分比（每个州所有百分比的总和为 100%）。

df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
                   'office_id': range(1, 7) * 2,
                   'sales': [np.random.randint(100000, 999999)
                             for _ in range(12)]})

df.groupby(['state', 'office_id']).agg({'sales': 'sum'})

这会返回：

                  sales
state office_id        
AZ    2          839507
      4          373917
      6          347225
CA    1          798585
      3          890850
      5          454423
CO    1          819975
      3          202969
      5          614011
WA    2          163942
      4          369858
      6          959285

我似乎不知道如何“达到”groupby 的state 级别，以合计整个state 的sales 来计算分数。

【问题讨论】：

df['sales'] / df.groupby('state')['sales'].transform('sum') 似乎是最明确的答案。

标签： python pandas

【解决方案1】：

Paul H's answer 是正确的，您必须创建第二个 groupby 对象，但您可以用更简单的方式计算百分比 - 只需 groupby state_office 并将 sales 列除以其和。复制 Paul H 答案的开头：

# From Paul H
import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
                   'office_id': list(range(1, 7)) * 2,
                   'sales': [np.random.randint(100000, 999999)
                             for _ in range(12)]})
state_office = df.groupby(['state', 'office_id']).agg({'sales': 'sum'})
# Change: groupby state_office and divide by sum
state_pcts = state_office.groupby(level=0).apply(lambda x:
                                                 100 * x / float(x.sum()))

返回：

                     sales
state office_id           
AZ    2          16.981365
      4          19.250033
      6          63.768601
CA    1          19.331879
      3          33.858747
      5          46.809373
CO    1          36.851857
      3          19.874290
      5          43.273852
WA    2          34.707233
      4          35.511259
      6          29.781508

【讨论】：

这是怎么回事？据我了解，x 是某种表格，所以100 * x 在直觉上没有意义（尤其是当某些单元格包含AZ 之类的字符串时，...）。
@dhardy state_office 是一个具有多索引的系列——所以它只是一个值都是数字的列。执行 groupby 后，每个 x 都是该列的子集。这有意义吗？
它可能，但它对我不起作用。 Python 3 中的 pandas 的工作方式是否有点不同？
level=0 是什么意思？
@Veenit 这意味着您是按索引的第一级分组，而不是按其中一个列。

【解决方案2】：

您需要创建第二个按状态分组的 groupby 对象，然后使用 div 方法：

import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999) for _ in range(12)]})

state_office = df.groupby(['state', 'office_id']).agg({'sales': 'sum'})
state = df.groupby(['state']).agg({'sales': 'sum'})
state_office.div(state, level='state') * 100


                     sales
state office_id           
AZ    2          16.981365
      4          19.250033
      6          63.768601
CA    1          19.331879
      3          33.858747
      5          46.809373
CO    1          36.851857
      3          19.874290
      5          43.273852
WA    2          34.707233
      4          35.511259
      6          29.781508

div 中的 level='state' kwarg 告诉 pandas 根据索引的 state 级别中的值广播/加入数据帧。

【讨论】：

如果您有 3 个索引，此方法是否有效？我首先在 3 列上进行了 groupby。然后我只对 2 做了第二个 groupby 并计算总和。然后我尝试使用div，但使用level=["index1", "index2"]，但它告诉我Join on level between two MultiIndex objects is ambiguous。
@Ger 它确实有效，但我无法从该描述中猜出你做错了什么。多在网站上搜索一下。如果您没有找到任何东西，请使用可重现的示例创建一个新问题来演示该问题。 stackoverflow.com/questions/20109391/…

【解决方案3】：

（这个解决方案的灵感来自这篇文章https://pbpython.com/pandas_transform.html）

我发现以下使用transformation 的解决方案是最简单的（可能也是最快的）：

转换：虽然聚合必须返回简化版本的数据，转换可以返回完整的一些转换版本数据重组。对于这样的转换，输出是相同的形状作为输入。

所以使用transformation，解决方案是1-liner：

df['%'] = 100 * df['sales'] / df.groupby('state')['sales'].transform('sum')

如果你打印：

print(df.sort_values(['state', 'office_id']).reset_index(drop=True))

   state  office_id   sales          %
0     AZ          2  195197   9.844309
1     AZ          4  877890  44.274352
2     AZ          6  909754  45.881339
3     CA          1  614752  50.415708
4     CA          3  395340  32.421767
5     CA          5  209274  17.162525
6     CO          1  549430  42.659629
7     CO          3  457514  35.522956
8     CO          5  280995  21.817415
9     WA          2  828238  35.696929
10    WA          4  719366  31.004563
11    WA          6  772590  33.298509

【讨论】：

@Cancer 这是我最喜欢的答案，因为它将 df 保持为 df（不转换为系列）并且仅添加 % 列。谢谢
这个答案的变体对我来说效果很好transform('max')
指向描述 transform() 的帖子的链接很棒。我认为这是一个比所选解决方案更好的解决方案，但需要学习转换（我认为这是一个优点:)

【解决方案4】：

为了简洁起见，我会使用 SeriesGroupBy：

In [11]: c = df.groupby(['state', 'office_id'])['sales'].sum().rename("count")

In [12]: c
Out[12]:
state  office_id
AZ     2            925105
       4            592852
       6            362198
CA     1            819164
       3            743055
       5            292885
CO     1            525994
       3            338378
       5            490335
WA     2            623380
       4            441560
       6            451428
Name: count, dtype: int64

In [13]: c / c.groupby(level=0).sum()
Out[13]:
state  office_id
AZ     2            0.492037
       4            0.315321
       6            0.192643
CA     1            0.441573
       3            0.400546
       5            0.157881
CO     1            0.388271
       3            0.249779
       5            0.361949
WA     2            0.411101
       4            0.291196
       6            0.297703
Name: count, dtype: float64

对于多个组，您必须使用转换（使用 Radical's df）：

In [21]: c =  df.groupby(["Group 1","Group 2","Final Group"])["Numbers I want as percents"].sum().rename("count")

In [22]: c / c.groupby(level=[0, 1]).transform("sum")
Out[22]:
Group 1  Group 2  Final Group
AAHQ     BOSC     OWON           0.331006
                  TLAM           0.668994
         MQVF     BWSI           0.288961
                  FXZM           0.711039
         ODWV     NFCH           0.262395
...
Name: count, dtype: float64

这似乎比其他答案的性能略高（只是不到 Radical 答案速度的两倍，对我来说大约 0.08 秒）。

【讨论】：

这超级快。我会推荐这是首选的熊猫方法。真正利用了 numpy 的矢量化和 pandas 索引。
这对我也很有效，因为我正在与多个小组一起工作。谢谢。
对于多组，不使用transform也可以做到：c / c.groupby(level=[0, 1]).sum()

【解决方案5】：

我认为这需要进行基准测试。使用OP的原始DataFrame，

df = pd.DataFrame({
    'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
    'office_id': range(1, 7) * 2,
    'sales': [np.random.randint(100000, 999999) for _ in range(12)]
})

第一个Andy Hayden

正如他的回答所评论的那样，Andy 充分利用了矢量化和 pandas 索引。

c = df.groupby(['state', 'office_id'])['sales'].sum().rename("count")
c / c.groupby(level=0).sum()

3.42 毫秒 ± 16.7 µs 每个循环
（平均值±标准差。7 次运行，每次 100 次循环）

第二个Paul H

state_office = df.groupby(['state', 'office_id']).agg({'sales': 'sum'})
state = df.groupby(['state']).agg({'sales': 'sum'})
state_office.div(state, level='state') * 100

4.66 毫秒 ± 24.4 µs 每个循环
（平均值±标准差。7 次运行，每次 100 次循环）

第三个exp1orer

这是最慢的答案，因为它会为级别 0 中的每个 x 计算 x.sum()。

对我来说，这仍然是一个有用的答案，尽管不是现在的形式。对于较小数据集的快速 EDA，apply 允许您使用 method chaining 将其写在一行中。因此，我们不再需要决定变量的名称，这实际上是您最宝贵的资源（您的大脑！！）的 computationally expensive。

这里是修改，

(
    df.groupby(['state', 'office_id'])
    .agg({'sales': 'sum'})
    .groupby(level=0)
    .apply(lambda x: 100 * x / float(x.sum()))
)

10.6 毫秒 ± 81.5 µs 每个循环
（平均值±标准差。7 次运行，每次 100 次循环）

所以没有人会关心小数据集上的 6 毫秒。但是，这是 3 倍的速度提升，并且在具有高基数 groupbys 的更大数据集上，这将产生巨大的影响。

添加到上面的代码中，我们制作了一个形状为 (12,000,000, 3) 的 DataFrame，其中包含 14412 个状态类别和 600 个 office_id，

import string

import numpy as np
import pandas as pd
np.random.seed(0)

groups = [
    ''.join(i) for i in zip(
    np.random.choice(np.array([i for i in string.ascii_lowercase]), 30000),
    np.random.choice(np.array([i for i in string.ascii_lowercase]), 30000),
    np.random.choice(np.array([i for i in string.ascii_lowercase]), 30000),
                       )
]

df = pd.DataFrame({'state': groups * 400,
               'office_id': list(range(1, 601)) * 20000,
               'sales': [np.random.randint(100000, 999999)
                         for _ in range(12)] * 1000000
})

使用安迪，

2 秒 ± 10.4 毫秒/循环
（平均值±标准偏差。7 次运行，每次 1 个循环）

和探险家

19 秒 ± 77.1 毫秒/循环
（平均值±标准偏差。7 次运行，每次 1 个循环）

所以现在我们看到 x10 在大型、高基数数据集上加速。

如果你对这三个答案进行紫外线，请务必对这三个答案进行紫外线！！

【讨论】：

【解决方案6】：

我意识到这里已经有了很好的答案。

尽管如此，我还是想贡献自己的力量，因为我觉得对于这样一个基本的、简单的问题，应该有一个一眼就能理解的简短解决方案。

它还应该以一种我可以将百分比添加为新列的方式工作，而数据框的其余部分保持不变。最后但同样重要的是，它应该以一种明显的方式推广到有多个分组级别的情况（例如，州和国家，而不是只有州）。

以下 sn-p 满足这些条件：

df['sales_ratio'] = df.groupby(['state'])['sales'].transform(lambda x: x/x.sum())

请注意，如果您仍在使用 Python 2，则必须将 lambda 项的分母中的 x 替换为 float(x)。

【讨论】：

这是 IMO 的最佳答案。唯一要添加的是* 100 以使其成为百分比。
@Bouncner：是的，严格来说，您必须乘以 100 才能获得百分比——或者将新变量从“sales_percentage”重命名为“sales_ratio”。就个人而言，我更喜欢后者，并相应地编辑了答案。感谢提及！
如果你有多个级别，这不起作用。
@irene：好点，谢谢！可能在那种情况下 df.reset_index().groupby(['state'])['sales'].transform(lambda x: x/x.sum()) 会起作用。还是我忽略了什么？
这个答案很棒。它不涉及创建一个临时的groupby 对象，非常简洁，从左到右读起来非常合乎逻辑。

【解决方案7】：

我知道这是一个老问题，但exp1orer's 对于具有大量唯一组的数据集（可能是因为 lambda）的回答非常慢。我根据他们的答案将其转换为数组计算，所以现在它超级快！下面是示例代码：

创建包含 50,000 个唯一组的测试数据框

import random
import string
import pandas as pd
import numpy as np
np.random.seed(0)

# This is the total number of groups to be created
NumberOfGroups = 50000

# Create a lot of groups (random strings of 4 letters)
Group1     = [''.join(random.choice(string.ascii_uppercase) for _ in range(4)) for x in range(NumberOfGroups/10)]*10
Group2     = [''.join(random.choice(string.ascii_uppercase) for _ in range(4)) for x in range(NumberOfGroups/2)]*2
FinalGroup = [''.join(random.choice(string.ascii_uppercase) for _ in range(4)) for x in range(NumberOfGroups)]

# Make the numbers
NumbersForPercents = [np.random.randint(100, 999) for _ in range(NumberOfGroups)]

# Make the dataframe
df = pd.DataFrame({'Group 1': Group1,
                   'Group 2': Group2,
                   'Final Group': FinalGroup,
                   'Numbers I want as percents': NumbersForPercents})

分组后的样子：

                             Numbers I want as percents
Group 1 Group 2 Final Group                            
AAAH    AQYR    RMCH                                847
                XDCL                                182
        DQGO    ALVF                                132
                AVPH                                894
        OVGH    NVOO                                650
                VKQP                                857
        VNLY    HYFW                                884
                MOYH                                469
        XOOC    GIDS                                168
                HTOY                                544
AACE    HNXU    RAXK                                243
                YZNK                                750
        NOYI    NYGC                                399
                ZYCI                                614
        QKGK    CRLF                                520
                UXNA                                970
        TXAR    MLNB                                356
                NMFJ                                904
        VQYG    NPON                                504
                QPKQ                                948
...
[50000 rows x 1 columns]

数组求百分比方法：

# Initial grouping (basically a sorted version of df)
PreGroupby_df = df.groupby(["Group 1","Group 2","Final Group"]).agg({'Numbers I want as percents': 'sum'}).reset_index()
# Get the sum of values for the "final group", append "_Sum" to it's column name, and change it into a dataframe (.reset_index)
SumGroup_df = df.groupby(["Group 1","Group 2"]).agg({'Numbers I want as percents': 'sum'}).add_suffix('_Sum').reset_index()
# Merge the two dataframes
Percents_df = pd.merge(PreGroupby_df, SumGroup_df)
# Divide the two columns
Percents_df["Percent of Final Group"] = Percents_df["Numbers I want as percents"] / Percents_df["Numbers I want as percents_Sum"] * 100
# Drop the extra _Sum column
Percents_df.drop(["Numbers I want as percents_Sum"], inplace=True, axis=1)

此方法大约需要 ~0.15 秒

最佳答案法（使用 lambda 函数）：

state_office = df.groupby(['Group 1','Group 2','Final Group']).agg({'Numbers I want as percents': 'sum'})
state_pcts = state_office.groupby(level=['Group 1','Group 2']).apply(lambda x: 100 * x / float(x.sum()))

此方法需要大约 21 秒才能产生相同的结果。

结果：

      Group 1 Group 2 Final Group  Numbers I want as percents  Percent of Final Group
0        AAAH    AQYR        RMCH                         847               82.312925
1        AAAH    AQYR        XDCL                         182               17.687075
2        AAAH    DQGO        ALVF                         132               12.865497
3        AAAH    DQGO        AVPH                         894               87.134503
4        AAAH    OVGH        NVOO                         650               43.132050
5        AAAH    OVGH        VKQP                         857               56.867950
6        AAAH    VNLY        HYFW                         884               65.336290
7        AAAH    VNLY        MOYH                         469               34.663710
8        AAAH    XOOC        GIDS                         168               23.595506
9        AAAH    XOOC        HTOY                         544               76.404494

【讨论】：

【解决方案8】：

在列或索引之间查找百分比的最优雅方法是使用pd.crosstab。

样本数据

df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999) for _ in range(12)]})

输出数据框是这样的

print(df)

        state   office_id   sales
    0   CA  1   764505
    1   WA  2   313980
    2   CO  3   558645
    3   AZ  4   883433
    4   CA  5   301244
    5   WA  6   752009
    6   CO  1   457208
    7   AZ  2   259657
    8   CA  3   584471
    9   WA  4   122358
    10  CO  5   721845
    11  AZ  6   136928

只需指定要聚合的索引、列和值。 normalize 关键字将根据上下文计算跨索引或列的百分比。

result = pd.crosstab(index=df['state'], 
                     columns=df['office_id'], 
                     values=df['sales'], 
                     aggfunc='sum', 
                     normalize='index').applymap('{:.2f}%'.format)




print(result)
office_id   1   2   3   4   5   6
state                       
AZ  0.00%   0.20%   0.00%   0.69%   0.00%   0.11%
CA  0.46%   0.00%   0.35%   0.00%   0.18%   0.00%
CO  0.26%   0.00%   0.32%   0.00%   0.42%   0.00%
WA  0.00%   0.26%   0.00%   0.10%   0.00%   0.63%

【讨论】：

【解决方案9】：

您可以将sum 整个DataFrame 除以state 总数：

# Copying setup from Paul H answer
import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999) for _ in range(12)]})
# Add a column with the sales divided by state total sales.
df['sales_ratio'] = (df / df.groupby(['state']).transform(sum))['sales']

df

返回

    office_id   sales state  sales_ratio
0           1  405711    CA     0.193319
1           2  535829    WA     0.347072
2           3  217952    CO     0.198743
3           4  252315    AZ     0.192500
4           5  982371    CA     0.468094
5           6  459783    WA     0.297815
6           1  404137    CO     0.368519
7           2  222579    AZ     0.169814
8           3  710581    CA     0.338587
9           4  548242    WA     0.355113
10          5  474564    CO     0.432739
11          6  835831    AZ     0.637686

但请注意，这仅适用于除 state 之外的所有列都是数字的，从而可以对整个 DataFrame 求和。例如，如果 office_id 是字符，则会出现错误：

df.office_id = df.office_id.astype(str)
df['sales_ratio'] = (df / df.groupby(['state']).transform(sum))['sales']

TypeError: /: 'str' 和 'str' 的操作数类型不受支持

【讨论】：

我编辑指出，这仅适用于除groupby 列之外的所有列都是数字的情况。但它在其他方面非常优雅。有没有办法让它与其他 str 列一起使用？
据我所知：stackoverflow.com/questions/34099684/…

【解决方案10】：

import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999) for _ in range(12)]})

df.groupby(['state', 'office_id'])['sales'].sum().rename("weightage").groupby(level = 0).transform(lambda x: x/x.sum())
df.reset_index()

输出：

    state   office_id   weightage
0   AZ  2   0.169814
1   AZ  4   0.192500
2   AZ  6   0.637686
3   CA  1   0.193319
4   CA  3   0.338587
5   CA  5   0.468094
6   CO  1   0.368519
7   CO  3   0.198743
8   CO  5   0.432739
9   WA  2   0.347072
10  WA  4   0.355113
11  WA  6   0.297815

【讨论】：

【解决方案11】：

我认为这可以在 1 行中解决问题：

df.groupby(['state', 'office_id']).sum().transform(lambda x: x/np.sum(x)*100)

【讨论】：

我相信它会占用数据集的所有列。在这种情况下，只有一个。如果您有多个并且想要对单个执行此操作，只需在 groupby 表达式之后指定它： df.groupby(['state', 'office_id'])[[YOUR COLUMN NAME HERE]].etc 如果需要为了保持其他列不变，只需重新分配特定列
@louisD：我非常喜欢你试图保持简短的方法。不幸的是，当我尝试按照您的建议重新分配列时，出现两个错误：“ValueError: Buffer dtype mismatch, expected 'Python object' but got 'long long'”，另外（在处理第一个异常期间）：“ TypeError：插入列的索引与框架索引不兼容”我使用的代码如下：df['percent'] = df.groupby(['state', 'office_id']).sum().transform(lambda x: x/np.sum(x)*100) 因此，我将发布一个单独的答案来解决这个问题。

【解决方案12】：

我使用的简单方法是在 2 个 groupby 之后进行合并，然后进行简单除法。

import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999) for _ in range(12)]})

state_office = df.groupby(['state', 'office_id'])['sales'].sum().reset_index()
state = df.groupby(['state'])['sales'].sum().reset_index()
state_office = state_office.merge(state, left_on='state', right_on ='state', how = 'left')
state_office['sales_ratio'] = 100*(state_office['sales_x']/state_office['sales_y'])

   state  office_id  sales_x  sales_y  sales_ratio
0     AZ          2   222579  1310725    16.981365
1     AZ          4   252315  1310725    19.250033
2     AZ          6   835831  1310725    63.768601
3     CA          1   405711  2098663    19.331879
4     CA          3   710581  2098663    33.858747
5     CA          5   982371  2098663    46.809373
6     CO          1   404137  1096653    36.851857
7     CO          3   217952  1096653    19.874290
8     CO          5   474564  1096653    43.273852
9     WA          2   535829  1543854    34.707233
10    WA          4   548242  1543854    35.511259
11    WA          6   459783  1543854    29.781508

【讨论】：

【解决方案13】：

df = pd.DataFrame({'state': ['CA', 'WA', 'CO', 'AZ'] * 3,
               'office_id': list(range(1, 7)) * 2,
               'sales': [np.random.randint(100000, 999999)
                         for _ in range(12)]})

grouped = df.groupby(['state', 'office_id'])
100*grouped.sum()/df[["state","sales"]].groupby('state').sum()

返回：

sales
state   office_id   
AZ  2   54.587910
    4   33.009225
    6   12.402865
CA  1   32.046582
    3   44.937684
    5   23.015735
CO  1   21.099989
    3   31.848658
    5   47.051353
WA  2   43.882790
    4   10.265275
    6   45.851935

【讨论】：

【解决方案14】：

作为一个也在学习 pandas 的人，我发现其他答案有点含蓄，因为 pandas 将大部分工作隐藏在幕后。即通过自动匹配列和索引名称来操作操作的工作方式。这段代码应该相当于@exp1orer接受的答案的逐步版本

对于df，我将使用别名state_office_sales 来称呼它：

                  sales
state office_id        
AZ    2          839507
      4          373917
      6          347225
CA    1          798585
      3          890850
      5          454423
CO    1          819975
      3          202969
      5          614011
WA    2          163942
      4          369858
      6          959285

state_total_sales 是state_office_sales 按index level 0（最左侧）中的总和分组。

In:   state_total_sales = df.groupby(level=0).sum()
      state_total_sales

Out: 
       sales
state   
AZ     2448009
CA     2832270
CO     1495486
WA     595859

因为两个数据框共享一个索引名和一个列名，所以 pandas 会通过共享索引找到合适的位置，例如：

In:   state_office_sales / state_total_sales

Out:  

                   sales
state   office_id   
AZ      2          0.448640
        4          0.125865
        6          0.425496
CA      1          0.288022
        3          0.322169
        5          0.389809
CO      1          0.206684
        3          0.357891
        5          0.435425
WA      2          0.321689
        4          0.346325
        6          0.331986

为了更好地说明这一点，这里是一个带有 XX 的部分总数，没有等价物。 Pandas 会根据索引和列名匹配位置，没有重叠的地方 pandas 会忽略它：

In:   partial_total = pd.DataFrame(
                      data   =  {'sales' : [2448009, 595859, 99999]},
                      index  =             ['AZ',    'WA',   'XX' ]
                      )
      partial_total.index.name = 'state'


Out:  
         sales
state
AZ       2448009
WA       595859
XX       99999

In:   state_office_sales / partial_total

Out: 
                   sales
state   office_id   
AZ      2          0.448640
        4          0.125865
        6          0.425496
CA      1          NaN
        3          NaN
        5          NaN
CO      1          NaN
        3          NaN
        5          NaN
WA      2          0.321689
        4          0.346325
        6          0.331986

当没有共享索引或列时，这一点变得非常清楚。这里missing_index_totals 等于state_total_sales，只是它没有索引名称。

In:   missing_index_totals = state_total_sales.rename_axis("")
      missing_index_totals

Out:  
       sales
AZ     2448009
CA     2832270
CO     1495486
WA     595859

In:   state_office_sales / missing_index_totals 

Out:  ValueError: cannot join with no overlapping index names

【讨论】：

【解决方案15】：

一线解决方案：

df.join(
    df.groupby('state').agg(state_total=('sales', 'sum')),
    on='state'
).eval('sales / state_total')

这会返回一系列每个办公室的比率——可以单独使用或分配给原始数据框。

【讨论】：