Pandas的使用技巧相关知识点总结

pandas的使用技巧相关知识点总结表.png

一、数学计算与统计基础

(1)基本参数axis和skipna

基本参数：axis、skipna

创建dataframe

df = pd.DataFrame({‘key1’:[4,5,3,np.nan,2],

‘key2’:[1,2,np.nan,4,5],

‘key3′:[1,2,3,’j’,’k’]},

index = [‘a’,’b’,’c’,’d’,’e’])

print(df)

print(df[‘key1’],df[‘key1’].dtype)

print(df[‘key2’],df[‘key2’].dtype)

print(df[‘key3’],df[‘key3’].dtype)

print(‘———————‘)

data = df.mean()

print(data)

.mean()计算均值，只统计元素是数字的列

按列计算每列的平均值，因key3含有字符串，返回只有key1和key2

单独统计一列，就索引要统计那列即可

单独统计key2这列

data2 = df[‘key2’].mean()

print(data2)

print(‘———————‘)

参数axis，默认为0，按列来计算

参数axis=1，则按行来计算

data3 = df.mean(axis=1)

print(data3)

print(‘———————‘)

从返回的data3结果来看，因原数据dataframe中含Nan，默认自动忽略Nan

参数skipna就是定义是否忽略Nan

参数skipna默认为True → 忽略Nan

参数skipna为False → 不忽略Nan，有Nan的列统计结果仍为Nan

data4 = df.mean(skipna=False)

data5 = df.mean(axis=1,skipna=False)

print(data4)

print(data5)

输出结果：

key1 key2 key3

a 4.0 1.0 1

b 5.0 2.0 2

c 3.0 NaN 3

d NaN 4.0 j

e 2.0 5.0 k

a 4.0

b 5.0

c 3.0

d NaN

e 2.0

Name: key1, dtype: float64 float64

a 1.0

b 2.0

c NaN

d 4.0

e 5.0

Name: key2, dtype: float64 float64

a 1

b 2

c 3

d j

e k

Name: key3, dtype: object object

a 2.5

b 3.5

c 3.0

d 4.0

e 3.5

dtype: float64

主要数学计算方法①

可用于Series和DataFrame

df = pd.DataFrame({‘key1’:np.arange(10),

‘key2’:np.random.rand(10)*10})

print(df)

print(‘—————–‘)

print(df.count(),’→ count统计非Na值的数量\n’)

print(df.min(),’→ min统计最小值\n’,df[‘key2′].max(),’→ max统计最大值\n’)

print(df.quantile(q=0.75),’→ quantile统计分位数，参数q确定位置\n’)

print(df.sum(),’→ sum求和\n’)

print(df.mean(),’→ mean求平均值\n’)

print(df.median(),’→ median求算数中位数，50%分位数\n’)

print(df.std(),’\n’,df.var(),’→ std,var分别求标准差，方差\n’)

print(df.skew(),’→ skew样本的偏度\n’)

print(df.kurt(),’→ kurt样本的峰度\n’)

输出结果：

key1 key2

0 0 4.253328

1 1 0.960379

2 2 3.511730

3 3 2.509393

4 4 0.054089

5 5 8.111823

6 6 4.844677

7 7 3.198498

8 8 3.034000

9 9 3.702352

主要数学计算方法②

可用于Series和DataFrame(2)

df = pd.DataFrame({‘key1’:np.arange(10),

‘key2’:np.random.rand(10)*10})

print(df)

print(‘—————–‘)

.cumsum()计算累计和

df[‘key1_s’] = df[‘key1’].cumsum()

df[‘key2_s’] = df[‘key2’].cumsum()

print(df,’→ cumsum样本的累计和\n’)

print(‘—————–‘)

.cumprod()计算累计积

df[‘key1_p’] = df[‘key1’].cumprod()

df[‘key2_p’] = df[‘key2’].cumprod()

print(df,’→ cumprod样本的累计积\n’)

print(‘—————–‘)

.cummax()求累计最大值，就是指累计的过程中要累计的数据中最大的值，就会一直被填充

.cummin()求累计最小值，就是指累计的过程中要列举的数据中最小的值，就会一直被填充

print(df.cummax(),’\n’,df.cummin(),’→ cummax,cummin分别求累计最大值，累计最小值\n’)

会填充key1，和key2的值

输出结果：

key1 key2

0 0 6.782298

1 1 8.826684

