python-数据分析-pandas基础知识

木心心以向荣

已于 2022-10-18 12:23:23 修改

阅读量1.1k

点赞数

文章标签： pandas python 数据分析

于 2022-10-16 13:28:16 首次发布

本文链接：https://blog.csdn.net/weixin_57194935/article/details/127306607

版权

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值

木心心以向荣

关注

0
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
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.交叉表
复制链接

扫一扫