文章目录
Pandas的函数应用
apply 和 applymap
1. 可直接使用NumPy的函数
- 示例代码：
# Numpy ufunc 函数
df = pd.DataFrame(np.random.randn(5,4) - 1)
print(df)
print(np.abs(df))
- 运行结果：
0 1 2 3
0 -0.062413 0.844813 -1.853721 -1.980717
1 -0.539628 -1.975173 -0.856597 -2.612406
2 -1.277081 -1.088457 -0.152189 0.530325
3 -1.356578 -1.996441 0.368822 -2.211478
4 -0.562777 0.518648 -2.007223 0.059411
0 1 2 3
0 0.062413 0.844813 1.853721 1.980717
1 0.539628 1.975173 0.856597 2.612406
2 1.277081 1.088457 0.152189 0.530325
3 1.356578 1.996441 0.368822 2.211478
4 0.562777 0.518648 2.007223 0.059411
2. 通过apply将函数应用到列或行上
- 示例代码：
# 使用apply应用行或列数据
#f = lambda x : x.max()
print(df.apply(lambda x : x.max()))
- 运行结果：
0 -0.062413
1 0.844813
2 0.368822
3 0.530325
dtype: float64
注意指定轴的方向，默认axis=0，方向是列
- 示例代码：
# 指定轴方向，axis=1，方向是行
print(df.apply(lambda x : x.max(), axis=1))
- 运行结果：
0 0.844813
1 -0.539628
2 0.530325
3 0.368822
4 0.518648
dtype: float64
3. 通过applymap将函数应用到每个数据上
- 示例代码：
# 使用applymap应用到每个数据
f2 = lambda x : '%.2f' % x
print(df.applymap(f2))
- 运行结果：
0 1 2 3
0 -0.06 0.84 -1.85 -1.98
1 -0.54 -1.98 -0.86 -2.61
2 -1.28 -1.09 -0.15 0.53
3 -1.36 -2.00 0.37 -2.21
4 -0.56 0.52 -2.01 0.06
排序
df.sort_index(axis = 0, #排序维度，默认为0,0为按列统计，1为按行统计
ascending=False, #是否降序排列，默认False降序排列，True为升序排列
na_position = 'last') # 空值是放在最前还是最后，默认'last'放在最后，'first'则是方向在最前
df.sort_values(
by = ['Python','Tensorflow','Keras'],
#排序依据的索引标签，list或者str(仅有一个标签时)，参考顺序为从前到后，如此例就是先根据Python，Python相同再Tensorflow，再Keras
axis=0,#进行统计的维度，默认为0,0为按列统计，1为按行统计
ascending=True,#是否降序排列，默认False降序排列，True为升序排列
na_position='last') # 空值是放在最前还是最后，默认'last'放在最后，'first'则是方向在最前
#筛选最大的N个值进行降序排序，只对列排序
df.nlargest(n = 6, #选择最大的几个值进行排序，int
columns='Python',#排序依据的索引标签，list或者str(仅有一个标签时)，同sort_values用法
keep='all')
# 排序时如果出现重复值如果处理，默认first，保留第一个出现的值，last为保留最后一个出现的值，all为保留索引，all的话可能出现保留的条数大于n的情况
# #筛选最小的N个值进行升序排序，只对列排序
df.nsmallest(5,columns='Keras',keep='all') #参数解析同nlargest
1. 索引排序
sort_index()
排序默认使用升序排序，ascending=False 为降序排序
- 示例代码：
# Series
s4 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))
print(s4)
# 索引排序
s4.sort_index() # 0 0 1 3 3
print(s4.sort_index())
- 运行结果：
0 10
3 11
1 12
3 13
0 14
dtype: int64
0 10
0 14
1 12
3 11
3 13
dtype: int64
2.对DataFrame操作时注意轴方向
- 示例代码：
# DataFrame
df4 = pd.DataFrame(np.random.randn(3, 5),
index=np.random.randint(3, size=3),
columns=np.random.randint(5, size=5))
print(df4)
df4_isort = df4.sort_index(axis=1, ascending=False)
print(df4_isort) # 4 2 1 1 0
- 运行结果：
1 4 0 1 2
2 -0.416686 -0.161256 0.088802 -0.004294 1.164138
1 -0.671914 0.531256 0.303222 -0.509493 -0.342573
1 1.988321 -0.466987 2.787891 -1.105912 0.889082
4 2 1 1 0
2 -0.161256 1.164138 -0.416686 -0.004294 0.088802
1 0.531256 -0.342573 -0.671914 -0.509493 0.303222
1 -0.466987 0.889082 1.988321 -1.105912 2.787891
3. 按值排序
sort_values(by='column name')
根据某个唯一的列名进行排序，如果有其他相同列名则报错。
- 示例代码：
# 按值排序,by=0,如果没有0，也会报错，重新运行一下，直到有0就不报错了
df4_vsort = df4.sort_values(by=0, ascending=False)
print(df4_vsort)
- 运行结果：
1 4 0 1 2
1 1.988321 -0.466987 2.787891 -1.105912 0.889082
1 -0.671914 0.531256 0.303222 -0.509493 -0.342573
2 -0.416686 -0.161256 0.088802 -0.004294 1.164138
处理缺失数据
- 示例代码：
df_data = pd.DataFrame([np.random.randn(3), [1., 2., np.nan],
[np.nan, 4., np.nan], [1., 2., 3.]])
print(df_data.head())
- 运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
1 1.000000 2.000000 NaN
2 NaN 4.000000 NaN
3 1.000000 2.000000 3.000000
1. 判断是否存在缺失值：isnull()
- 示例代码：
# isnull
print(df_data.isnull())
- 运行结果：
0 1 2
0 False False False
1 False False True
2 True False True
3 False False False
2. 丢弃缺失数据：dropna()
根据axis轴方向，丢弃包含NaN的行或列。
- 示例代码：
# dropna
print(df_data.dropna())
print(df_data.dropna(axis=1))
- 运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
3 1.000000 2.000000 3.000000
1
0 -0.786572
1 2.000000
2 4.000000
3 2.000000
3. 填充缺失数据：fillna()
- 示例代码：
# fillna
print(df_data.fillna(-100.))
- 运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
1 1.000000 2.000000 -100.000000
2 -100.000000 4.000000 -100.000000
3 1.000000 2.000000 3.000000
层级索引（hierarchical indexing）
下面创建一个Series， 在输入索引Index时，输入了由两个子list组成的list，第一个子list是外层索引，第二个list是内层索引。
- 示例代码：
import pandas as pd
import numpy as np
ser_obj = pd.Series(np.random.randn(12),index=[
['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
])
print(ser_obj)
- 运行结果：
a 0 0.099174
1 -0.310414
2 -0.558047
b 0 1.742445
1 1.152924
2 -0.725332
c 0 -0.150638
1 0.251660
2 0.063387
d 0 1.080605
1 0.567547
2 -0.154148
dtype: float64
MultiIndex索引对象
-
打印这个Series的索引类型，显示是
MultiIndex -
直接将索引打印出来，可以看到有lavels,和labels两个信息。lavels表示两个层级中分别有那些标签，labels是每个位置分别是什么标签。
-
示例代码：
print(type(ser_obj.index))
print(ser_obj.index)
- 运行结果：
<class 'pandas.indexes.multi.MultiIndex'>
MultiIndex(levels=[['a', 'b', 'c', 'd'], [0, 1, 2]],
labels=[[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]])
选取子集
根据索引获取数据。因为现在有两层索引，当通过外层索引获取数据的时候，可以直接利用外层索引的标签来获取。
当要通过内层索引获取数据的时候，在list中传入两个元素，前者是表示要选取的外层索引，后者表示要选取的内层索引。
1. 外层选取：
ser_obj['outer_label']
- 示例代码：
# 外层选取
print(ser_obj['c'])
- 运行结果：
0 -1.362096
1 1.558091
2 -0.452313
dtype: float64
- 内层选取：
ser_obj[:, 'inner_label']
- 示例代码：
# 内层选取
print(ser_obj[:, 2])
- 运行结果：
a 0.826662
b 0.015426
c -0.452313
d -0.051063
dtype: float64
常用于分组操作、透视表的生成等
交换分层顺序
1. swaplevel()
.swaplevel( )交换内层与外层索引。- 示例代码：
print(ser_obj.swaplevel())
- 运行结果：
0 a 0.099174
1 a -0.310414
2 a -0.558047
0 b 1.742445
1 b 1.152924
2 b -0.725332
0 c -0.150638
1 c 0.251660
2 c 0.063387
0 d 1.080605
1 d 0.567547
2 d -0.154148
dtype: float64
交换并排序分层 sortlevel()
.sortlevel( )先对外层索引进行排序，再对内层索引进行排序，默认是升序。- 示例代码：
# 交换并排序分层
print(ser_obj.swaplevel().sortlevel())
- 运行结果：
0 a 0.099174
b 1.742445
c -0.150638
d 1.080605
1 a -0.310414
b 1.152924
c 0.251660
d 0.567547
2 a -0.558047
b -0.725332
c 0.063387
d -0.154148
dtype: float64
Pandas统计计算和描述
- 示例代码：
import numpy as np
import pandas as pd
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj)
- 运行结果：
a b c d
0 1.469682 1.948965 1.373124 -0.564129
1 -1.466670 -0.494591 0.467787 -2.007771
2 1.368750 0.532142 0.487862 -1.130825
3 -0.758540 -0.479684 1.239135 1.073077
4 -0.007470 0.997034 2.669219 0.742070
常用的统计计算
sum, mean, max, min…
axis=0 按列统计，axis=1按行统计
skipna 排除缺失值， 默认为True
- 示例代码：
df_obj.sum()
df_obj.max()
df_obj.min(axis=1, skipna=False)
- 运行结果：
a 0.605751
b 2.503866
c 6.237127
d -1.887578
dtype: float64
a 1.469682
b 1.948965
c 2.669219
d 1.073077
dtype: float64
0 -0.564129
1 -2.007771
2 -1.130825
3 -0.758540
4 -0.007470
dtype: float64
常用的统计描述
describe 产生多个统计数据
- 示例代码：
print(df_obj.describe())
- 运行结果：
a b c d
count 5.000000 5.000000 5.000000 5.000000
mean 0.180305 0.106488 0.244978 0.178046
std 0.641945 0.454340 1.064356 1.144416
min -0.677175 -0.490278 -1.164928 -1.574556
25% -0.064069 -0.182920 -0.464013 -0.089962
50% 0.231722 0.127846 0.355859 0.190482
75% 0.318854 0.463377 1.169750 0.983663
max 1.092195 0.614413 1.328220 1.380601
常用的统计描述方法：
数学和统计方法
import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randint(0,10,size = (20,3)),
columns=['Python','Math','En'],index = list('QWERTYUIOPASDFGHJKLZ'))
df.iloc[6,2] = np.NAN#把所以为6,2的元素更改为空值
简单统计指标
display(df.count(),df.nunique(),df.min(),df.max(),df.mean(),df.median(),df.std(),df.var())
df.count(axis=0,level=None,numeric_only=False)，统计非空数据量；
df.nunique(axis=0,dropna=True)，统计去重数据量；
df.min(axis=0,skipna=None,level=None,numeric_only=False)，统计最小值；
df.max(axis=0,skipna=None,level=None,numeric_only=False)，统计最大值；
df.mean(axis=0,skipna=None,level=None,numeric_only=False)，统计平均数；
df.median(axis=0,skipna=None,level=None,numeric_only=False)，统计中位数；
df.std(axis=0,skipna=None,level=None,ddof=1,numeric_only=False)，统计标准差；
df.var(axis=0,skipna=None,level=None,ddof=1,numeric_only=False)，统计方差。
参数解析：
-
axis：计算的维度，默认0，表示计算整列的数值，将0维也就是此列所有行的数据进行统计，axis=1的时候计算的是此行所有列的统计值。
-
level：当索引为多重索引的时候，计算指定级别索引对应的统计值，默认为None。
-
skipna，dropna：是否忽略空值，默认为True，忽略空值，当整行或整列都为空值时将无意义。
-
numeric_only：是否只针对布尔值，int和float进行统计，默认为None，统计所有类型的数据。
-
ddof：自由度，统计学指标。
df['Python'].unique() # 去除重复数据，只能针对具体的列，作用对象是Series。
array([8, 5, 4, 3, 1, 6, 2, 7, 9])
# 统计元素出现的频次
df.value_counts(
subset=['Math','Python'],#要统计的列，默认为None，全部统计
normalize=True,#是否显示元素出现频率，默认为False显示元素出现次数
sort= True,#是否进行排序，默认为True
ascending= True) #是否升序显示，默认为False降序
# 百分位数，统计这一组数据里从小到大在各个水平线上的值
df.quantile(
q = [0,0.25,0.5,0.75,1],#水平线，0为最小值，1为最大值，0.5为中位数，默认为0.5即中位数
axis=0) #确认统计维度，0为统计整列，1为统计整行
#常用统计量展示，包括最小值，最大值，平均值，标准差，非空数据量，以及水平线数值
df.describe(
percentiles=[0.25,0.5,0.75],#确定水平线，默认[0.25,0.5,0.75]，即四分位的三个临界值
datetime_is_numeric=False).round(1) #datetime_is_numeric，是否将日期类型转化为数字，默认为False。
索引标签位置获取
# 返回最大值索引，必须给定具体的列，只针对列进行统计，不能用于行
df['Python'].argmax()
# 返回最小值索引，必须给定具体的列，只针对列进行统计，不能用于行
df['En'].argmin()
# 返回最大值的标签
df.idxmax(
axis=0, #统计的维度，默认为0，按列统计， axis=1时按行统计
skipna=True) #是否忽略空值，默认为True忽略空值
# 返回最小值标签
df.idxmin(
axis=0, #统计的维度，默认为0，按列统计， axis=1时按行统计
skipna=True) #是否忽略空值，默认为True忽略空值
累计统计指标
#统计累加和
df.cumsum(axis=0,skipna=True)
#统计累乘值，遇到第一个0之后就全为0了，符合乘法规律
df.cumprod(axis=0,skipna=True)
#统计累计最小值
df.cummin(axis=0,skipna=True)
#统计累计最大值
df.cummax(axis=0,skipna=True)
# 差分，当前数据减去前N数据的差值
df.diff(
periods=1,#向上寻找的步长，默认为1，即当前位置的数据减去上一个索引位置的数据得到差值，int，可以自行设置步长
axis = 1) #确定统计维度，默认为0,0为按列统计，1为按行统计
#统计百分比变化,适合用于计算同环比
df.pct_change(periods=1)#向上寻找的步长，默认为1，即当前位置的数据减去上一个索引位置的数据得到差值，int，可以自行设置步长
高级统计指标
df.cov() # 协方差：自己和别人计算
df['Python'].cov(df['Math'])#计算两个指定系列的协方差
df.corr() # 相关性系数 -1 ~ 1，相关性系数由协方差求得
df.corrwith(df['En']) # 一列的相关性系数
分箱操作
df = pd.DataFrame(np.random.randint(0,151,size = (100,3)),
columns=['Python','Math','En'])
等宽分箱–cut
cut会把数组中的数据分成宽度相等的N等份，比如数组中的数据最大值和最小值为0和150，我们要分成3份，那么cut就会把数组分成0-50,50-100,100-150的宽度相等的三份，当然我们也可以自己指定每一箱的临界值，这时候箱子的宽度也可以不相等。等宽分箱每一箱的元素个数大多数情况下是不相等的。
等宽分箱适用于我们知道临界值且需要根据临界值进行等级划分的情况。
参数解析：
-
x : 需要进行操作的数据集，数据类型须为一维数组或者Series。
-
bins：分成的份数，int或者list，
- 给定int的的时候由系统自动根据数据极差进行等宽分箱，
- 给定list的时候，根据list内的临界值进行分箱，这时候箱宽可以是不相等的。
-
labels,给各个箱起名，数值类型为list，注意当bins为int的时候，labels内的标签个数和int相等，当bins为list的时候，labels内的标签个数为bins的临界值个数-1。
-
right,箱内数据是否包括临界值，默认为True包括。
绝对等宽分箱
# 未给定临界值，由系统自动进行等宽分箱
pd.cut(x = df.Python,
bins = 4, # 等宽分成四份
labels=['不及格','及格','中等','优秀'],
right = True)# 区间，闭区间
#将分箱操作赋予原DataFrane返回新的DataFrame
df['等级']=pd.cut(df.Python,
bins = 4, # 等宽分成四份
labels=['不及格','及格','中等','优秀'],#labels内的标签个数等于bins的数值
right = True)# 区间，闭区间
给定临界值分箱
# 给定临界值，由临界值进行分箱，这时候箱宽可以不相等
df['等级'] = pd.cut(df.Python,
bins = [0,60,90,100,120,150],#此时箱宽可以不相等
labels=['极差','不及格','及格','中等','优秀']) #labels内的标签个数为bins的临界值个数-1
等频分箱–qcut
等频的分箱每个箱的元素个数必然是相等或者接近的(有时候不相等是因为元素个数不能被箱数整除)
等频分箱适用于需要根据人数或者说元素个数进行分箱的情况，比如销售业绩排名，有时候可能大家都没达标或者都达标了，但是还是需要找出各个级别的人，这时候可以进行人数相等的分箱操作，不必根据临界值。
pd.qcut(df.Python,
q = 4,
labels=['不及格','及格','中等','优秀'])
#查看各箱元素数是否相等
pd.qcut(df.Python,
q = 4,
labels=['不及格','及格','中等','优秀']).value_counts()
参考：http://www.jianshu.com/p/ac703660ed7e
https://zhuanlan.zhihu.com/p/343835600
803
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