2 2 5.330644

3 3 1.284093

4 4 2.040580

5 5 5.194812

6 6 4.981178

7 7 3.467392

8 8 6.802496

9 9 1.212725

key1 key2 key1_s key2_s key1_p key2_p

0 0 6.782298 0 6.782298 0 6.782298

1 1 8.826684 1 15.608982 0 59.865201

2 2 5.330644 3 20.939626 0 319.120053

3 3 1.284093 6 22.223719 0 409.779981

4 4 2.040580 10 24.264299 0 836.188665

5 5 5.194812 15 29.459111 0 4343.843239

6 6 4.981178 21 34.440289 0 21637.455452

7 7 3.467392 28 37.907680 0 75025.529833

8 8 6.802496 36 44.710176 0 510360.865310

9 9 1.212725 45 45.922902 0 618927.582201 → cumprod样本的累计积

[‘a’ ‘s’ ‘d’ ‘v’ ‘c’ ‘f’ ‘g’]

0 a

1 s

2 d

3 v

4 c

5 f

6 g

dtype: object

[‘a’ ‘c’ ‘d’ ‘f’ ‘g’ ‘s’ ‘v’]

(4)值values的计数.value_counts()

值计数：.value_counts()

s = pd.Series(list(‘asdvasdcfgg’))

print(s)

print(‘—————–‘)

对s的values进行计数(次数)

sc = s.value_counts()

print(sc)

sc2 = s.value_counts(sort=False)

print(sc2)

得到一个新的Series，计算出不同值出现的频率

sort参数：排序，默认为True

print(‘—————–‘)

print(s)

输出结果：

0 a

1 s

2 d

3 v

4 a

5 s

6 d

7 c

8 f

9 g

10 g

dtype: object

0 a

1 s

2 d

3 v

4 a

5 s

6 d

7 c

8 f

9 g

10 g

dtype: object

(5)成员资格判断.isin()

成员资格：.isin()

s = pd.Series(np.arange(10,15))

df = pd.DataFrame({‘key1’:list(‘asdcbvasd’),

‘key2’:np.arange(4,13)})

print(s)

print(df)

print(‘—–‘)

print(s.isin([5,14])) # 判断5或14是否在s里

print(df.isin([‘a’,’bc’,’10’,8]))

用[]表示

得到一个布尔值的Series或者Dataframe

输出结果：

0 10

1 11

2 12

3 13

4 14

dtype: int32

key1 key2

0 a 4

1 s 5

2 d 6

3 c 7

4 b 8

5 v 9

6 a 10

7 s 11

8 d 12

key1 key2

0 a hee

1 b fv

2 c w

3 d hija

4 e 123

5 f NaN

字符串常用方法①- lower，upper，len，startswith，endswith

s = pd.Series([‘A’,’b’,’bbhello’,’123′,np.nan])

print(s)

print(‘—————-‘)

将文本数据的字符串字母变小写

print(s.str.lower(),’→ lower小写\n’)

将文本数据的字符串字母变大写

print(s.str.upper(),’→ upper大写\n’)

计数每行数据的字符串长度

print(s.str.len(),’→ len字符长度\n’)

print(s.str.startswith(‘b’),’→ 判断起始是否为a\n’)

print(s.str.endswith(‘3′),’→ 判断结束是否为3\n’)

输出结果：

0 A

1 b

2 bbhello

3 123

4 NaN

dtype: object

字符串常用方法② – strip

创建Series和Dataframe

s = pd.Series([‘ jack’, ‘jill ‘, ‘ jesse ‘, ‘frank’])

df = pd.DataFrame(np.random.randn(3, 2), columns=[‘ Column A ‘, ‘ Column B ‘],

index=range(3))

print(s)

print(df)

print(‘————-‘)

print(s.str.strip()) # 去除字符串中的空格

print(s.str.lstrip()) # 去除字符串中的左空格

print(s.str.rstrip()) # 去除字符串中的右空格

df.columns = df.columns.str.strip()

print(df)

这里去掉了columns的前后空格，但没有去掉中间空格

那就可以用replace将中间空格替换为其他

输出结果：

0 jack

1 jill

2 jesse

3 frank

dtype: object

Column A Column B

0 -0.680736 0.817757

1 -1.037254 -1.264084

2 0.424927 -1.150749

字符串常用方法(3) – replace

