python-数据分析-pandas基础知识
文章目录
-
- 1.Series和DataFrame基础操作
-
- 添加列数据
- 添加行数据
- 删除行列
- Series和DataFrame数据计算
- 按行列排序
- 2.Series和DataFrame切片
- 3.数据的读取
- 4.pandas统计功能
- 5.处理缺失值
- 6.删除重复数据
- 7.数据离散分箱
- 8.哑变量处理
- 9.Pandas按键合并数据
- 10.Pandas值合并函数
- 11.Pandas合并重叠数据
- 12.groupby分组
- 13.apply函数
- 1.数据透视表
- 2.交叉表
1.Series和DataFrame基础操作
Pandas需要通过改变索引进行增加和删除内部数据
添加列数据
Dataframe.insert(loc, column, value, allow_duplicates=False)
| 参数 | 含义 |
|---|---|
| loc | 使用整数定义_列数据_插入的位置，必须是0到columns列标签的长度 |
| column | 可选字符串、数字或者object；列标签名 |
data={
'城市':['北京','上海','广州','深圳'],
'环比':[101.5,102.2,101.3,102.0],
'同比':[120.7,127.3,119.4,140.9],
'定基':[121.4,127.8,120.0,145.5]
}
df=pd.DataFrame(data,index=list('abcd'))
# 在最后一列添加数据
df['排名']=[1,2,3,4]
print(df)
城市 环比 同比 定基 排名
a 北京 101.5 120.7 121.4 1
b 上海 102.2 127.3 127.8 2
c 广州 101.3 119.4 120.0 3
d 深圳 102.0 140.9 145.5 4
#在位置（loc）为3的地方添加一列数据，名字叫（column）'排名',值（values）为1，2，3，4
loc=3
column='排名'
value=[1,2,3,4]
df.insert(loc, column, value, allow_duplicates=False)
# 输出
城市 环比 同比 排名 定基
a 北京 101.5 120.7 1 121.4
b 上海 102.2 127.3 2 127.8
c 广州 101.3 119.4 3 120.0
d 深圳 102.0 140.9 4 145.5
添加行数据
添加行数据需要使用reindex函数创建一个符合新索引的新对象。
DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)
| 参数 | 含义 |
|---|---|
| index, columns | 新的行列自定义索引 |
| fill_value | 重新索引中用于填充缺失位置的值 |
| method | 填充方法，ffill当前值向前填充，bfill向后填充 |
# loc[]按dataframe的索引在最后一行添加数据，默认是整数型
df.loc['e'] = ['武汉', 90,100,5,120] # 等价于df.loc['e',df.columns]
城市 环比 同比 排名 定基
a 北京 101.5 120.7 1 121.4
b 上海 102.2 127.3 2 127.8
c 广州 101.3 119.4 3 120.0
d 深圳 102.0 140.9 4 145.5
e 武汉 90.0 100.0 5 120.0
# loc[]按dataframe的索引在最后一列添加数据
df.loc[:, 'GDP'] = [100,99,98,97,96]
print(df)
城市 环比 同比 排名 定基 GDP
a 北京 101.5 120.7 1 121.4 100
b 上海 102.2 127.3 2 127.8 99
c 广州 101.3 119.4 3 120.0 98
d 深圳 102.0 140.9 4 145.5 97
e 武汉 90.0 100.0 5 120.0 96
#增加一个索引构成新索引
newi=df.index.insert(3,'e')
#按照新的行列索引构成新的DataFrame，填充值为0
ndf=df.reindex(index=newi,columns=df.columns,fill_value=0)
print(ndf)
城市 环比 同比 排名 定基
a 北京 101.5 120.7 1 121.4
b 上海 102.2 127.3 2 127.8
c 广州 101.3 119.4 3 120.0
e 0 0.0 0.0 0 0.0
d 深圳 102.0 140.9 4 145.5
#按照新的行列索引构成新的DataFrame，填充方法为向前填充
ndf=df.reindex(index=newi,columns=ndf.columns,method='ffill')
删除行列
DataFrame.drop (labels=None, axis=0, index=None, columns=None, level=None, inplace=False,
errors='raise’ )
| 参数 | 含义 |
|---|---|
| labels | 就是要删除的行列的名字，用列表给定 |
| axis | 默认为0，指删除行，因此删除columns时要指定axis=1 |
| index | 直接指定要删除的行 |
| columns | 直接指定要删除的列 |
| inplace=False | 默认该删除操作不改变原数据，而是返回一个执行删除操作后的新dataframe |
| inplace=True | 则会直接在原数据上进行删除操作，删除后无法返回 |
# 删除索引为'c'的一行 ,axis=0指删除行，=1为删除列
df1=df.drop('c',axis=0)
Series和DataFrame数据计算
df1=pd.DataFrame(np.random.random((2,3)),
index=list('ab'),
columns=list('abc'))
df2=pd.DataFrame(np.random.random((2,3)),
index=list('bc'),
columns=list('bcd'))
#索引相同的位置的数据相加
df1+df2
# 输出
a b c d
a NaN NaN NaN NaN
b NaN 0.162524 0.320636 NaN
c NaN NaN NaN NaN
#判断df1中大于0.5的数
df1>0.5
# 输出
a b c
a False False True
b True False False
#将df1中大于0.5的数重新赋值为6
df1[df1>0.5]=6
# 输出
a b c
a 0.409016 0.284512 6.000000
b 6.000000 0.139782 0.266547
按行列排序
索引排序
Series.sort_index(axis=0, ascending=True, inplace=False,···)
| 参数 | 含义 |
|---|---|
| axis | 轴直接排序。对于系列，只能为0 |
| ascending | 升序与降序排序 |
| inplace | 如果为True，则就地执行操作 |
Sr1=pd.DataFrame(np.random.random(5),
index=list('aghzb'))
#对索引排序
Sr1.sort_index(axis=0, ascending=True,)
#对索引排序，并选择降序
Sr1.sort_index(axis=0, ascending=False)
值排序
DataFrame.sort_values(by=‘##’,axis=0,ascending=True, inplace=False, ···)
| 参数 | 含义 |
|---|---|
| by | 指定列名(axis=0或’index’)或索引值(axis=1或’columns’) |
df = pd.DataFrame({
'b':[1,2,3,2],
'a':[4,3,2,1],
'c':[1,3,8,2]},index=[2,0,1,3])
# 按b列升序排序
df.sort_values(by='b')
#等同于df.sort_values(by='b',axis=0))
b a c
2 1 4 1
0 2 3 3
3 2 1 2
1 3 2 8
# 先按b列降序，再按a列升序排序
df.sort_values(by=['b','a'],axis=0,ascending=[False,True])
# 按行3升序排列
#必须指定axis=1
df.sort_values(by=3,axis=1)
# 按行3升序，行0降排列
df.sort_values(by=[3,0],axis=1,ascending=[True,False])
返回名次
Series.rank(axis=0,method=‘average’,na_option=‘keep’,ascending=True)
| 参数 | 含义 |
|---|---|
| method | {‘average’,‘min’,‘max’,‘first’,‘dense’}指定排名时用于破坏平级关系的method选项 |
# 根据数据的大小返回排名
Sr1.rank(axis=0,method='average',na_option='keep',ascending=True)
2.Series和DataFrame切片
Pandas的两种数据类型都可以使用numpy一样的数据格式进行索引，也可以使用loc和iloc进行更高级的索引与切片。
df.loc[]：获取具有特定标签的行(和/或列)，接受两个参数：行标和列标，当列标省略时，默认获取整行数据。两个参数都可以以字符，切片以及列表的形式传入。
df.iloc[]：用法和df.loc[]类似，最大的区别在于，loc是基于行列的标签进行检索，而iloc是基于位置进行检索。标签索引与内置索引混用：
get_loc()是一个索引方法，意思是“获取标签在这个索引中的位置”。注意，因为用iloc切片不包含它的端点，必须在这个值上加上1。
s = pd.Series(list("acbdfe"), index=[49, 48, 47, 0, 1, 2])
print('构建的Series:\n',s)
print('索引标签0处的值：',s.loc[0])
print('索引位置为0处的值：',s.iloc[0])
print('索引标签在0到1(包括1)之间的行：\n',s.loc[0:1])
print('索引位置在0到1之间的行(不包含1)：\n',s.iloc[0:1])
# 输出
索引标签0处的值： d
索引位置为0处的值： a
索引标签在0到1(包括1)之间的行：
0 d
1 f
dtype: object
索引位置在0到1之间的行(不包含1)：
49 a
dtype: object
s2 = pd.Series(s.index, index=s.values)
print('以英文标签为索引\n',s2)
print('所有在“c”和“e”之间的行(包括e):\n',s2.loc['c':'e'] )
# 输出
所有在“c”和“e”之间的行(包括e):
c 48
b 47
d 0
f 1
e 2
dtype: int64
df = pd.DataFrame(np.arange(25).reshape(5, 5),
index=list('abcde'),
columns=['x','y','z', 8, 9])
print(df)
print('行c及以上列z以下\n',df.loc['c': , :'z'])
print('所有行，但只有索引位置3的列\n',df.iloc[:, 3])
# 输出
行c及以上列z以下
x y z
c 10 11 12
d 15 16 17
e 20 21 22
所有行，但只有索引位置3的列
a 3
b 8
c 13
d 18
e 23
Name: 8, dtype: int32
df = pd.DataFrame(np.arange(25).reshape(5, 5),
index=list('abcde'),
columns=['x','y','z', 8, 9])
print('原始数据\n',df)
print('loc和ilic混用\n',df.iloc[:df.index.get_loc('c') + 1, :4])
# 输出
x y z 8
a 0 1 2 3
b 5 6 7 8
c 10 11 12 13
3.数据的读取
df_csv=pd.read_csv('CSV数据.csv')
df_txt=pd.read_table('txt数据.txt',sep=',')
df_excel=pd.read_excel('Excel数据.xlsx',sheet_name='test')
#将dataframe数据写入csv,txt,excel
df.to_csv('test.csv')
df.to_csv('test.txt')
df.to_excel('test1.xlsx')
4.pandas统计功能
Pandas基于NumPy，同样可以使用NumPy的函数对数据框进行描述性统计,pandas还提供了更加便利的方法来计算均值 ，如detail[‘amounts’].mean()。
pandas还提供了一个方法叫作describe，能够一次性得出数据框所有数值型特征的非空值数目、均值、四分位数、标准差。
| 方法名称 | 说明 | 方法名称 | 说明 |
|---|---|---|---|
| min | 最小值 | max | 最大值 |
| mean | 均值 | ptp | 极差 |
| median | 中位数 | std | 标准差 |
| var | 方差 | cov | 协方差 |
| sem | 标准误差 | mode | 众数 |
| skew | 样本偏度 | kurt | 样本峰度 |
| quantile | 四分位数 | count | 非空值数目 |
| describe | 描述统计 | mad | 平均绝对离差 |
| 函数名称 | 说明 |
|---|---|
| np.min/max | 最小/大值 |
| np.mean | 均值 |
| np.median | 中位数 |
| np.var | 方差 |
| np.ptp | 极差 |
| np.std | 标准差 |
| np.cov | 协方差 |
df = pd.DataFrame({
'b':[1,2,2,3],
'a':[4,3,2,1],
'c':[1,3,8,2]},index=[2,0,1,3])
np.max(df['a']) # df['a'].max()
df.min()
# 输出
b 1
a 1
c 1
dtype: int64
5.处理缺失值
| 方法 | 描述 |
|---|---|
| dropna() | 根据每个标签的值是否缺失数据来筛选标签，并根据允许缺失的数据来确定阈值 |
| fillna() | 用某些值填充缺失的数据或使用插值方法 |
| isnull() | 返回表明哪些值是缺失值的布尔值 |
| notnull() | isnull的反函数 |
DataFrame.dropna(self, axis=0, how=‘any’, thresh=None, subset=None, inplace=False)
how： 选择方式是全为空还是部分为空
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, **kwargs)
value： 它是一个用于填充空值的值
method： 一种用于填充重新索引的Series中的空值的方法
df = pd.DataFrame({
'a':[1,np.nan,2,3],
'b':[4,np.nan,2,1],
'c':[np.nan,np.nan,np.nan,np.nan]},
index=[2,0,1,3])
# 输出
a b c
2 1.0 4.0 NaN
0 NaN NaN NaN
1 2.0 2.0 NaN
3 3.0 1.0 NaN
# 按行删除空数据,选择删除都是空的数据:按列删除则axis=1
df.dropna(how='all',axis=0)
# 输出
a b c
2 1.0 4.0 NaN
1 2.0 2.0 NaN
3 3.0 1.0 NaN
# 填充数据,补充成某一个值
df.fillna(value=3.0)
# 填充数据,按照方法填充;ffill当前值向前填充，bfill向后填充
df.fillna(method='ffill')
# 输出
ffill当前值向前填充，bfill向后填充
a b c
2 1.0 4.0 NaN
0 1.0 4.0 NaN
1 2.0 2.0 NaN
3 3.0 1.0 NaN
6.删除重复数据
DataFrame.drop_duplicates(subset=[‘A’,‘B’],keep=‘first’,inplace=True)
subset： 列名，表示只考虑这两列，将这两列对应值相同的行进行去重。默认为subset=None表示考虑所有列
keep=‘first’： 保留第一次出现的重复行，是默认值。keep另外两个取值为“last”和False，分别表示保留最后一次出现的重复行和去除所有重复行
inplace=True： 表示直接在原来的DataFrame上删除重复项，而默认值False表示生成一个副本
df=pd.DataFrame({'one':[0,0,2,3],
'two':[0,0,6,6],
'three':[0,0,6,6],
'four':[0,1,2,3],},
index=['b','c','c','e'])
# 删除行重复数据,保留重复数据的第一行，数据不在原始数据上改动
df1=df.drop_duplicates(subset=['one','two'],keep='first',inplace=False)
# 输出
one two three four
b 0 0 0 0
c 2 6 6 2
e 3 6 6 3
7.数据离散分箱
连续数值经常需要离散化，或者分离成箱子进行分析。如果相对数据进行分组，需要借用cut函数和qcut函数。
pandas.cut(x, bins, right=True, labels=None, retbins=False, precision=3, duplicates='raise’)
pandas.qcut(x, bins, labels=None, retbins=False, precision=3, duplicates='raise’) x： 被切分的类数组数据，必须是1维的（不能用DataFrame）
| 参数 | 含义 |
|---|---|
| bins | bins是被切割后的区间，有3中形式：一个int型的标量、标量序列（数组）或pandas.IntervalIndex |
| right | bool型参数，默认为True，表示是否包含区间右部。比如如果bins=[1,2,3]，right=True，则区间为(1,2],(2,3]；right=False，则区间为(1,2),(2,3) |
| labels | 给分割后的bins打标签，比如把年龄x分割成年龄段bins后，可以给年龄段打上诸如青年、中年的标签 |
| retbins | 是否返回bins |
| precision | 数据精度 |
| duplicates | 是否允许重复区间。有两种选择：raise：不允许，drop：允许 |
在这里插入代码片
8.哑变量处理
将分类变量转换成‘虚拟’或‘指标’矩阵式是另一种用于统计建模或机器学习的转换操作。pandas有一个
函数get_dummies函数用于实现该功能。
pandas.get_dummies(data, prefix=None, prefix_sep=‘_’, dummy_na=False, columns=None, sparse=False, drop_first=False)
| 参数 | 含义 |
|---|---|
| data | 输入的数据 |
| prefix | 转换后，列名的前缀 |
| columns | 指定需要实现类别转换的列名 |
| dummy_na | 增加一列表示空缺值，如果False就忽略空缺值 |
| drop_first | 获得k中的k-1个类别值，去除第一个，默认False |
| https://www.cnblogs.com/sddai/p/8834373.html |
data=pd.read_excel('susceptibility.xls',index_col=0)
print(data.head())
geologic structure human activity underground water susceptibility
index
1 weak strong rich likely
2 weak strong rich likely
3 weak strong rich likely
4 weak weak rich likely
5 weak strong rich likely
# 转成0-1虚拟指标
name=['geologic structure','human activity','underground water']
for i in name:
g_data=pd.get_dummies(data[i],prefix=i[0])
# 拼接数据
data=pd.concat([data,g_data],axis=1)
print(data.head())
geo human unde sus g_strong g_weakh_strong h_weak u_poor u_rich
index
1 weak strong rich likely 0 1 1 0 0 1
2 weak strong rich likely 0 1 1 0 0 1
3 weak strong rich likely 0 1 1 0 0 1
4 weak weak rich likely 0 1 0 1 0 1
5 weak strong rich likely 0 1 1 0 0 1
9.Pandas按键合并数据
pandas.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=None, copy=True)
| 参数 | 含义 |
|---|---|
| objs | Series，DataFrame或Panel对象的序列或映射 |
| axis | {0,1，…}，默认为0。沿着连接的轴 |
| join | {‘inner’，‘outer’}，默认为“outer” 处理其他轴上的索引。outer为并集，inner为交集 |
DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=False)
| 参数 | 含义 |
|---|---|
| other | DataFrame、series、dict、list这样的数据结构 |
| ignore_index | 默认值为False，如果为True则不使用index标签 |
| verify_integrity | 默认值为False，如果为True当创建相同的index时会抛出ValueError的异常 |
df1=pd.DataFrame({'first':[2,3,8],
'second':[4,5,6]},
index=['aa','b','c'])
df2=pd.DataFrame({'second':[6,5,8],
'third':[17,18,19]},
index=['b','c','aa'])
#默认参数下的并集聚合效果,
pd.concat([df1,df2])
first second third
aa 2.0 4 NaN
b 3.0 5 NaN
c 8.0 6 NaN
b NaN 6 17.0
c NaN 5 18.0
aa NaN 8 19.0
#inner参数下的交集聚合效果
pd.concat([df1,df2],join='inner')
second
aa 4
b 5
c 6
b 6
c 5
aa 8
# 横向聚合效果;纵向聚合axis=0
pd.concat([df1,df2],axis=1)
first second second third
aa 2 4 8 19
b 3 5 6 17
c 8 6 5 18
df1.append(df2)
first second third
aa 2.0 4 NaN
b 3.0 5 NaN
c 8.0 6 NaN
b NaN 6 17.0
c NaN 5 18.0
aa NaN 8 19.0
#忽略行索引
df1.append(df2,ignore_index=True)
first second third
0 2.0 4 NaN
1 3.0 5 NaN
2 8.0 6 NaN
3 NaN 6 17.0
4 NaN 5 18.0
5 NaN 8 19.0
10.Pandas值合并函数
pandas.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,validate=None,…)
| 参数 | 含义 |
|---|---|
| left | 参与合并的左侧DataFrame |
| right | 参与合并的右侧DataFrame |
| how | 连接方式：‘inner’（默认）；还有，‘outer’、‘left’、‘right’ |
| on | 用于连接的列名，必须同时存在于左右两个DataFrame对象中，如果未指定，则以left和right列名的交集作为连接键 |
| left_on | 左侧DataFarme中用作连接键的列 |
| right_on | 右侧DataFarme中用作连接键的列 |
| left_index | {True or False,默认False}将左侧的行索引用作其连接键 |
| right_index | {True or False ,默认False}将右侧的行索引用作其连接键 |
| suffixes | 字符串值元组，用于追加到重叠列名的末尾，默认为（‘_x’,‘_y’） |
df1=pd.DataFrame({'first':[2,3,8],
'second':[4,5,6]},
index=['aa','aa','c'])
df2=pd.DataFrame({'second':[6,5,8],
'third':[17,8,19]},
index=['b','c','aa'])
#按照second相同的值进行交集合并:inner（默认）
pd.merge(df1,df2)
# 输出
first second third
0 3 5 8
1 8 6 17
# 修改how参数为outer,为并集合并
pd.merge(df1,df2,how='outer')
first second third
0 2.0 4 NaN
1 3.0 5 8.0
2 8.0 6 17.0
3 NaN 8 19.0
# 修改left_on和right_on参数示例;可以修改suffixes，默认为（‘_x’,‘_y’）
pd.merge(df1,df2,left_on='first',right_on='second')
first second_x second_y third
0 8 6 8 19
11.Pandas合并重叠数据
12.groupby分组
DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
by： 用来指定作用于index的函数、字典、Series对象或指定列名作为分组依据
根据不同的键进行分组
单键分组: DataFrame.groupby(‘key’).method()
多键分组: DataFrame.groupby([‘key1’,···，‘keyn’]).method()
分组后对指定列的值进行计算(有多种方法，这里举一种作为示例)
DataFrame.groupby([‘key1’,···‘keyn’])[‘val1’,···，‘valn’].method()
| 方法 | 描述 | 方法 | 描述 |
|---|---|---|---|
| count | 分组中的非NA值 | sum | 非NA值得累和 |
| mean | 非NA值得均值 | median | 非NA值的算数中位数 |
| std、var | 无偏标准差和方差 | min、max | 非NA的最小值和最大值 |
| prod | 非NA值的乘积 | first、last | 非NA的第一个值和最后一个值 |
| quantile(n) | 计算Series或DataFrame列的样本分位数，n∈（0，1） |
df=pd.DataFrame({'sex':list('FFMFMMF'),
'smoker':list('YNYYNYY'),
'age':[21,30,17,37,40,18,26],
'weight':[120,100,132,140,94,89,123]})
print(df)
sex smoker age weight
0 F Y 21 120
1 F N 30 100
2 M Y 17 132
3 F Y 37 140
4 M N 40 94
5 M Y 18 89
6 F Y 26 123
# 数据分组
grouped=df.groupby('sex')['weight']
# 对分组后数据应用多个函数:其中agg中可是自定义函数
print(grouped.agg(['mean','sum','count']))
mean sum count
sex
F 120.75 483 4
M 105.00 315 3
13.apply函数
apply函数也可以对groupby的结果进行操作，函数具体的使用参数如下
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
func： apply应用的函数
axis： 函数应用的轴向，0是纵向，1是横向
| apply函数 | agg函数辨析(不同点) |
|---|---|
| 对整个分组下的整体数据应用可以返回多个值 | 单独对分组的某列数据进行计算，只能返回一个结果 |
| 一次只能应用一个方法 | 一次能使用多个方法 |
| 可选方向 | 只能对列计算 |
import pandas as pd
df=pd.DataFrame({'sex':list('FFMFMMF'),
'smoker':list('YNYYNYY'),
'age':[21,30,17,37,40,18,26],
'weight':[120,100,132,140,94,89,123]})
# apply函数对整个分组下的整体数据应用，可以返回多个值
df['公斤']=df['weight'].apply(lambda x : x/2)
print(df)
# 输出
sex smoker age weight 公斤
0 F Y 21 120 60.0
1 F N 30 100 50.0
2 M Y 17 132 66.0
3 F Y 37 140 70.0
4 M N 40 94 47.0
5 M Y 18 89 44.5
6 F Y 26 123 61.5
def func(x,N,asc): # x为dataframe类型
return x.sort_values('公斤',ascending=asc)[:N] # 求出datafram进行切片
print(df.groupby("sex").apply(func,N=2,asc=False)) # 获得前面两行的排序
sex smoker age weight 公斤
sex
F 3 F Y 37 140 70.0
6 F Y 26 123 61.5
M 2 M Y 17 132 66.0
4 M N 40 94 47.0
1.数据透视表
透视表根据一个或者多个键聚合一张表的数据，将数据在矩形格式中排列，其中一部分分组键沿着行，另一
部分沿着列。实现该功能可以借助pivot_table函数实现。
pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc=‘mean’, fill_value=None,
margins=False, dropna=True, margins_name='All’)
| 参数 | 含义 |
|---|---|
| data | 要处理的数据 |
| index/ columns | 在结果透视表行/列上进行分组的列名或者其他分组键 |
| values | 需要聚合的列名，默认聚合所有列 |
| aggfunc | 值的聚合方式(默认的是求平均) |
| margins | 总计 |
| fill_value | 当出现nan值时，用什么填充 |
| dropna | 是否去掉nan值 |
df=pd.read_excel('Excel数据.xlsx',sheet_name=0)
print(df.head())
# 求个地区每种品牌的销售额
pd.pivot_table(df,values='销售额',index='地区',columns='家电品牌',aggfunc='sum')
# 求个地区每种品牌的销售额以及销售数量
pd.pivot_table(df,values='销售额',index='地区',columns='家电品牌',aggfunc=['sum','count'])
家电品牌 奥克斯 志高 春兰 松下 格力 海尔 美的
地区
东北 19200.0 17600.0 11100.0 13500.0 13500.0 9000.0 16205.0
华东 10000.0 2000.0 15300.0 29400.0 34800.0 4500.0 17550.0
华中 12000.0 NaN NaN 23100.0 7200.0 NaN 10800.0
华北 14400.0 NaN 4500.0 21000.0 17300.0 19500.0 28500.0
华南 9600.0 3000.0 6000.0 31800.0 27600.0 NaN 48200.0
西北 6000.0 8000.0 13500.0 12900.0 30000.0 25100.0 22800.0
西南 41207.0 22600.0 9600.0 18600.0 22007.0 NaN 10800.0
2.交叉表
交叉表是透视表的一个特殊情况，计算的是分组中的频率。主要使用crosstable函数实现
pandas.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None,margins=False, dropna=True, normalize=False)
| 参数 | 含义 |
|---|---|
| index | 在结果交叉表行上进行分组的列名或者其他分组键 |
| columns | 在结果交叉表列上进行分组的列名或者其他分组键 |
| values | 需要聚合的列名 |
| aggfunc | 值的聚合方式(默认的是求平均) |
| margins | 总计 |
| fill_value | 当出现nan值时，用什么填充 |
| dropna | 是否去掉nan值 |