1.Pandas的介绍
Pandas 是基于 NumPy 的一个非常好用的库，正如名字一样，人见人爱。之所以如此，就在于不论是读取、处理数据，用它都非常简单。
Pandas 有两种自己独有的基本数据结构。读者应该注意的是，它固然有着两种数据结构，因为它依然是 Python 的一个库，所以，Python 中有的数据类型在这里依然适用，也同样还可以使用类自己定义数据类型。只不过，Pandas 里面又定义了两种数据类型：Series 和 DataFrame，它们让数据操作更简单了。
2.Pandas的基本数据结构Series
(1)Series的创建
1>创建方式一:通过列表转换为Series对象
import pandas as pd import numpy as np #创建一个列表 list_1 = list(range(5,10)) print(list_1) #输出结果[5, 6, 7, 8, 9] #通过把列表转换为Series对象 ser_obj = pd.Series(list_1) print(ser_obj) #输出结果 #0 5 #1 6 #2 7 #3 8 #4 9 #dtype: int64
从上面代码可以看出来,输出结果为两列,第一列为索引,第二列为值,并且数据类型为int64
2>创建方式二:通过字典创建Series对象
#通过字典创建Series对象
#创建一个字典data_dict
data_dict = {
'2010':15.6,
'2011':16.2,
'2012':13.2,
'2013':12.9
}
#转换为Series对象
ser_obj = pd.Series(data_dict)
print(ser_obj)
#输出结果
#2010 15.6
#2011 16.2
#2012 13.2
#2013 12.9
#dtype: float64从上面的代码可以看出,字典中的key作为了Series的索引,字典中的value作为了Series中的数据,并且数据类型为诶float64
>3创建方式三:手动添加索引和数据类型
#手动添加索引和数据类型 #手动添加索引 ser_obj = pd.Series(['数据A','数据B','数据C'],index=['a','b','c']) print(ser_obj) #输出结果 #a 数据A #b 数据B #c 数据C #dtype: objec,因为数据为字符串型,所以数据类型为object #手动添加索引,并设置数据类型为Int32 ser_obj = pd.Series([11.2,15.6,18.9],index=['a','b','c'],dtype='int32') print(ser_obj) #输出结果 #a 11 #b 15 #b 15 #c 18 #dtype: int32
(2)Series对象的各种属性
1>Series对象的index属性--->获得索引类型
ser = pd.Series(range(3)) print(ser) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 #通过Series对象的index属性获得索引类型 print(ser.index) #输出结果RangeIndex(start=0, stop=3, step=1)
2>Series对象的values属性--->获得数据
ser = pd.Series(range(3)) print(ser) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 #通过Series对象的values属性获得数据,看着为一维数组 print(ser.values) #输出结果[0 1 2]
3>Series对象的index.name属性--->指定索引名称
#通过Series.index.name属性设置index索引名称 ser = pd.Series(range(3)) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 ser.index.name = 'index_name' print(ser) #输出结果 #index_name #0 0 #1 1 #2 2 #dtype: int32
4>Series对象的name属性--->指定Series对象的名称,为一列的时候作为一列的名称
#通过Series对象的name属性设置Series对象的名称,为一列时作为当列名称 ser = pd.Series(range(3)) ser.name = '列名' print(ser) #输出结果 #0 0 #1 1 #2 2 #Name: 列名, dtype: int32
(2)获取Series对象中的数据
1>根据一个索引获取数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) print(ser) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来获取数据7,索引从0开始 print(ser[2]) #输出结果7 #根据自己指定的索引来获取数据7 print(ser['c']) #输出结果为7
2>根据几个不连续的索引获取数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来获取数据 print(ser[[0,2,4]]) #输出结果 #a 5 #c 7 #e 9 #dtype: int32 #根据自己指定的索引来获取数据 print(ser[['a','d']]) #输出结果 #a 5 #d 8 #dtype: int32
3>通过切片获取指定数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来切片 print(ser[2:4]) #使用默认的RangeIndex索引来切片的话,只包含头元素,不包含尾部元素 #输出结果 #c 7 #d 8 #dtype: int32 #根据自己指定的索引来获取数据 print(ser['b':'e']) #使用自定义索引来切片的话,包含头尾两个元素 #输出结果 #b 6 #c 7 #d 8 #e 9 #dtype: int32
4>通过条件筛选出指定数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #创建条件 bool_ser = ser>6 print(bool_ser) #输出结果 #a False #b False #c True #d True #e True #dtype: bool #根据布尔型数组筛选出符合条件的数据 ser = ser[bool_ser] print(ser) #输出结果 #c 7 #d 8 #e 9 #dtype: int32
(4)Series对象的运算
1>直接运算(每个Series对象的数据个数相同)
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) ser_2 = pd.Series(range(20,25)) #加法计算 ser_3 = ser_1 + ser_2 #减法计算 ser_3 = ser_1 - ser_2 #乘法计算 ser_3 = ser_1 * ser_2 #除法计算 ser_3 = ser_1 / ser_2 print(ser_3)
2>对齐运算(每个Series对象的数据个数不同)
在对齐运算中,如果对应的位置没有数据,则自动填充为Nan
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) #5个数据 ser_2 = pd.Series(range(20,30)) #10个数据 #加法计算 ser_3 = ser_1 + ser_2 print(ser_3) #输出结果 ''' 0 25.0 1 27.0 2 29.0 3 31.0 4 33.0 5 NaN 6 NaN 7 NaN 8 NaN 9 NaN dtype: float64 '''
但是在实际统计中,数据NaN会影响,所以可以使用add()函数
add()对齐运算--->对未对齐的数据填充，然后进行运算
参数一：需要对齐运算的数据对象
参数二：对应位置默认值
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) #5个数据 ser_2 = pd.Series(range(20,30)) #10个数据 ser_3 = ser_1.add(ser_2,fill_value=0) print(ser_3) ''' 0 25.0 1 27.0 2 29.0 3 31.0 4 33.0 5 25.0 6 26.0 7 27.0 8 28.0 9 29.0 dtype: float64 '''
3.Pandas的基本数据结构DataFrame
(1)DataFrame的创建
1>创建方式一:把二维数组nparray对象转换为DataFrame对象
#将二维数组转换为DataFrame对象
#创建一个二维数组
arr = np.random.randn(3,4)
#二维数组中每一个小数组中的数据在DataFrame中是一行
#二维数组中每一个小数组中对应索引的数据在DataFrame中是一列
print(arr) #输出结果
'''
[[ 2.04938227 1.71157949 1.0695802 -1.21246563]
[ 1.59988925 -1.1689984 -1.15787772 0.24163685]
[ 0.71197257 0.93078003 0.78163736 0.57635525]]
'''
#对象转换,不指定行索引,列索引的话都是默认使用RangeIndex索引,从0开始
df_obj = pd.DataFrame(arr)
print(df_obj) #输出结果
'''
0 1 2 3
0 2.049382 1.711579 1.069580 -1.212466
1 1.599889 -1.168998 -1.157878 0.241637
2 0.711973 0.930780 0.781637 0.576355
'''
#对象换号.指定行索引,列索引
df_obj = pd.DataFrame(arr,index=['a','b','c'],columns=['A','B','C','D'])
print(df_obj) #输出结果
'''
A B C D
a 0.676696 -0.185332 0.951456 -3.416397
b 0.802608 -0.019629 0.533598 -0.064079
c -0.783926 -1.105331 2.659964 0.602179
'''
2>创建方式二:通过字典创建DataFrame对象
注意:
保证数据中至少有一列是带有行索引的
字典中的key作为列索引,value作为一列的数据
#通过字典创建DataFrame对象
#首先创建一个字典
data_dict = {
#必须有一列数据带有行索引,否则报错
'A':pd.Series(range(5)),
'B':2,
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
#输出结果,A列使用了默认的RangeIndex索引
'''
A B C D F
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
(2)DataFrame对象的各种属性
1>DataFrame对象的index属性--->获取行索引的类型
#通过字典创建DataFrame对象
#首先创建一个字典
data_dict = {
#必须有一列数据带有行索引,否则报错
'A':pd.Series(range(5)),
'B':2,
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
#输出结果,A列使用了默认的RangeIndex索引
'''
A B C D F
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
#通过DataFrame.index属性获得行索引的类型
print(df.index) #输出结果RangeIndex(start=0, stop=5, step=1)
2>DataFrame对象的columns属性--->获取列索引的类型
#通过字典创建DataFrame对象
#首先创建一个字典
data_dict = {
#必须有一列数据带有行索引,否则报错
'A':pd.Series(range(5)),
'B':2,
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
#输出结果,A列使用了默认的RangeIndex索引
'''
A B C D F
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
#通过DataFrame.columns属性获得行索引的类型
print(df.columns) #输出结果Index(['A', 'B', 'C', 'D', 'F'], dtype='object')
3>DataFrame对象的index.name和columns.name属性--->设置行索引和列索引的名称
#通过字典创建DataFrame对象
#首先创建一个字典
data_dict = {
#必须有一列数据带有行索引,否则报错
'A':pd.Series(range(5)),
'B':2,
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
#输出结果,A列使用了默认的RangeIndex索引
'''
A B C D F
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
#通过DataFrame.index/columns属性设置行索引名称,列索引名称
df.index.name = 'index_name'
df.columns.name = 'columns_name'
print(df)
#输出结果
'''
columns_name A B C D F
index_name
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
4>DataFrame对象的values属性--->获取DataFrame对象的数据
扫描二维码关注公众号，回复：
1058219 查看本文章
#通过字典创建DataFrame对象
#首先创建一个字典
data_dict = {
#必须有一列数据带有行索引,否则报错
'A':pd.Series(range(5)),
'B':2,
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
#输出结果,A列使用了默认的RangeIndex索引
'''
A B C D F
0 0 2 3 4 5
1 1 2 3 4 5
2 2 2 3 4 5
3 3 2 3 4 5
4 4 2 3 4 5
'''
#通过DataFrame.values属性获得数组
res = df.values
print(res)
#输出结果
'''
[[0 2 3 4 5]
[1 2 3 4 5]
[2 2 3 4 5]
[3 2 3 4 5]
[4 2 3 4 5]]
'''
(3)获取DataFrame对象的数据
1>通过列索引取出某一列
DataFrame对象是由多个Series对象组成,取出的每一列都是一个Series对象
#通过字典创建DataFrame对象
data_dict = {
'A':pd.Series(range(5)),
'B':pd.Series(['张三','李四','王五','赵柳','王炸']),
'C':3,
'D':4,
'F':5
}
#转换对象
df = pd.DataFrame(data_dict)
print(df)
'''
输出原内容
A B C D F
0 0 张三 3 4 5
1 1 李四 3 4 5
2 2 王五 3 4 5
3 3 赵柳 3 4 5
4 4 王炸 3 4 5
'''
#通过B列索引获取B列
print(df['B'])
print(type(df['B'])) #输出结果<class 'pandas.core.series.Series'>
#输出结果
'''
0 张三
1 李四
2 王五
3 赵柳
4 王炸
Name: B, dtype: object
'''
2>通过列索引和元素索引取出某个值
#通过字典创建DataFrame对象
data_dict = {
'A':pd.Series(range(5)),
'B':pd.Series(['张三','李四','王五','赵柳','王炸']),
'C':3,
'D':4,
'F':5
}
df = pd.DataFrame(data_dict)
print(df)
'''
输出原内容
A B C D F
0 0 张三 3 4 5
1 1 李四 3 4 5
2 2 王五 3 4 5
3 3 赵柳 3 4 5
4 4 王炸 3 4 5
'''
#取出王炸这个值
print(df['B'][4]) #输出 王炸
3>通过不连续的列索引取出多列数据
注意:在Series中根据不连续索引可以根据默认的RangeIndex索引来取,也可以根据自己指定的索引来获取,但是在DataFrame中不能使用默认的RangeIndex索引来获取
#通过字典创建DataFrame对象
data_dict = {
'A':pd.Series(range(5)),
'B':pd.Series(['张三','李四','王五','赵柳','王炸']),
'C':3,
'D':4,
'F':5
}
df = pd.DataFrame(data_dict)
print(df)
'''
输出原内容
A B C D F
0 0 张三 3 4 5
1 1 李四 3 4 5
2 2 王五 3 4 5
3 3 赵柳 3 4 5
4 4 王炸 3 4 5
'''
#根据不连续列索引取出多列数据
print(df[['B','D']])
#输出结果
'''
B D
0 张三 4
1 李四 4
2 王五 4
3 赵柳 4
4 王炸 4
'''
4>通过切片来获取数据
由于切片必须根据行索引来切,所以先指定下行索引
data_dict = {
'A':pd.Series(range(5)),
'B':pd.Series(['张三','李四','王五','赵柳','王炸']),
'C':3,
'D':4,
'F':5
}
#指定行索引
df.index=['a','b','c','d','e']
print(df)
#输出结果
'''
A B C D F
a 0 张三 3 4 5
b 1 李四 3 4 5
c 2 王五 3 4 5
d 3 赵柳 3 4 5
e 4 王炸 3 4 5
'''
print(df['b':'d'])
'''
输出结果
A B C D F
b 1 李四 3 4 5
c 2 王五 3 4 5
d 3 赵柳 3 4 5
'''
print(type(df['b':'d'])) #输出结果<class 'pandas.core.frame.DataFrame'>
#切片出来的数据也是个DataFrame对象
5>通过条件来筛选指定的数据
data_dict = {
'A':pd.Series(range(5)),
'B':pd.Series(['张三','李四','王五','赵柳','王炸']),
'C':3,
'D':4,
'F':5
}
#指定行索引
df.index=['a','b','c','d','e']
print(df)
'''
原内容
A B C D F
a 0 张三 3 4 5
b 1 李四 3 4 5
c 2 王五 3 4 5
d 3 赵柳 3 4 5
e 4 王炸 3 4 5
'''
#添加条件,返回一个布尔类型
bool_df = df>4
print(bool_df)
'''
输出结果
A B C D F
a False True False False True
b False True False False True
c False True False False True
d False True False False True
e False True False False True
'''
#根据布尔型的DataFrame对象筛选出数据
df = df[bool_df]
print(df) #True的值正常输出,False的值用NaN填充
'''
A B C D F
a NaN 张三 NaN NaN 5
b NaN 李四 NaN NaN 5
c NaN 王五 NaN NaN 5
d NaN 赵柳 NaN NaN 5
e N
(4)DataFrame对象的运算
1>直接运算(每个DataFrame对象的数据个数相同,位置一一对应)
#创建两个DataFrame对象
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E'])
print(df_1)
'''
输出结果
A B C D E
a 1 2 3 4 5
b 1 2 3 4 5
'''
df_2 = pd.DataFrame([[10,20,30,40,50],[10,20,30,40,50]],index=['a','b'],columns=['A','B','C','D','E'])
print(df_2)
'''
输出结果
A B C D E
a 10 20 30 40 50
b 10 20 30 40 50
'''
#加法计算
df_3 = df_1 + df_2
print(df_3)
'''
输出结果
A B C D E
a 11 22 33 44 55
b 11 22 33 44 55
'''
#减法计算
df_3 = df_1 - df_2
#乘法计算
df_3 = df_1 * df_2
#除法计算
df_3 = df_1 / df_2
2>对齐运算(每个DataFrame对象的数据个数不相同)
#创建两个DataFrame对象
#两行五列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E'])
print(df_1)
'''
输出结果
A B C D E
a 1 2 3 4 5
b 1 2 3 4 5
'''
#三行三列
df_2 = pd.DataFrame([[10,20,30],[10,20,30],[10,20,30]],index=['a','b','c'],columns=['A','B','C'])
print(df_2)
'''
输出结果
A B C
a 10 20 30
b 10 20 30
c 10 20 30
'''
df_3 = df_1 + df_2
print(df_3)
#和Series中的对齐运算一样,找不到对应的位置的数据给Nan
'''
输出结果
A B C D E
a 11.0 22.0 33.0 NaN NaN
b 11.0 22.0 33.0 NaN NaN
c NaN NaN NaN NaN NaN
'''
但是在实际统计中,数据NaN会影响,所以可以使用add()函数
add()对齐运算--->对未对齐的数据填充，然后进行运算
参数一：需要对齐运算的数据对象
参数二：对应位置默认值#创建两个DataFrame对象
#两行五列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E'])
print(df_1)
'''
输出结果
A B C D E
a 1 2 3 4 5
b 1 2 3 4 5
'''
#三行三列
df_2 = pd.DataFrame([[10,20,30],[10,20,30]],index=['a','b'],columns=['A','B','C'])
print(df_2)
'''
输出结果
A B C
a 10 20 30
b 10 20 30
'''
df_3 = df_1.add(df_2,fill_value=1)
print(df_3)
#使用add()函数,fill_value参数为需要设置的默认值
'''
输出结果
A B C D E
a 11 22 33 5.0 6.0
b 11 22 33 5.0 6.0
'''
(5)DataFrame对象的数据修改
1>修改列数据
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #修改B这一列 df_1['B'] = pd.Series([100,200],index=['a','b']) print(df_1) ''' A B C D E a 1 100 3 4 5 b 1 200 3 4 5 '''
2>添加新列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' df_1['F'] = pd.Series(['你好',"世界"],index=['a','b']) print(df_1) ''' A B C D E F a 1 2 3 4 5 你好 b 1 2 3 4 5 世界 '''
3>删除某列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #使用del del(df_1['E']) print(df_1) ''' A B C D a 1 2 3 4 b 1 2 3 4 '''
4>通常会遇到有Nan的空数据
可以通过fillna()这个函数把Nan数据转换为正常数据
参数1:需要填充的数据
参数2:inplace,默认为False,替换后需要新对象接收,改为True的话就为就地填充
#创建两个DataFrame对象
#两行五列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E'])
print(df_1)
'''
输出结果
A B C D E
a 1 2 3 4 5
b 1 2 3 4 5
'''
#三行三列
df_2 = pd.DataFrame([[10,20,30],[10,20,30]],index=['a','b'],columns=['A','B','C'])
print(df_2)
'''
输出结果
A B C
a 10 20 30
b 10 20 30
'''
df_3 = df_1 + df_2
print(df_3)
'''
A B C D E
a 11 22 33 NaN NaN
b 11 22 33 NaN NaN
'''
#使用fillan()函数,设置需要填充的数据为0
df_4 = df_3.fillna(0)
'''
直接输出
A B C D E
a 11 22 33 NaN NaN
b 11 22 33 NaN NaN
发现并没有改变,因为inplace默认为False,替换后需要新对象接收
'''
print(df_4)
'''
A B C D E
a 11 22 33 0.0 0.0
b 11 22 33 0.0 0.0
'''
#如果fillna()中的inplace=True的话,则不需要新对象接收,直接输出即可
3.Pandas的其他高级应用
(1)Pandas高级函数
1>allpy()函数
作用:将某个函数应用到行数据或列数据
参数1:某个函数
参数2:axis=0/1 0为列轴向,1为行轴向
注意:默认为0是列轴向
#创建一个DataFrame对象
df = pd.DataFrame(np.random.randn(4,5))
print(df)
'''
0 1 2 3 4
0 -0.424642 0.245011 0.234163 2.020902 -2.008150
1 1.071732 -0.356165 -0.051649 0.081620 -0.416612
2 0.618656 1.271960 0.126436 0.138978 -0.924348
3 1.848569 -0.563261 -1.321456 -0.537379 0.521588
'''
#使用allpy(某个函数,axis=0/1)函数
#默认的话axis=0,是每列,所以取出了每列最大值
print(df.apply(lambda x:x.max()))
'''
0 1.848569
1 1.271960
2 0.234163
3 2.020902
4 0.521588
dtype: float64
'''
2>allpymap()函数
作用:将某个函数应用对象的每一个数据上
参数1:某个函数
#创建一个DataFrame对象
df = pd.DataFrame(np.random.randn(4,5))
print(df)
'''
0 1 2 3 4
0 -0.416850 0.721202 0.407990 0.706786 2.205044
1 0.187485 0.721705 -1.781101 -0.389938 0.385217
2 1.042906 -0.121288 -0.108704 0.220526 -1.943875
3 -0.817982 0.329798 -0.830090 -0.609012 -0.255436
'''
#使用allpymap(某个函数)函数
#所有数据保留2个小数
print(df.applymap(lambda x:'%.2f'%x))
'''
0 1 2 3 4
0 -0.42 0.72 0.41 0.71 2.21
1 0.19 0.72 -1.78 -0.39 0.39
2 1.04 -0.12 -0.11 0.22 -1.94
3 -0.82 0.33 -0.83 -0.61 -0.26
'''
3>sort_index()函数
作用:根据索引排序
#创建一个Series对象
ser = pd.Series(range(10,15),index=np.random.randint(5,size=5))
print(ser)
'''
2 10
0 11
4 12
2 13
2 14
dtype: int32
'''
#使用sort_index()函数排序,默认ascending=True升序
#ascending=False为降序
print(ser.sort_index())
'''
0 11
2 10
2 13
2 14
4 12
dtype: int32
'''
#创建一个DataFrame对象
df = pd.DataFrame(np.random.randn(3,4),index=np.random.randint(3,size=3),columns=np.random.randint(4,size=4))
print(df)
'''
2 0 3 2
2 0.217727 1.203948 -0.688645 -0.863836
2 -0.180206 -0.077609 -0.611350 0.150716
1 0.658392 -0.658513 0.076823 -0.106351
'''
#不指定排序轴向,默认按照行轴向排序
#asix=0按照行排序 asix=1按照列排序
print(df.sort_index())
'''
2 0 3 2
1 0.658392 -0.658513 0.076823 -0.106351
2 0.217727 1.203948 -0.688645 -0.863836
2 -0.180206 -0.077609 -0.611350 0.150716
'''
4>sort_values()函数
作用:根据索引排序#创建一个Series对象
ser = pd.Series([2,5,7,8,1,0])
print(ser)
'''
0 2
1 5
2 7
3 8
4 1
5 0
dtype: int64
'''
#使用sort_values()函数排序,默认ascending=True升序
#ascending=False为降序
print(ser.sort_values())
'''
5 0
4 1
0 2
1 5
2 7
3 8
dtype: int64
'''
#创建一个DataFrame对象
df = pd.DataFrame(np.random.randn(3,4),index=range(1,4),columns=range(1,5))
print(df)
'''
1 2 3 4
1 -0.856200 -1.824741 -1.283182 0.427393
2 -0.689118 1.020502 -0.146721 0.677232
3 0.968071 -0.010719 -0.444609 0.519839
'''
#不指定排序轴向,默认按照行轴向排序
#asix=0按照行排序 asix=1按照列排序
print(df.sort_values(by=2,ascending=False))
'''
1 2 3 4
2 -0.689118 1.020502 -0.146721 0.677232
3 0.968071 -0.010719 -0.444609 0.519839
1 -0.856200 -1.824741 -1.283182 0.427393
'''
#指定按照多列进行排序,优先按照第一个指定的列进行排序
print(df.sort_values(by=[2,3]))
'''
1 2 3 4
1 -0.856200 -1.824741 -1.283182 0.427393
3 0.968071 -0.010719 -0.444609 0.519839
2 -0.689118 1.020502 -0.146721 0.677232
'''
5>fillna()函数
# fillna() 填充缺失数据的
df = pd.DataFrame([np.random.randn(4),
[1,2,np.nan,np.nan],
[3,np.nan,np.nan,np.nan],
['hello','world','test','qq']
])
print(df)
# 获取布尔类型索引，判断数据中哪些为空数据
print(df.isnull())
6>dropna()函数
# fillna() 填充缺失数据的
df = pd.DataFrame([np.random.randn(4),
[1,2,np.nan,np.nan],
[3,np.nan,np.nan,np.nan],
['hello','world','test','qq']
])
print(df)
# df.fillna(1)
# dropna()丢弃缺失数据 默认按照行丢弃缺失数据，如果该行有NaN数据，则丢弃该行数据
# axis=0 按照行丢弃空数据 axis=1按照列丢弃空数据
print(df.dropna(axis=1))
(2)Pandas数据的分组和聚合
分组对数据进行分组，然后对一组的数据进行计算
SQL是可以对数据进行分组和过滤的
Pandas可以通过groupby函数进行复杂的分组运算
分组运算过程：
1.分组 根据某些要求分组
2.运算 根据不同的分组数据进行不同的运算
3.合并 把每一个分组的运算结果合并在一起
首先创建数据模型
dict_data = {
'key1':['a','b','c','d','a','b','c','d'],
'key2':['one','two','three','one','two','three','one','two'],
'data1':[3.6,1.8,2,6,8,10,5.8,4],
'data2':[11,5,6,2,7,9,1,2]
}
#根据字典创建df对象
df = pd.DataFrame(dict_data)
print(df)
'''
data1 data2 key1 key2
0 3.6 11 a one
1 1.8 5 b two
2 2.0 6 c three
3 6.0 2 d one
4 8.0 7 a two
5 10.0 9 b three
6 5.8 1 c one
7 4.0 2 d two
'''
1>根据指定列进行分组
#按照指定列进行分组
#DataFrameGroupBy 类型的对象,储存分组之后的数据
print(df.groupby('key1')) #输出结果<pandas.core.groupby.DataFrameGroupBy object at 0x088687D0>
print(df.groupby('key1').sum())
'''
data1 data2
key1
a 11.6 18
b 11.8 14
c 7.8 7
d 10.0 4
'''
'''
a data1 data2
0 3.6 11
1 8.0 7
b
0 1.8 5
1 10.0 9
c
0 2.0 6
1 5.8 1
d
0 6.0 2
1 4.0 2
'''
2>把某列数据按照另一列进行分组
#把某列数据按照另一列进行分组 #1.找到要分组的列 print(df['data1']) ''' 0 3.6 1 1.8 2 2.0 3 6.0 4 8.0 5 10.0 6 5.8 7 4.0 Name: data1, dtype: float64 ''' #根据key1这一列进行分组 #SeriesGroupBy print(df['data1'].groupby(df['key1']).sum()) ''' key1 a 11.6 b 11.8 c 7.8 d 10.0 Name: data1, dtype: float64 '''
3>按照数据类型分组
#按照数据类型分组
group = df.groupby(df.dtypes,axis=1)
print(group)
for group_name,group_data in group:
print(group_name)
#分组运算,让每一个df对象中的每一列的数据累加
#print(group_data)
print('*'*30)
#按照数据类型分组
group = df.groupby(df.dtypes,axis=1)
print(group)
for group_name,group_data in group:
print(group_name)
#分组运算,让每一个df对象中的每一列的数据累加
print(group_data.sum())
print('*'*30)
4>根据字典进行分组
#根据字典进行分组
df = pd.DataFrame(np.random.randint(1,10,(5,5)),
index = ['a','b','c','d','e'],
columns = ['A','B','C','D','E']
)
print(df)
'''
A B C D E
a 5 1 5 5 9
b 1 1 5 2 5
c 9 4 3 6 4
d 6 6 3 4 9
e 5 9 2 5 5
'''
#自己指定每一列的数据对应的分组名称
dict_mapping = {
'A':'Python',
'B':'Java',
'C':'C',
'D':'Java',
'E':'Python'
}
print(df.groupby(dict_mapping,axis=1).size())
'''
C 1
Java 2
Python 2
dtype: int64
'''
print(df.groupby(dict_mapping,axis=1).sum())
'''
C Java Python
a 5 6 14
b 5 3 6
c 3 10 13
d 3 10 15
e 2 14 10
'''