df = pd.DataFrame(np.random.randn(3, 2), columns=[‘ Column A ‘, ‘ Column B ‘],

index=range(3))

print(df)

df.columns = df.columns.str.replace(‘ ‘,’-‘)

print(df)

用.replace替换，将中间的空格用”-“替换

df.columns = df.columns.str.replace(‘-‘,’hehe’,n=1)

print(df)

“-“用hehe来替换，且只替换一个”-“

参数n=1，表示替换个数为1个

输出结果：

Column A Column B

0 0.143967 -0.426351

1 -1.210151 0.320342

2 -0.825522 -1.299585

-Column-A- -Column-B-

0 0.143967 -0.426351

1 -1.210151 0.320342

2 -0.825522 -1.299585

heheColumn-A- heheColumn-B-

0 0.143967 -0.426351

1 -1.210151 0.320342

2 -0.825522 -1.299585

[‘a’, ‘b’, ‘c’]

0 1 2

0 a b c

1 1 2 3

2 NaN NaN NaN

3 NaN NaN NaN

0 1

0 a b,c

1 1 2,3

2 NaN NaN

3 NaN NaN

0 1

0 a,b c

1 1,2 3

2 NaN NaN

3 NaN NaN

0 A

1 b

2 C

3 b

4 1

5 NaN

6 h

dtype: object

0 A

1 b

2 C

3 bb

4 12

5 NaN

6 hj

dtype: object

0 h

1 f

2 w

3 h

4 1

5 NaN

Name: key2, dtype: object

三、pandas的合并merge、join

Pandas具有全功能的，高性能内存中连接操作，与SQL等关系数据库非常相似。

(1)合并merge

pd.merge(left, right, how=’inner’, on=None, left_on=None, right_on=None,left_index=False, right_index=False, sort=True,suffixes=(‘_x’, ‘_y’), copy=True, indicator=False)

A B key C D

0 A0 B0 K0 C0 D0

1 A1 B1 K1 C1 D1

2 A2 B2 K2 C2 D2

3 A3 B3 K3 C3 D3

A B key1 key2 C D

0 A0 B0 K0 K0 C0 D0

1 A2 B2 K1 K0 C1 D1

2 A2 B2 K1 K0 C2 D2

A B key1 key2 C D

0 A0 B0 K0 K0 C0 D0

1 A2 B2 K1 K0 C1 D1

2 A2 B2 K1 K0 C2 D2

A B key1 key2 C D

0 A0 B0 K0 K0 C0 D0

1 A1 B1 K0 K1 NaN NaN

2 A2 B2 K1 K0 C1 D1

3 A2 B2 K1 K0 C2 D2

4 A3 B3 K2 K1 NaN NaN

参数 left_on, right_on, left_index, right_index → 当键不为一个列时，可以单独设置左键与右键

df1 = pd.DataFrame({‘lkey’:list(‘bbacaab’),

‘data1’:range(7)})

df2 = pd.DataFrame({‘rkey’:list(‘abd’),

‘date2’:range(3)})

print(pd.merge(df1, df2, left_on=’lkey’, right_on=’rkey’))

print(‘——‘)

df1以’lkey’为键，df2以’rkey’为键

df1 = pd.DataFrame({‘key’:list(‘abcdfeg’),

‘data1’:range(7)})

df2 = pd.DataFrame({‘date2’:range(100,105)},

index = list(‘abcde’))

print(pd.merge(df1, df2, left_on=’key’, right_index=True))

df1以’key’为键，df2以index为键

left_index：为True时，第一个df以index为键，默认False

right_index：为True时，第二个df以index为键，默认False

所以left_on, right_on, left_index, right_index可以相互组合：

left_on + right_on, left_on + right_index, left_index + right_on, left_index + right_index

输出结果：

data1 lkey date2 rkey

0 0 b 1 b

1 1 b 1 b

2 6 b 1 b

3 2 a 0 a

4 4 a 0 a

5 5 a 0 a

参数 sort

df1 = pd.DataFrame({‘key’:list(‘bbacaab’),

‘data1’:[1,3,2,4,5,9,7]})

df2 = pd.DataFrame({‘key’:list(‘abd’),

‘date2’:[11,2,33]})

print(df1)

print(df2)

x1 = pd.merge(df1,df2, on = ‘key’, how = ‘outer’)

x2 = pd.merge(df1,df2, on = ‘key’, sort=True, how = ‘outer’)

