パンダとグループの合計の割合


148

これは明らかに単純ですが、派手な初心者として私は行き詰まっています。

そのオフィスのState、Office ID、およびSalesの3つの列を含むCSVファイルがあります。

特定の州のオフィスごとの売上のパーセンテージを計算したい(各州のパーセンテージの合計が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

分数を計算するために全体のを合計するのstateレベルに「到達」する方法を理解できないようです。groupbysalesstate


3
df['sales'] / df.groupby('state')['sales'].transform('sum')最も明確な答えのようです。
ポールルージュ

回答:


207

ポールHの答えは、あなたが二加える必要があります右のことであるgroupbyオブジェクトを、しかし、あなたは簡単な方法でパーセンテージを計算することができます-ちょうどと分けて合計で列を。ポールHの答えの始まりをコピー:groupbystate_officesales

# 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

1
何が起きてる?私が理解しているように、 xはある種のテーブルなので、100 * x直感的には意味がありません(特に、一部のセルにAZ、... などの文字列が含まれている場合)。
dhardy、2015

5
@dhardy state_officeはマルチインデックスを持つシリーズです- つまり、値がすべて数値の1つの列にすぎません。groupbyを実行すると、それぞれxがその列のサブセットになります。それは理にかなっていますか?
exp1orer 2015

2
多分それは私のために働かなかった。Python 3のパンダの動作は少し異なりますか?
dhardy 2015

1
どういうlevel=0意味ですか?
van_d39 2016年

3
@Veenitこれは、列の1つではなく、インデックスの最初のレベルでグループ化していることを意味します。
exp1orer 2016年

54

状態ごとにグループ化する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

level='state'でkwargは、divの値にデータフレームの基部を接合/ブロードキャストにパンダを伝えるstate指標のレベル。


4
この方法は、3つのインデックスがある場合に機能しますか?最初に3列でgroupbyを行いました。次に、2つだけで2番目のgroupbyを実行し、合計を計算しました。それから私は使用しようとしますdivlevel=["index1", "index2"]、それは私にそれを教えてくれJoin on level between two MultiIndex objects is ambiguousます。
Ger

@Gerそれは機能しますが、その説明からあなたが間違っていることを私が理解することはできません。もう少しサイトを検索してください。何も見つからない場合は、問題を示す再現可能な例を使用して新しい質問を作成します。stackoverflow.com/questions/20109391/…–
ポールH

34

簡潔にするために、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の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の回答の2倍の速度未満です。0.08秒以下)。


5
これは超高速です。私はこれを優先するパンダのアプローチとしてお勧めします。numpyのベクトル化とパンダのインデックス作成を実際に利用しています。
Charles

複数のグループで作業しているので、これも私にとってはうまくいきました。ありがとう。
アイリーン、

27

これにはベンチマークが必要だと思います。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はベクトル化とパンダのインデックス作成を最大限に活用しています。

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

ループあたり3.42 ms ±16.7 µs
(7回の実行の平均±標準偏差、それぞれ100ループ)


セカンドポール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 ms ±24.4 µs
(7回の実行の平均±標準偏差、各100ループ)


3回目の探索者

これは、レベル0のx.sum()それぞれについて計算するため、最も遅い回答xです。

私にとって、これは現在の形ではありませんが、依然として有用な答えです。小さなデータセットですばやくEDAをapply実行するには、メソッドチェーンを使用してこれを1行で記述できます。したがって、実際には計算コストが非常に高い変数の名前を決定する必要がなくなります。最も貴重なリソース(脳!!)に対してます。

ここに変更があります

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

ループあたり10.6 ms ±81.5 µs
(7回の実行の平均±標準偏差、各100ループ)


したがって、小さなデータセットで6msを気にする人はいません。ただし、これは3倍のスピードアップであり、カーディナリティの高いgroupbyを使用する大規模なデータセットでは、大きな違いが生じます。

上記のコードに加えて、14412の状態カテゴリと600のoffice_idを持つ形状(12,000,000、3)のDataFrameを作成します。

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 s ±10.4 ms
(7ランの平均±標準偏差、各1ループ)

およびexp1orer

ループあたり19 s ±77.1 ms
(7つの実行の平均±標準偏差、各1ループ)

大きなカーディナリティのデータセットでx10がスピードアップすることがわかります。


これをUVする場合は、必ずこれら3つの回答をUVしてください。


17

