Python数据分析
Posted 雨宙
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python数据分析相关的知识，希望对你有一定的参考价值。
Python数据分析（三）
打卡第七天啦！！！
pandas库（二）
pandas索引操作
index对象
- Series和DataFrame中的索引都是Index对象
import pandas as pd
import numpy as np
ps = pd.Series(range(5),index=['a','b','c','d','e'])
print(ps)
print(type(ps.index)) # <class 'pandas.core.indexes.base.Index'>
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['A','B','C'])
print(pd1)
print(type(pd1.index)) # <class 'pandas.core.indexes.base.Index'>
print(type(pd1.columns)) # <class 'pandas.core.indexes.base.Index'>
- 索引对象不可变，保证数据安全
- 常见的index种类：Index索引、Int64Index整数索引、MultiIndex层级索引、DatetimeIndex时间戳类型
重新索引
reindex创建一个符合新索引的新对象
- Series中的重新索引
ps1 = ps.reindex(['a','b','c','d','e','f'])
print(ps1)
# a 0.0
# b 1.0
# c 2.0
# d 3.0
# e 4.0
# f NaN
# dtype: float64
- DataFrame中的重新索引
# 行索引重建
pd2 = pd1.reindex(index=['a','b','c','d'])
print(pd2)
# A B C
# a 0.0 1.0 2.0
# b 3.0 4.0 5.0
# c 6.0 7.0 8.0
# d NaN NaN NaN
# 列索引重建
pd3 = pd1.reindex(columns=['C','B','A'])
print(pd3)
# C B A
# a 2 1 0
# b 5 4 3
# c 8 7 6
增
- Series中的增加操作
s1 = pd.Series({'f':999})
ps4 = ps.append(s1)
print(ps4)
# a 0
# b 1
# c 2
# d 3
# e 4
# f 999
# dtype: int64
- DataFrame中的增加操作
# 插入列
pd1.insert(0,'E',[9,99,999])
print(pd1)
# E A B C
# a 9 0 1 2
# b 99 3 4 5
# c 999 6 7 8
# 插入行
# 第一种方法：标签索引
pd1.loc['d'] = [1,1,1,1]
print(pd1)
# E A B C
# a 9 0 1 2
# b 99 3 4 5
# c 999 6 7 8
# d 1 1 1 1
# 第二种方法
row = {'E':6,'A':6,'B':6,'C':6}
pd5 = pd1.append(row,ignore_index=True)
print(pd5)
# E A B C
# 0 9 0 1 2
# 1 99 3 4 5
# 2 999 6 7 8
# 3 1 1 1 1
# 4 6 6 6 6
删
- Series中的删除操作，其中分为两种情况，一种是直接在原数据上进行删除，另外一种是先拷贝一份再进行删除
（1）在原数据上直接进行删除
del ps['e']
print(ps)
# a 0
# b 1
# c 2
# d 3
# dtype: int64
（2）不在原数据上直接进行删除，删除后返回新对象
# 不在原有数据上修改
ps1 = ps.drop('d')
print(ps1)
# a 0
# b 1
# c 2
# dtype: int64
# 删除多条
ps1 = ps.drop(['c','d'])
print(ps1)
# a 0
# b 1
# dtype: int64
- DataFrame中的删除操作，其中分为两种情况，一种是直接在原数据上进行删除，另外一种是先拷贝一份再进行删除
（1）在原数据上直接进行删除（使用del关键字，但只能删除列）
# 通过del只能删除列
del pd1['E']
print(pd1)
# A B C
# a 0 1 2
# b 3 4 5
# c 6 7 8
# d 1 1 1
（2）不在原数据上直接进行删除，删除后返回新对象（使用drop方法，通过设置axis可以删除行或列）
# 默认删除行数据
pd2 = pd1.drop('a')
print(pd2)
# A B C
# b 3 4 5
# c 6 7 8
# d 1 1 1
# 删除列数据
pd2 = pd1.drop('A',axis=1) # axis=1与axis='columns'效果相同
print(pd2)
# B C
# a 1 2
# b 4 5
# c 7 8
# d 1 1
- 需要注意的是，使用drop也可以在原数据上直接进行修改，只需要设置inplace属性
# inplace属性 在原对象上删除，并不会返回新的对象
ps.drop('d',inplace=True)
print(ps)
# a 0
# b 1
# c 2
# dtype: int64
改
- Series中的修改操作，直接使用索引修改
ps1['a'] = 999
ps1
# a 999
# b 1
# c 2
# d 3
# e 4
# dtype: int64
ps1[0] = 1000
ps1
# a 1000
# b 1
# c 2
# d 3
# e 4
# dtype: int64
- DataFrame中的修改操作，可以使用索引修改，或使用对象.列的方式修改，但只能修改列数据，另一种方法是使用loc标签索引修改数据，可以修改行数据，以及某一行某一列的具体数据
# 直接使用索引
pd1['A'] = 9
print(pd1)
# A B C
# a 9 1 2
# b 9 4 5
# c 9 7 8
pd1['A'] = [9,10,11]
print(pd1)
# A B C
# a 9 1 2
# b 10 4 5
# c 11 7 8
# 对象.列的形式
pd1.A = 6
print(pd1)
# A B C
# a 6 1 2
# b 6 4 5
# c 6 7 8
# 修改行
# 使用loc标签索引
pd1.loc['a'] = 9
print(pd1)
# A B C
# a 9 9 9
# b 6 4 5
# c 6 7 8
# 修改某一个具体数据
pd1.loc['a','A'] = 1000
print(pd1)
# A B C
# a 1000 9 9
# b 6 4 5
# c 6 7 8
查
Series中的查找操作
- 行索引
# 行索引
ps1
# a 1000
# b 1
# c 2
# d 3
# e 4
# dtype: int64
print(ps1['a'])
# 1000
print(ps1[0])
# 1000
- 切片索引，需要注意的是，利用位置切片索引，不包含终止索引；利用标签切片索引，包含终止索引。
# 切片索引
# 位置切片索引，不包含终止索引
print(ps1[1:4])
# b 1
# c 2
# d 3
# dtype: int64
# 标签切片索引，包含终止索引
print(ps1['b':'d'])
# b 1
# c 2
# d 3
# dtype: int64
- 不连续索引
# 不连续索引
print(ps1[['b','e']])
# b 1
# e 4
# dtype: int64
print(ps1[[0,2,3]])
# a 1000
# c 2
# d 3
# dtype: int64
- 布尔索引
# 布尔索引
ps1[ps1>2]
# a 1000
# d 3
# e 4
# dtype: int64
DataFrame中的查找操作
- 列索引，通过列索引查找某一列数据，返回Series对象，需要注意的是，在取多列数据时，用两个中括号。
# 列索引
pd1['A']
# a 1000
# b 6
# c 6
# Name: A, dtype: int64
# 取多列
print(pd1[['A','C']])
# A C
# a 1000 9
# b 6 5
# c 6 8
- 通过列索引和行索引取到某一行某一列的具体数据
pd1['A']['a']
# 1000
- 切片索引，此时的切片是针对行来说的
# 切片
print(pd1[:2]) # 获取行
# A B C
# a 1000 9 9
# b 6 4 5
高级索引
loc标签索引
# loc是基于标签名的索引 自定义的索引名
ps1.loc['a':'c']
# a 1000
# b 1
# c 2
# dtype: int64
ps1['a':'c']
# a 1000
# b 1
# c 2
# dtype: int64
pd1.loc['a':'b','A':'C'] # 第一个参数是索引行 第二个参数是列
iloc位置索引
ps1.iloc[1:3]
# b 1
# c 2
# dtype: int64
ps1[1:3]
# b 1
# c 2
# dtype: int64
print(pd1.iloc[0:3,0:2])
# A B
# a 1000 9
# b 6 4
# c 6 7
ix标签与位置混合索引（不推荐使用）
pandas库（三）
对齐运算
算术运算和数据对
s1 = pd.Series(np.arange(4),index=['a','b','c','d'])
s2 = pd.Series(np.arange(5),index=['a','c','e','f','g'])
s1+s2
# a 0.0
# b NaN
# c 3.0
# d NaN
# e NaN
# f NaN
# g NaN
# dtype: float64
df1 = pd.DataFrame(np.arange(12).reshape(4,3),index=['a','b','c','d'],columns=list('ABC'))
df2 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','d','f'],columns=list('ABD'))
print(df1+df2)
# A B C D
# a 0.0 2.0 NaN NaN
# b NaN NaN NaN NaN
# c NaN NaN NaN NaN
# d 12.0 14.0 NaN NaN
# f NaN NaN NaN NaN
填充值
s1.add(s2,fill_value=0)
# a 0.0
# b 1.0
# c 3.0
# d 3.0
# e 2.0
# f 3.0
# g 4.0
# dtype: float64
print(df1.add(df2,fill_value=0))
# A B C D
# a 0.0 2.0 2.0 2.0
# b 3.0 4.0 5.0 NaN
# c 6.0 7.0 8.0 NaN
# d 12.0 14.0 11.0 5.0
# f 6.0 7.0 NaN 8.0
DataFrame和Series混合运算
- 匹配列索引
s3 = df1.iloc[0]
s3
# A 0
# B 1
# C 2
# Name: a, dtype: int32
print(df1 - s3)
# A B C
# a 0 0 0
# b 3 3 3
# c 6 6 6
# d 9 9 9
- 匹配行索引
s4 = df1['A']
s4
# a 0
# b 3
# c 6
# d 9
# Name: A, dtype: int32
print(df1.sub(s4,axis=0)) # 指定轴为列
# A B C
# a 0 1 2
# b 0 1 2
# c 0 1 2
# d 0 1 2
函数应用
apply和applymap
- 通过apply将函数应用到列或行
print(df)
# 0 1 2 3
# 0 0.256674 -1.556277 2.230852 0.682209
# 1 1.791964 -0.085436 2.139264 -0.369255
# 2 1.241260 -0.195090 0.806148 -0.670290
# 3 1.678381 1.694978 0.595143 2.214359
# 4 -0.352148 -1.230048 -0.670016 -0.071479
f = lambda x:x.max()
df.apply(f)
# 0 1.791964
# 1 1.694978
# 2 2.230852
# 3 2.214359
# dtype: float64
# 默认轴的方向 默认axis=0列
df.apply(f,axis=1)
# 0 2.230852
# 1 2.139264
# 2 1.241260
# 3 2.214359
# 4 -0.071479
# dtype: float64
- 通过applymap将函数应用到每个数据
f2 = lambda x:'%.2f'%x # 保留两位小数
print(df.applymap(f2))
# 0 1 2 3
# 0 0.26 -1.56 2.23 0.68
# 1 1.79 -0.09 2.14 -0.37
# 2 1.24 -0.20 0.81 -0.67
# 3 1.68 1.69 0.60 2.21
# 4 -0.35 -1.23 -0.67 -0.07
排序
- 索引排序
s1 = pd.Series(np.arange(4),index=list('dbca'))
s1
# d 0
# b 1
# c 2
# a 3
# dtype: int32
s1.sort_index() # 默认升序
# a 3
# b 1
# c 2
# d 0
# dtype: int32
s1.sort_index(ascending = False)
# d 0
# c 2
# b 1
# a 3
# dtype: int32
pd1 = pd.DataFrame(np.arange(12).reshape(4,3),index=list('bdca'),columns=list('BCA'))
# 按照行排序
print(pd1.sort_index())
# B C A
# a 9 10 11
# b 0 1 2
# c 6 7 8
# d 3 4 5
# 按照列排序
print(pd1.sort_index(axis=1))
# A B C
# b 2 0 1
# d 5 3 4
# c 8 6 7
# a 11 9 10
- 按值排序
（1）NAN值排最后
（2）指定ascending属性可以降序或升序排列
（3）DataFrame需要指定列进行排序，也可以指定多列
s1.sort_values() # 根据值的大小进行排序
# d 0
# b 1
# c 2
# a 3
# dtype: int32
s1['a'] = np.nan
s1.sort_values() # 根据值的大小进行排序,当有缺失值，默认排最后
# d 0.0
# b 1.0
# c 2.0
# a NaN
# dtype: float64
s1.sort_values(ascending = False)
# c 2.0
# b 1.0
# d 0.0
# a NaN
# dtype: float64
pd2 = pd.DataFrame({'a':[3,7,9,0],'b':[1,-1,4,8],'c':[0,6,-3,2]})
print(pd2)
# a b c
# 0 3 1 0
# 1 7 -1 6
# 2 9 4 -3
# 3 0 8 2
# 指定一列排序
print(pd2.sort_values(by='a'))
# a b c
# 3 0 8 2
# 0 3 1 0
# 1 7 -1 6
# 2 9 4 -3
# 指定多列排序
print(pd2.sort_values(by=['a','b']))
唯一值和成员属性
- 使用unique方法查找唯一值
s1 = pd.Series([2,6,8,9,3,6],index=['a','a','c','c','e','e'])
s2 = s1.unique()
# array([2, 6, 8, 9, 3], dtype=int64)
- 使用is_unique判断是否唯一
s1.index.is_unique
# False
s1.is_unique
# False
- 使用value_counts方法计算每个值出现的个数
# 计算值的个数
s1 = pd.Series([2,6,8,9,3,6])
s1.value_counts() # 返回Series
# 6 2
# 3 1
# 2 1
# 9 1
# 8 1
# dtype: int64
- 判断数据是否存在
s1.isin([8]) # 判断数据是否存在，返回布尔类型，也可以判断多个值
# 0 False
# 1 False
# 2 True
# 3 False
# 4 False
# 5 False
# dtype: bool
data = pd.DataFrame({'a':[3,7,9,0],'b':[1,-1,4,8],'c':[0,6,-3,2]})
print(data.isin([2,4]))
# a b c
# 0 False False False
# 1 False False False
# 2 False True False
# 3 False False True
处理缺失数据
- 判断是否存在缺失值
df3 = pd.DataFrame([np.random.randn(3),[1.,2.,np.nan],
[np.nan,4.,np.nan],[1.,2.,3.]])
df3.isnull()
# 0 1 2
# 0 False False False
# 1 False False True
# 2 True False True
# 3 False False False
- 丢弃缺失数据
df3.dropna() # 默认丢弃行
df3.dropna(axis=1) # 丢弃列
- 填充缺失数据
df3.fillna(-1)
# 0 1 2
# 0 -0.931614 0.612775 -0.070913
# 1 1.000000 2.000000 -1.000000
# 2 -1.000000 4.000000 -1.000000
# 3 1.000000 2.000000 3.000000
层级索引
- 选取指定外层索引和内层索引
s1 =以上是关于Python数据分析的主要内容，如果未能解决你的问题，请参考以下文章