print(x1)

print(x2)

print(‘——‘)

sort：按照字典顺序通过 连接键 对结果DataFrame进行排序。默认为False，设置为False会大幅提高性能

print(x2.sort_values(‘data1’)) # 对data1进行排序

也可直接用Dataframe的排序方法：sort_values，sort_index

输出结果：

data1 key

0 1 b

1 3 b

2 2 a

3 4 c

4 5 a

5 9 a

6 7 b

date2 key

0 11 a

1 2 b

2 33 d

data1 key date2

0 1.0 b 2.0

1 3.0 b 2.0

2 7.0 b 2.0

3 2.0 a 11.0

4 5.0 a 11.0

5 9.0 a 11.0

6 4.0 c NaN

7 NaN d 33.0

data1 key date2

0 2.0 a 11.0

1 5.0 a 11.0

2 9.0 a 11.0

3 1.0 b 2.0

4 3.0 b 2.0

5 7.0 b 2.0

6 4.0 c NaN

7 NaN d 33.0

data1 key

0 1 b

1 3 b

2 2 a

3 4 c

4 5 a

5 9 a

6 7 b

date2 key

0 11 a

1 2 b

2 33 d

data1 key_1 date2 key_2

0 1 b 11 a

1 3 b 2 b

2 2 a 33 d

data1 key date2

0 1 b 11.0

1 3 b 2.0

2 2 a 33.0

3 4 c NaN

4 5 a NaN

5 9 a NaN

6 7 b NaN

连接：concat

pd.concat(objs, axis=0, join=’outer’, join_axes=None, ignore_index=False,keys=None, levels=None, names=None, verify_integrity=False,copy=True)

s1 = pd.Series([1,2,3])

s2 = pd.Series([2,3,4])

s3 = pd.Series([1,2,3],index=list(‘ach’))

s4 = pd.Series([2,3,4],index=[‘b’,’e’,’d’])

print(s4)

【参数axis】

concat连接s1和s2，

参数axis=0，是行+行，返回series

sc = pd.concat([s1,s2])

print(sc,type(sc))

concat连接s3和s4

sc2 = pd.concat([s3,s4])

print(sc2.sort_index()) # 对连接的series的index排序

print(‘——————–‘)

参数axis=1，是列+列，返回dataframe

df = pd.concat([s1,s2],axis=1)

print(df,type(df))

输出结果：

0 1

1 2

2 3

0 2

1 3

2 4

dtype: int64

a 1

b 2

c 2

d 4

e 3

h 3

dtype: int64

连接方式：join，join_axes

s1 = pd.Series([1,2,3],index=list(‘abc’))

s2 = pd.Series([2,3,4],index=list(‘bcd’))

print(s1)

print(s2)

print(‘—————‘)

【参数join】

参数join默认为outer，取联合；join为inner取交集。

print(pd.concat([s1,s2],axis=1,join=’inner’))

print(‘—————‘)

【参数join_axes】

参数join_axes默认为None，若定义join_axes，可以指定联合的index

print(pd.concat([s1,s2],axis=1,join_axes=[[‘a’,’b’,’c’]]))

输出结果：

a 1

b 2

c 3

dtype: int64

b 2

c 3

d 4

dtype: int64

0 1

a 1 NaN

b 2 2.0

c 3 3.0

0 1 2

0 NaN 3.0 5.0

1 -4.6 NaN -8.2

2 -5.0 7.0 4.0

0 False

1 True

2 True

3 True

4 False

5 True

6 True

7 False

8 False

9 False

10 True

11 True

12 True

dtype: bool

0 1

4 2

7 3

8 4

9 5

dtype: int64

0 False

1 True

2 False

3 False

4 False

dtype: bool

0 False

1 True

2 False

3 True

4 False

Name: key2, dtype: bool

(2)替换.replace

替换 .replace

s = pd.Series(list(‘ascaazsd’))

print(s)

print(‘———‘)

print(s.replace(‘a’, np.nan)) # 用np.nan替换字符串”a”

print(‘———‘)

可一次性替换一个值或多个值

print(s.replace([‘a’,’s’] ,np.nan))

print(‘———‘)

可传入列表或字典

print(s.replace({‘a’:’hello world!’,’s’:123}))

‘a’:’hello world!’ → a 用hello world替换

输出结果：

0 a

1 s

2 c

3 a

4 a

5 z