(このソリューションは、この記事https://pbpython.com/pandas_transform.htmlからヒントを得ています

私は次の解決策を使用する最も簡単な(そしておそらく最速の)方法を見つけますtransformation

トランスフォーメーション:集約ではデータの縮小バージョンを返す必要がありますが、トランスフォーメーションでは、再結合するために完全なデータの一部のトランスフォームバージョンを返すことができます。このような変換では、出力は入力と同じ形状です。

したがって、を使用するtransformationと、ソリューションは1ライナーになります。

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

3
@Cancerこれは、dfを(系列に変換せずに)dfとして保持し、%列を追加するだけなので、私のお気に入りの回答です。ありがとう
T.Fung

この回答のばらつきがで私のために非常によく働いたtransform('max')
Sheldore

11

これは古い質問であることはわかっていますが、一意のグループが多数あるデータセット(おそらくラムダのため)の場合、exp1orerの回答は非常に遅くなります。私はそれを配列計算に変えるために彼らの答えを基に構築しましたので、今は超高速です!以下はサンプルコードです:

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秒かかります

トップアンサーメソッド(ラムダ関数を使用):

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

9

ここにはすでに良い答えがあることに気づきました。

それでも私は自分で貢献したいと思います。このような基本的な簡単な質問を感じるので、一目で理解できる短い解決策があるはずです。

また、パーセンテージを新しい列として追加し、残りのデータフレームはそのままにしておく方法でも機能するはずです。最後に重要なことですが、複数のグループ化レベル(例:州だけでなく州と国)がある場合に明白な方法で一般化する必要があります。

次のスニペットは、これらの基準を満たしています。

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

まだPython 2を使用している場合は、ラムダ項の分母のxをfloat(x)に置き換える必要があることに注意してください。


これがIMOの最良の回答です。追加するのは、* 100それをパーセンテージにすることだけです。
Bouncner

1
@Bouncner:はい、厳密に言えば、パーセンテージを取得するには100を掛ける必要があります。または、新しい変数の名前を「sales_percentage」から「sales_ratio」に変更します。個人的には後者を好み、それに応じて回答を編集しました。言及してくれてありがとう!
MightyCurious

2
複数のレベルがある場合、これは機能しません。
アイリーン2013年

@irene:良い点、ありがとう!おそらくその場合、df.reset_index()。groupby(['state'])['sales']。transform(lambda x:x / x.sum())が機能します。または私は何かを見落としているか?
MightyCurious

1
この答えは素晴らしいです。一時的なgroupbyオブジェクトの作成は含まれず、非常に簡潔で、論理的に左から右に読みます。
C.ブラウン

7

列またはインデックス全体のパーセンテージを見つける最もエレガントな方法は、 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%

3

あなたsumは全体DataFramestate合計で割ることができます:

# 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列で機能させる方法はありますか?
マックスジェニス2017年

ではない私の知る限り:stackoverflow.com/questions/34099684/...
イギー

2

私はこれが1行でトリックを行うと思います:

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

データセットのすべての列が必要だと思います。この場合は1つだけです。複数あり、この操作を単一の操作で実行したい場合は、groupby式の後に指定します:df.groupby(['state'、 'office_id'])[[YOUR COLUMN NAME HERE]]。etc他の列をそのままにしておくには、特定の列を再割り当てします
louisD

@louisD:私はそれを短くしようとするあなたのアプローチがとても好きです。残念ながら、あなたが提案したように列を再割り当てしようとすると、「ValueError:バッファdtypeの不一致、 'Pythonオブジェクト'が必要ですが 'long long'が発生しました」と、さらに(最初の例外の処理中): " TypeError:フレームインデックスと挿入された列の非互換のインデックス "私が使用したコードは次のとおりです:df ['percent'] = df.groupby(['state'、 'office_id'])。sum()。transform(lambda x: x / np.sum(x)* 100)したがって、これを修正するために別の回答を投稿します。
MightyCurious

1

私が使用した単純な方法は、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

1
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

0

パンダも学んでいる誰かとして、パンダはほとんどの仕事を舞台裏で隠しているので、他の人は少し暗黙の答えを見つけました。つまり、列名とインデックス名を自動的に照合することにより、操作がどのように機能するかです。このコードは、@ 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

2つのデータフレームはインデックス名と列名を共有しているため、パンダは次のような共有インデックスを通じて適切な場所を見つけます。

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、同等のものがないaの部分的な合計を次に示します。パンダは、インデックスと列名に基づいて場所を照合します。重複がない場合、パンダはそれを無視します。

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

-1

ワンラインソリューション:

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

これは、一連のオフィスごとの比率を返します。独自に使用することも、元のデータフレームに割り当てることもできます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.