衡水网站seo,桂林哪里学建设网站,手机发布WordPress文章,有了域名和空间怎么建网站对象的创建
导入 Pandas 时#xff0c;通常给其一个别名“pd”#xff0c;即 import pandas as pd。作为标签库#xff0c;Pandas 对象在 NumPy 数组基础上给予其行列标签。可以说#xff0c;列表之于字典#xff0c;就如 NumPy 之于 Pandas。Pandas 中#xff0c;所有数…对象的创建
导入 Pandas 时通常给其一个别名“pd”即 import pandas as pd。作为标签库Pandas 对象在 NumPy 数组基础上给予其行列标签。可以说列表之于字典就如 NumPy 之于 Pandas。Pandas 中所有数组特性仍在Pandas 的数据以 NumPy 数组的方式存储。
一维对象的创建
字典创建法 NumPy 中可以通过 np.array()函数将 Python 列表转化为 NumPy 数组同样Pandas 中可以通过 pd.Series()函数将 Python 字典转化为 Series 对象。
import pandas as pd
# 创建字典
dict_v { a:0, b:0.25, c:0.5, d:0.75, e:1 }
# 用字典创建对象
sr pd.Series( dict_v )
sr #OUT:a 0.00# b 0.25# c 0.50# d 0.75# e 1.00# dtype: float64数组创建法 最直接的创建方法即直接给 pd.Series()函数参数其需要两个参数。第一个参数是值 values列表、数组、张量均可第二个参数是键 index索引。
import pandas as pd
# 先定义键与值
v [0, 0.25, 0.5, 0.75, 1]
k [a, b, c, d, e]# 用列表创建对象
sr pd.Series( v, indexk )
sr #OUT:a 0.00# b 0.25# c 0.50# d 0.75# e 1.00# dtype: float64其中参数 index 可以省略省略后索引即从 0 开始的顺序数字。
一维对象的属性
Series 对象有两个属性values 与 index。
import numpy as np
import pandas as pd
# 用数组创建 sr
v np.array( [ 53, 64, 72, 82 ] )
k [1 号, 2 号, 3 号, 4 号]
sr pd.Series( v, indexk )
sr #OUT:1 号 53# 2 号 64# 3 号 72# 4 号 82# dtype: int32
# 查看 values 属性
sr.values #OUT:array([53, 64, 72, 82])
# 查看 index 属性
sr.index #OUT:Index([1 号, 2 号, 3 号, 4 号], dtypeobject)事实上无论是用列表、数组还是张量来创建对象最终 values 均为数组。虽然 Pandas 对象的第一个参数 values 可以传入列表、数组与张量但传进去后默认的存储方式是 NumPy 数组。这一点更加提醒我们Pandas 是建立在 NumPy 基础上的库没有 NumPy 数组库就没有 Pandas 数据处理库。当想要 Pandas 退化为 NumPy 时查看其 values 属性即可。
二维对象的创建
二维对象将面向矩阵其不仅有行标签 index还有列标签 columns。
字典创建法 用字典法创建二维对象时必须基于多个 Series 对象每一个 Series 就是一列数据相当于对一列一列的数据作拼接。
创建 Series 对象时字典的键是 index其延展方向是竖直方向创建 DataFrame 对象时字典的键是 columns其延展方向是水平方向。
import pandas as pd
# 创建 sr1各个病人的年龄
v1 [ 53, 64, 72, 82 ]
i [ 1 号, 2 号, 3 号, 4 号 ]
sr1 pd.Series( v1, indexi )
sr1 #OUT:1 号 53# 2 号 64# 3 号 72# 4 号 82# dtype: int32# 创建 sr2各个病人的性别
v2 [ 女, 男, 男, 女 ]
i [ 1 号, 2 号, 3 号, 4 号 ]
sr2 pd.Series( v2, indexi )
sr2 #OUT:1 号 女# 2 号 男# 3 号 男# 4 号 女# dtype: object
# 创建 df 对象
df pd.DataFrame( { 年龄:sr1, 性别:sr2 } )
df #OUT: 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 72 男# 4 号 82 女如果 sr1 和 sr2 的 index 不完全一致那么二维对象的 index 会取 sr1 与 sr2的所有 index相应的该对象就会产生一定数量的缺失值NaN。 2. 数组创建法 最直接的创建方法即直接给 pd.DataFrame 函数参数其需要三个参数。第一个参数是值 values数组第二个参数是行标签 index第三个参数是列标签columns。其中index 和 columns 参数可以省略省略后即从 0 开始的顺序数字。
import numpy as np
import pandas as pd
# 设定键值
v np.array( [ [53, 女], [64, 男], [72, 男], [82, 女] ] )
i [ 1 号, 2 号, 3 号, 4 号 ]
c [ 年龄, 性别 ]
# 数组创建法
df pd.DataFrame( v, indexi, columnsc )
df #OUT: 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 72 男# 4 号 82 女上述 NumPy 数组居然又含数字又含字符串上一篇博文中明明讲过数组只能容纳一种变量类型。这里的原理是数组默默把数字转为了字符串于是 v 就是一个字符串型数组。
二维对象的属性
DataFrame 对象有三个属性values、index 与 columns。
import pandas as pd
# 设定键值
v [ [53, 女], [64, 男], [72, 男], [82, 女] ]
i [ 1 号, 2 号, 3 号, 4 号 ]
c [ 年龄, 性别 ]
# 数组创建法
df pd.DataFrame( v, indexi, columnsc )
df #OUT: 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 72 男# 4 号 82 女
# 查看 values 属性 # 查看 index 属性
df.index #OUT:array([[53, 女],# [64, 男],# [72, 男],# [82, 女]], dtypeobject)
# 查看 index 属性
df.index #OUT:Index([1 号, 2 号, 3 号, 4 号], dtypeobject)
# 查看 columns 属性
df.columns #OUT:Index([年龄, 性别], dtypeobject)当想要 Pandas 退化为 NumPy 时查看其 values 属性即可。
# 提取完整的数组
arr df.values
print(arr) #OUT:[[53 女]# [64 男]# [72 男]# [82 女]]
# 提取第[0]列并转化为一个整数型数组
arr arr[:,0].astype(int)
print(arr) #OUT:[53 64 72 82]由于数组只能容纳一种变量类型因此需要 .astype(int) 的操作。但对象不用对象每一列的存储方式是单独的这就很好的兼容了大数据的特性。
对象的索引
在学习 Pandas 的索引之前需要知道
Pandas 的索引分为显式索引与隐式索引。显式索引是使用 Pandas 对象提供的索引而隐式索引是使用数组本身自带的从 0 开始的索引。现假设某演示代码中的索引是整数这个时候显式索引和隐式索引可能会出乱子。于是Pandas 作者发明了索引器 loc显式与 iloc隐式手动告诉程序自己这句话是显式索引还是隐式索引。
一维对象的索引
访问元素
import pandas as pd
# 创建 sr
v [ 53, 64, 72, 82 ]
k [1 号, 2 号, 3 号, 4 号]
sr pd.Series( v, indexk )
sr #OUT:1 号 53# 2 号 64# 3 号 72# 4 号 82# dtype: int64
# 访问元素
sr.loc[ 3 号 ] #OUT:72 显示索引
sr.iloc[ 2 ] #OUT:72 隐式索引
# 花式索引
sr.loc[ [ 1 号, 3 号 ] ] #OUT:1 号 53 显示索引# 3 号 72# dtype: int64
sr.iloc[ [ 0, 2 ] ] #OUT:1 号 53 隐式索引# 3 号 72# dtype: int64
# 修改元素
sr.loc[ 3 号 ] 100
sr #OUT:1 号 53 显示索引# 2 号 64# 3 号 100# 4 号 82# dtype: int64
# 修改元素
sr.iloc[ 2 ] 100
sr #OUT:1 号 53 隐式索引# 2 号 64# 3 号 100# 4 号 82# dtype: int64访问切片 使用显式索引时‘1 号’:‘3 号’ 可以涵盖最后一个’3 号’但隐式与之前一样。
import pandas as pd
# 创建 sr
v [ 53, 64, 72, 82 ]
k [1 号, 2 号, 3 号, 4 号]
sr pd.Series( v, indexk )
sr #OUT:1 号 53# 2 号 64# 3 号 72# 4 号 82# dtype: int64
# 访问切片
sr.loc[ 1 号:3 号 ] #OUT: 1 号 53 显示索引# 2 号 64# 3 号 72# dtype: int64
sr.iloc[ 0:3 ] #OUT:1 号 53 隐式索引# 2 号 64# 3 号 72# dtype: int64# 切片仅是视图
cut sr.loc[ 1 号:3 号 ]
cut.loc[1 号] 100
sr #OUT: 1 号 53 显示索引# 2 号 64# 3 号 72# dtype: int64
cut sr.iloc[ 0:3 ]
cut.iloc[0] 100
sr #OUT:1 号 53 隐式索引# 2 号 64# 3 号 72# dtype: int64
# 对象赋值仅是绑定
cut sr
cut.loc[3 号] 200
sr #OUT:1 号 100 显示索引# 2 号 64# 3 号 200# 4 号 82# dtype: int64
cut sr
cut.iloc[2] 200
sr #OUT:1 号 100 隐式索引# 2 号 64# 3 号 200# 4 号 82# dtype: int64若想创建新变量与 NumPy 一样使用.copy()方法即可。如果去掉 .loc 和 .iloc 此时与 NumPy 中的索引语法完全一致。
二维对象的索引
在二维对象中索引器不能去掉否则会报错因此必须适应索引器的存在。
访问元素
import pandas as pd# 字典创建法
i [ 1 号, 2 号, 3 号, 4 号 ]
v1 [ 53, 64, 72, 82 ]
v2 [ 女, 男, 男, 女 ]
sr1 pd.Series( v1, indexi )
sr2 pd.Series( v2, indexi )
df pd.DataFrame( { 年龄:sr1, 性别:sr2 } )
df #OUT:# 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 72 男# 4 号 82 女
# 访问元素
df.loc[ 1 号, 年龄 ] #OUT:53
df.iloc[ 0, 0 ] #OUT:53
# 花式索引
df.loc[ [1 号, 3 号] , [性别,年龄] ] #OUT: 性别 年龄# 1 号 女 53# 3 号 男 72
df.iloc[ [0,2], [1,0] ] #OUT: 性别 年龄# 1 号 女 53# 3 号 男 72
# 修改元素
df.loc[ 3 号, 年龄 ] 100
df #OUT:# 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 100 男# 4 号 82 女
df.iloc[ 2, 0 ] 100
df #OUT:# 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 100 男# 4 号 82 女在 NumPy 数组中花式索引输出的是一个向量。但在 Pandas 对象中考虑到其行列标签的信息不能丢失所以输出一个向量就不行了。 2. 访问切片
import pandas as pd# 数组创建法
v [ [53, 女], [64, 男], [72, 男], [82, 女] ]
i [ 1 号, 2 号, 3 号, 4 号 ]
c [ 年龄, 性别 ]
df pd.DataFrame( v, indexi, columnsc )
df #OUT:# 年龄 性别# 1 号 53 女# 2 号 64 男# 3 号 72 男# 4 号 82 女
# 切片
df.loc[ 1 号:3 号 , 年龄 ] #OUT: 1 号 53# 2 号 64# 3 号 72# Name: 年龄, dtype: int64
df.iloc[ 0:3 , 0 ] #OUT: 1 号 53# 2 号 64# 3 号 72# Name: 年龄, dtype: int64# 提取二维对象的行
df.loc[ 3 号 , : ] #OUT: 年龄 72# 性别 男# Name: 3 号, dtype: object
df.iloc[ 2 , : ] #OUT: 年龄 72# 性别 男# Name: 3 号, dtype: object
# 提取矩阵对象的列
df.loc[ : , 年龄 ] #OUT: 1 号 53# 2 号 64# 3 号 72# 4 号 82# Name: 年龄, dtype: int64
df.iloc[ : , 0 ] #OUT: 1 号 53# 2 号 64# 3 号 72# 4 号 82# Name: 年龄, dtype: int64在显示索引中提取矩阵的行或列还有一种简便写法即
提取二维对象的行df.loc[ ‘3 号’]原理是省略后面的冒号隐式也可以提取二维对象的列df [‘年龄’ ]原理是列标签本身就是二维对象的键
对象的变形
对象的转置
有时候提供的大数据很畸形行是特征列是个体这必须要先进行转置。
import pandas as pd
# 创建畸形 df
v [ [53, 64, 72, 82], [ 女, 男, 男, 女 ] ]
i [ 年龄, 性别 ]
c [ 1 号, 2 号, 3 号, 4 号 ]
df pd.DataFrame( v, indexi, columnsc )
df #OUT: 1 号 2 号 3 号 4 号#年龄 53 64 72 82#性别 女 男 男 女
# 转置
df df.T
df #OUT:# 年龄 性别#1 号 53 女#2 号 64 男#3 号 72 男#4 号 82 女对象的翻转
# 左右翻转
df df.iloc[ : , : : -1 ]
df #OUT:# 性别 年龄 #1 号 女 53 #2 号 男 64 #3 号 男 72 #4 号 女 82 # 上下翻转
df df.iloc[ : : -1 , : ]
df #OUT:# 性别 年龄 #4 号 女 82#3 号 男 72#2 号 男 64#1 号 女 53对象的重塑
考虑到对象是含有行列标签的.reshape()已不再适用因此对象的重塑没有那么灵活。但可以做到将 sr 并入 df也可以将 df 割出 sr。
import pandas as pd
# 数组法创建 sr
i [ 1 号, 2 号, 3 号, 4 号 ]
v1 [ 10, 20, 30, 40 ]
v2 [ 女, 男, 男, 女 ]
v3 [ 1, 2, 3, 4 ]
sr1 pd.Series( v1, indexi )
sr2 pd.Series( v2, indexi )
sr3 pd.Series( v3, indexi )
sr1, sr2, sr3 #OUT:(1 号 10 1 号 女 1 号 1#OUT:2 号 20 2 号 男 2 号 2#OUT:3 号 30 3 号 男 3 号 3#OUT:4 号 40 4 号 女 4 号 4#OUT:dtype: int64, dtype: object, dtype: int64)
# 字典法创建 df
df pd.DataFrame( { 年龄:sr1, 性别:sr2 } )
df #OUT:年龄 性别#1 号 10 女#2 号 20 男#3 号 30 男#4 号 40 女
# 把 sr 并入 df 中
df[牌照] sr3
df #OUT: 年龄 性别 牌照#1 号 10 女 1#2 号 20 男 2#3 号 30 男 3#4 号 40 女 4
# 把 df[年龄]分离成 sr4
sr4 df[年龄]
sr4 #OUT:1 号 10#2 号 20#3 号 30#4 号 40#Name: 年龄, dtype: int64对象的拼接
Pandas 中有一个 pd.concat()函数与 np.concatenate()函数语法相似。
一维对象的合并
import pandas as pd# 创建 sr1 和 sr2
v1 [10, 20, 30, 40]
v2 [40, 50, 60]
k1 [ 1 号, 2 号, 3 号, 4 号 ]
k2 [ 4 号, 5 号, 6 号 ]
sr1 pd.Series( v1, index k1 )
sr2 pd.Series( v2, index k2 )
sr1, sr2 #OUT:(1 号 10# 2 号 20# 3 号 30# 4 号 40# dtype: int64,# 4 号 40# 5 号 50# 6 号 60# dtype: int64)
# 合并
pd.concat( [sr1, sr2] ) #OUT:1 号 10# 2 号 20# 3 号 30# 4 号 40# 4 号 40# 5 号 50# 6 号 60# dtype: int64值得注意的是上述出现了两个“4 号”这是因为 Pandas 对象的属性放弃了集合与字典索引中“不可重复”的特性实际中这可以拓展大数据分析与处理的应用场景。那么如何保证索引是不重复的呢对对象的属性 .index 或 .columns 使用 .is_unique 即可检查返回 True表示行或列不重复False 表示有重复
sr3 pd.concat( [sr1, sr2] )
sr3.index.is_unique #OUT:False一维对象与二维对象的合并 一维对象与二维对象的合并即可理解为给二维对象加上一列或者一行。因此不必使用 pd.concat()函数只需要借助 2.2 小节“二维对象的索引”语法。
import pandas as pd
# 创建 sr1 与 sr2
v1 [ 10, 20, 30]
v2 [ 女, 男, 男]
sr1 pd.Series( v1, index[ 1 号, 2 号, 3 号] )
sr2 pd.Series( v2, index[ 1 号, 2 号, 3 号] )
sr1, sr2 #OUT:(1 号 10# 2 号 20# 3 号 30# dtype: int64,# 1 号 女# 2 号 男# 3 号 男# dtype: object)
# 创建 df
df pd.DataFrame( { 年龄:sr1, 性别:sr2 } )
df #OUT:# 年龄 性别#1 号 10 女#2 号 20 男#3 号 30 男
# 加上一列
df[牌照] [1, 2, 3]
df #OUT:# 年龄 性别 牌照#1 号 10 女 1#2 号 20 男 2#3 号 30 男 3
# 加上一行
df.loc[4 号] [40, 女, 4]
df #OUT:# 年龄 性别 牌照#1 号 10 女 1#2 号 20 男 2#3 号 30 男 3#4 号 40 女 4二维对象的合并 二维对象合并仍然用 pd.concat()函数不过其多了一个 axis 参数。
import pandas as pd
# 设定 df1、df2、df3
v1 [ [10, 女], [20, 男], [30, 男], [40, 女] ]
v2 [ [1, 是], [2, 是], [3, 是], [4, 否] ]
v3 [ [50, 男, 5, 是], [60, 女, 6, 是] ]
i1 [ 1 号, 2 号, 3 号, 4 号 ]
i2 [ 1 号, 2 号, 3 号, 4 号 ]
i3 [ 5 号, 6 号 ]
c1 [ 年龄, 性别 ]
c2 [ 牌照, ikun ]
c3 [ 年龄, 性别, 牌照, ikun ]
df1 pd.DataFrame( v1, indexi1, columnsc1 )
df2 pd.DataFrame( v2, indexi2, columnsc2 )
df3 pd.DataFrame( v3, indexi3, columnsc3 )
df1 #OUT:# 年龄 性别#1 号 10 女#2 号 20 男#3 号 30 男#4 号 40 女
df2 #OUT:# 牌照 ikun#1 号 1 是#2 号 2 是#3 号 3 是#4 号 4 否
df3 #OUT:# 年龄 性别 牌照 ikun#5 号 50 男 5 是#6 号 60 女 6 是
# 合并列对象添加列特征
df pd.concat( [df1,df2], axis1 )
df #OUT: 年龄 性别 牌照 ikun#1 号 10 女 1 是#2 号 20 男 2 是#3 号 30 男 3 是#4 号 40 女 4 否
# 合并行对象添加行个体
df pd.concat( [df,df3] )
df #OUT:# 年龄 性别 牌照 ikun#1 号 10 女 1 是#2 号 20 男 2 是#3 号 30 男 3 是#4 号 40 女 4 否#5 号 50 男 5 是#6 号 60 女 6 是对象的运算
对象与系数之间的运算
一维对象
import pandas as pd
# 创建 sr
sr pd.Series( [ 53, 64, 72 ] , index[1 号, 2 号, 3 号] )
sr #OUT:1 号 53# 2 号 64# 3 号 72# dtype: int64
sr sr 10
sr #OUT:1 号 63# 2 号 74# 3 号 82# dtype: int64
sr sr * 10
sr #OUT:1 号 630# 2 号 740# 3 号 820# dtype: int64
sr sr ** 2
sr #OUT:1 号 396900# 2 号 547600# 3 号 672400# dtype: int64二维对象
import pandas as pd
# 创建 df
v [ [53, 女], [64, 男], [72, 男] ]
df pd.DataFrame( v, index[ 1 号, 2 号, 3 号 ], columns[ 年龄, 性别 ] )
df #OUT: 年龄 性别#1 号 53 女#2 号 64 男#3 号 72 男
df[年龄] df[年龄] 10
df #OUT: 年龄 性别#1 号 63 女#2 号 74 男#3 号 82 男
df[年龄] df[年龄] * 10
df #OUT: 年龄 性别#1 号 630 女#2 号 740 男#3 号 820 男
df[年龄] df[年龄] ** 2
df #OUT: 年龄 性别#1 号 396900 女#2 号 547600 男#3 号 672400 男对象与对象之间的运算
对象做运算必须保证其都是数字型对象两个对象之间的维度可以不同。
一维对象之间的运算
import pandas as pd# 创建 sr1
v1 [10, 20, 30, 40]
k1 [ 1 号, 2 号, 3 号, 4 号 ]
sr1 pd.Series( v1, index k1 )
sr1 #OUT:1 号 10# 2 号 20# 3 号 30# 4 号 40# dtype: int64
# 创建 sr2
v2 [1, 2, 3 ]
k2 [ 1 号, 2 号, 3 号 ]
sr2 pd.Series( v2, index k2 )
sr2 #OUT: 1 号 1# 2 号 2# 3 号 3# dtype: int64
sr1 sr2 #OUT:1 号 11.0 加法# 2 号 22.0# 3 号 33.0# 4 号 NaN# dtype: float64
sr1 - sr2 #OUT:1 号 9.0 减法# 2 号 18.0# 3 号 27.0# 4 号 NaN# dtype: float64
sr1 * sr2 #OUT:1 号 10.0 乘法# 2 号 40.0# 3 号 90.0# 4 号 NaN# dtype: float64
sr1 / sr2 #OUT:1 号 10.0 乘法# 2 号 10.0# 3 号 10.0# 4 号 NaN# dtype: float64
sr1 ** sr2 #OUT:1 号 10.0 乘法# 2 号 400.0# 3 号 27000.0# 4 号 NaN# dtype: float64二维对象之间的运算
import pandas as pd
# 设定 df1 和 df2
v1 [ [10, 女], [20, 男], [30, 男], [40, 女] ]
v2 [ 1, 2 ,3, 6 ]
i1 [ 1 号, 2 号, 3 号, 4 号 ]; c1 [ 年龄, 性别 ]
i2 [ 1 号, 2 号, 3 号, 6 号 ]; c2 [ 牌照 ]
df1 pd.DataFrame( v1, indexi1, columnsc1 )
df2 pd.DataFrame( v2, indexi2, columnsc2 )
df1 #OUT:# 年龄 性别#1 号 10 女#2 号 20 男#3 号 30 男#4 号 40 女
df2 #OUT:# 牌照#1 号 1#2 号 2#3 号 3#6 号 6
# 加法
df1[加法] df1[年龄] df2[牌照]
df1 #OUT:# 年龄 性别 加法#1 号 10 女 11.0#2 号 20 男 22.0#3 号 30 男 33.0#4 号 40 女 NaN
# 减法、乘法、除法、幂方
df1[减法] df1[年龄] - df2[牌照]
df1[乘法] df1[年龄] * df2[牌照]
df1[除法] df1[年龄] / df2[牌照]
df1[幂方] df1[年龄] ** df2[牌照]
df1 #OUT:# 年龄 性别 加法 减法 乘法 除法 幂方#1 号 10 女 11.0 9.0 10.0 10.0 10.0#2 号 20 男 22.0 18.0 40.0 10.0 400.0#3 号 30 男 33.0 27.0 90.0 10.0 27000.0#4 号 40 女 NaN NaN NaN NaN NaN使用 np.abs()、np.cos()、np.exp()、np.log() 等数学函数时会保留索引Pandas 中仍然存在布尔型对象用法与 NumPy 无异会保留索引。
对象的缺失值
发现缺失值
发现缺失值使用 .isnull() 方法。
import pandas as pd
# 创建 sr
v [ 53, None, 72, 82 ]
k [1 号, 2 号, 3 号, 4 号]
sr pd.Series( v, indexk )
sr #OUT:1 号 53.0#2 号 NaN#3 号 72.0#4 号 82.0#dtype: float64
# 创建 df
v [ [None, 1], [64, None], [72, 3], [82, 4] ]
i [ 1 号, 2 号, 3 号, 4 号 ]
c [ 年龄, 牌照 ]
df pd.DataFrame( v, indexi, columnsc )
df #OUT: 年龄 牌照#1 号 NaN 1.0#2 号 64.0 NaN#3 号 72.0 3.0#4 号 82.0 4.0
# 发现 sr 的缺失值
sr.isnull() #OUT: 1 号 False# 2 号 True# 3 号 False# 4 号 False# dtype: float64
df.isnull() #OUT: 年龄 牌照#1 号 True False#2 号 False True#3 号 False False#4 号 False False除了.isnull() 方法还有一个与之相反的 .notnull() 方法但不如在开头加一个非号“~”即可。
剔除缺失值
剔除缺失值使用 .dropna() 方法一维对象很好剔除二维对象比较复杂要么单独剔除 df 中含有缺失值的行要么剔除 df 中含有缺失值的列。
import pandas as pd
# 创建 sr
v [ 53, None, 72, 82 ]
k [1 号, 2 号, 3 号, 4 号]
sr pd.Series( v, indexk )
sr #OUT:1 号 53.0#2 号 NaN#3 号 72.0#4 号 82.0#dtype: float64
# 剔除 sr 的缺失值
sr.dropna() #OUT:1 号 53.0#3 号 72.0#4 号 82.0#dtype: float64# 创建 df
v [ [None, None], [64, None], [72, 3], [82, 4] ]
i [ 1 号, 2 号, 3 号, 4 号 ]
c [ 年龄, 牌照 ]
df pd.DataFrame( v, indexi, columnsc )
df #OUT: 年龄 牌照#1 号 NaN NaN#2 号 64.0 NaN#3 号 72.0 3.0#4 号 82.0 4.0
df.dropna() #OUT: 年龄 牌照#3 号 72.0 3.0#4 号 82.0 4.0把含有 NaN 的行剔除掉了你也可以通过 df.dropna(axis‘columns’)的方式剔除列。但请警惕一般都是剔除行只因大数据中行是个体列是特征。 有些同学认为只要某行含有一个 NaN 就剔除该个体太过残忍我们可以设定一个参数只有当该行全部是 NaN才剔除该列特征。
df.dropna(howall) #OUT: 年龄 牌照#2 号 64.0 NaN#3 号 72.0 3.0#4 号 82.0 4.0ps:也可以设置缺失值大于几行时剔除。
填补缺失值
填充缺失值使用 .fillna() 方法实际的数据填充没有统一的方法很灵活。
一维对象
import pandas as pd
# 创建 sr
v [ 53, None, 72, 82 ]
sr pd.Series( v, index[1 号, 2 号, 3 号, 4 号] )
sr #OUT:1 号 53.0#2 号 NaN#3 号 72.0#4 号 82.0#dtype: float64
# 用常数0填充
sr.fillna(0) #OUT:1 号 53.0#2 号 0.0#3 号 72.0#4 号 82.0#dtype: float64
# 用常数均值填充
import numpy as np
sr.fillna(np.mean(sr)) #OUT:1 号 53.0#2 号 69.0#3 号 72.0#4 号 82.0#dtype: float64
# 用前值填充
sr.fillna(methodffill) #OUT:1 号 53.0#2 号 53.0#3 号 72.0#4 号 82.0#dtype: float64
# 用后值填充
sr.fillna(methodbfill) #OUT:1 号 53.0#2 号 72.0#3 号 72.0#4 号 82.0#dtype: float64二维对象
import pandas as pd
# 设定 df
v [ [None, None], [64, None], [72, 3], [82, 4] ]
i [ 1 号, 2 号, 3 号, 4 号 ]; c [ 年龄, 牌照 ]
df pd.DataFrame( v, indexi, columnsc )
df #OUT:# 年龄 牌照#1 号 NaN NaN#2 号 64.0 NaN#3 号 72.0 3.0#4 号 82.0 4.0
# 用常数0填充
df.fillna(0) #OUT:# 年龄 牌照#1 号 0.0 0.0#2 号 64.0 0.0#3 号 72.0 3.0#4 号 82.0 4.0
# 用常数均值填充
import numpy as np
df.fillna( np.mean(df))#OUT:# 年龄 牌照#1 号 72.69 3.5#2 号 64.0 3.5#3 号 72.0 3.0#4 号 82.0 4.0
# 用前值填充
df.fillna(methodffill)#OUT:# 年龄 牌照#1 号 NaN NaN#2 号 64.0 NaN#3 号 72.0 3.0#4 号 82.0 4.0
# 用后值填充
df.fillna(methodbfill)#OUT:# 年龄 牌照#1 号 64.0 3.0#2 号 64.0 3.0#3 号 72.0 3.0#4 号 82.0 4.0导入Excel文件
创建Excel文件
首先创建 Excel 文件录入信息第一列为 index第一行为 columns。字体选择微软雅黑即可 如果你的数据没有 index 和 columns也即你只是想导入一个数组那么也请先补上行列标签后续用 .values 属性就能将二维对象转换为数组。 接着将其另存为为 CSV 文件在另存为的弹窗里面的保存类型选择.csv 。
放入项目文件夹
将刚刚另存为的 CSV 文件放置工程文件下不一定是默认路径。
导入Excel信息
import pandas as pd
# 导入 Pandas 对象
df pd.read_csv(Data.csv, index_col0)
df #OUT: # age Mgender num kun#1号 10.0 女 1 是#2号 20.0 男 2 是#3号 30.0 男 3 是#4号 40.0 女 4 否#5号 50.0 男 5 是#6号 60.0 女 6 是
# 提取纯数组
arr df.values
arr #OUT:array([[10.0, 女, 1, 是],# [20.0, 男, 2, 是],# [30.0, 男, 3, 是],# [40.0, 女, 4, 否],# [50.0, 男, 5, 是],# [60.0, 女, 6, 是]], dtypeobject)数据分析
导入信息
按上一章内容导入信息
import pandas as pd
# 导入 Pandas 对象
pd.read_csv(行星数据.csv, index_col0, encoding gbk)聚合方法
可在输出 df 时对其使用 .head() 方法使其仅输出前五行。
df pd.read_csv(行星数据.csv, index_col0, encoding gbk)
df.head()NumPy 中所有的聚合函数对 Pandas 对象均适用。此外Pandas 将这些函数变为对象的方法这样不导入 NumPy 也可使用。
# 最大值函数 np.max( )
df.max()
# 最小值函数 np.min( )
df.min()
# 均值函数 np.mean( )
df.mean()
# 标准差函数 np.std( )
df.std()
# 求和函数 np.sum( )
df.sum()在这些方法中像 NumPy 中一样有默认值为 0 的参数 axis。一般不要将其数值手动设定为 1因为这种情况在数据分析中毫无意义。此外这些方法都忽略了缺失值属于 NumPy 中聚合函数的安全版本。
描述方法
在数据分析中用以上方法挨个查看未免太过麻烦可以使用 .describe() 方法直接查看所有聚合函数的信息。
第 1 行 count 是计数项统计每个特征的有效数量即排除缺失值从 count可以看出行星质量的缺失值比较多需要考虑一定的办法填充或舍弃。第 2 行至第 3 行的 mean 与 std 统计每列特征的均值与标准差。第 4 行至第 8 行的 min、25%、50%、75%、max 的意思是五个分位点即把数组从小到大排序后0%、25%、50%、75%、100%五个位置上的数值的取值。显然50%分位点即中位数。
数据透视
两个特征内的数据透视 数据透视对数据分析来讲十分重要。 现以泰坦尼克号的生还数据为例以“是否生还”特征为考察的核心或者说是神经网络的输出研究其它特征输入与之的关系如示例所示。
import pandas as pd
# 导入 Pandas 对象
df pd.read_csv(泰坦尼克.csv, index_col0)
df.head()
# 一个特征性别
df.pivot_table(是否生还, index性别)
# 两个特征性别、船舱等级
df.pivot_table(是否生还, index性别, columns船舱等级)在上述示例中数据透视表中的数值默认是输出特征“是否生还”的均值mean行标签和列标签变成了其它的输入特征。值得注意的是pivot_table() 方法有一个很重要的参数aggfunc其默认值是’mean’除此以外所有的聚合函数 ‘max’、‘min’、‘sum’、‘count’ 均可使用。显然对于这里的“是否生还”来说mean’就是最好的选择其刚好为概率
多个特征的数据透视 前面的示例只涉及到两个特征有时需要考察更多特征与输出特征的关系。 这里将年龄和费用都加进去。但是这两个特征的数值很分散之前的性别和船舱等级都可以按照类别分现在已经不能再按类别分了。因此需要涉及到数据透视表配套的两个重要函数pd.cut()与 pd.qcut()
# 三个特征性别、船舱等级、年龄
age pd.cut( df[年龄], [0,18,120] ) # 以 18 岁为分水岭
df.pivot_table(是否生还, index [性别, age], columns船舱等级)# 四个特征性别、船舱等级、年龄、费用
fare pd.qcut( df[费用], 2 ) # 将费用自动分为两部分
df.pivot_table(是否生还, index [船舱等级,fare], columns[性别, age])pd.cut()函数需要手动设置分割点也可以设置为[0,18,60,120]。pd.qcut()函数可自动分割如果需要分割成 3 部分可以设置为 3。