6 s

7 d

dtype: object

0 NaN

1 NaN

2 c

3 NaN

4 NaN

5 z

6 NaN

7 d

dtype: object

分组 – groupby()

df = pd.DataFrame({‘A’ : [‘foo’, ‘bar’, ‘foo’, ‘bar’,’foo’, ‘bar’, ‘foo’, ‘foo’],

‘B’ : [‘one’, ‘one’, ‘two’, ‘three’, ‘two’, ‘two’, ‘one’, ‘three’],

‘C’ : np.random.randn(8),

‘D’ : np.random.randn(8)})

print(df)

print(‘——‘)

print(df.groupby(‘A’),type(df.groupby(‘A’)))

print(‘——‘)

直接分组得到一个groupby对象，是一个中间数据，没有进行计算

a = df.groupby(‘A’).mean() # 以A分组，算平均值

print(a,type(a))

print(‘——‘)

b = df.groupby([‘A’,’B’]).mean() # 以A、B分组，算平均值

print(b,type(b))

print(‘——‘)

c = df.groupby(‘A’)[‘D’].mean() # 以A分组，再取个D列求D的平均值

print(c)

通过分组后的计算，得到一个新的dataframe

默认axis = 0，以行来分组

可单个或多个([])列分组

输出结果：

A B C D

0 foo one -0.644577 1.118908

1 bar one 1.179229 -0.386515

2 foo two -1.060731 0.536817

3 bar three 1.151450 -1.321295

4 foo two 0.388789 2.147647

5 bar two 0.059214 1.008346

6 foo one 1.364315 -0.617321

7 foo three -0.834223 -0.671149

C D

A

bar 0.796631 -0.233155

foo -0.157285 0.502980

A

bar -0.233155

foo 0.502980

Name: D, dtype: float64

[(‘A’, X Y

0 A 1

2 A 3), (‘B’, X Y

1 B 4

3 B 2)] → 可迭代对象，直接生成list

(‘A’, X Y

0 A 1

2 A 3) → 以元祖形式显示

A

X Y

0 A 1

2 A 3

B

X Y

1 B 4

3 B 2

{‘A’: Int64Index([0, 2], dtype=’int64′), ‘B’: Int64Index([1, 3], dtype=’int64′)}

Int64Index([0, 2], dtype=’int64′)

A B C D

0 foo one -1.145245 0.282188

1 bar one 1.098816 -1.229021

2 foo two -0.202471 1.313067

3 bar three 0.423064 -0.944102

4 foo two 1.035012 -0.159363

5 bar two 2.586997 -0.870078

6 foo one 0.549764 -0.323518

7 foo three -2.402178 0.990989

Int64Index([7], dtype=’int64′)

float64

data1 data2

0 0.269405 0.236738

1 0.000449 0.503876

object

key1 key2

0 a one

1 b two

{‘d’: ‘two’, ‘b’: ‘one’, ‘c’: ‘two’, ‘a’: ‘one’, ‘e’: ‘three’}

one two

0 1 5

1 9 13

2 17 21

3 25 29

通过函数分组

df = pd.DataFrame(np.arange(16).reshape(4,4),

columns = [‘a’,’b’,’c’,’d’],

index = [‘abc’,’bcd’,’aa’,’b’])

print(df,’\n’)

print(df.groupby(len).sum())

按照字母长度分组

a b c d

abc 0 1 2 3

bcd 4 5 6 7

aa 8 9 10 11

b 12 13 14 15

a b c d

1 12 13 14 15

2 8 9 10 11

3 4 6 8 10

多函数计算：agg()

多函数计算可以让分组数据同时计算两个以上的统计

df = pd.DataFrame({‘a’:[1,1,2,2],

‘b’:np.random.rand(4),

‘c’:np.random.rand(4),

‘d’:np.random.rand(4),})

print(df,’\n’)

print(df.groupby(‘a’).agg([‘mean’,np.sum]))

print(df.groupby(‘a’)[‘b’].agg({‘result1’:np.mean,

‘result2’:np.sum}))

函数写法可以用str，或者np.方法

可以通过list，dict传入，当用dict时，key名为columns

输出结果：

a b c d

0 1 0.689856 0.212391 0.575196

1 1 0.516206 0.871239 0.340175

2 2 0.440666 0.428301 0.573359

3 2 0.211181 0.900975 0.845924

b c d

mean sum mean sum mean sum

a

1 0.603031 1.206062 0.541815 1.083630 0.457686 0.915371

2 0.325924 0.651847 0.664638 1.329276 0.709641 1.419282

result2 result1

a

1 1.206062 0.603031

2 0.651847 0.325924

七、分组转换及一般性”拆分-应用-合并”

(1)数据分组转换transform

数据分组转换,transform

df = pd.DataFrame({‘data1’:np.random.rand(5),

‘data2’:np.random.rand(5),

‘key1’:list(‘aabba’),

‘key2’:[‘one’,’two’,’one’,’two’,’one’]})

print(df,’\n’)

k_mean = df.groupby(‘key1’).mean() # 以key1分组，求平均值

print(k_mean,’\n’)

print(pd.merge(df,k_mean,left_on=’key1′,right_index=True).add_prefix(‘mean_’)) # .add_prefix(‘mean_’)：添加前缀

print(‘—————‘)

通过分组、合并，得到一个包含均值的Dataframe

print(df.groupby(‘key2′).mean(),’\n’) # 按照key2分组求均值

print(df.groupby(‘key2’).transform(np.mean))

data1、data2每个位置元素取对应分组列的均值

字符串不能进行计算

输出结果：

data1 data2 key1 key2

0 0.295972 0.857439 a one

1 0.934285 0.278705 a two

2 0.302457 0.844987 b one

3 0.248708 0.549459 b two

4 0.978329 0.691800 a one

data1 data2

key1

a 0.736195 0.609315

b 0.275582 0.697223

mean_data1_x mean_data2_x mean_key1 mean_key2 mean_data1_y mean_data2_y

0 0.295972 0.857439 a one 0.736195 0.609315

1 0.934285 0.278705 a two 0.736195 0.609315

4 0.978329 0.691800 a one 0.736195 0.609315

2 0.302457 0.844987 b one 0.275582 0.697223

3 0.248708 0.549459 b two 0.275582 0.697223

key a b c d

date

2017-05-01 1.978948 NaN 3.127164 4.127823

2017-05-02 7.059673 6.444399 NaN 0.198809

2017-05-03 1.435535 4.657516 5.816060 NaN

values

date key

2017-05-01 a 1.0

c 1.0

d 1.0

2017-05-02 a 1.0

b 1.0

d 1.0

2017-05-03 a 1.0

b 1.0

c 1.0

(2)交叉表crosstab

交叉表做因子频率计算。

pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)

交叉表：crosstab，统计频率的时候用交叉表，如字符串只能计算频率

默认情况下，crosstab计算因子的频率表，比如用于str的数据透视分析

pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)

df = pd.DataFrame({‘A’: [1, 2, 2, 2, 2],

‘B’: [3, 3, 4, 4, 4],

‘C’: [1, 1, np.nan, 1, 1]})

print(df)

print(‘—–‘)

print(pd.crosstab(df[‘A’],df[‘B’]))

print(‘—–‘)

如果crosstab只接收两个Series，它将提供一个频率表。

用A的唯一值，统计B唯一值的出现次数

返回的频率表意思：B=3，A=1的频率为1，以此类推。

print(pd.crosstab(df[‘A’],df[‘B’],normalize=True))

print(‘—–‘)

normalize：默认False，将所有值除以值的总和进行归一化 → 为True时候显示百分比

返回的频率表是B=3，A=1的频率为1，总和为1+0+1+3=5，1/5=0.2

print(pd.crosstab(df[‘A’],df[‘B’],values=df[‘C’],aggfunc=np.sum))

print(‘—–‘)

values：可选，根据因子聚合的值数组

aggfunc：可选，如果未传递values数组，则计算频率表，如果传递数组，则按照指定计算

这里相当于以A和B界定分组，计算出每组中第三个系列C的值

print(pd.crosstab(df[‘A’],df[‘B’],values=df[‘C’],aggfunc=np.sum, margins=True))

margins：布尔值，默认值False，添加行/列边距(小计求和)

输出结果：

A B C

0 1 3 1.0

1 2 3 1.0

2 2 4 NaN

3 2 4 1.0

4 2 4 1.0

B 3 4

A

1 1.0 NaN

2 1.0 2.0

Original: https://blog.csdn.net/weixin_36084095/article/details/114911967
Author: 里灰啊
Title: python panda3d从入门_笔记：Python之Pandas的使用技巧