[Python知识库]Python数据分析（三）

Python数据分析（三）

打卡第七天啦！！！

pandas库（二）

pandas索引操作

index对象

1. 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'>

2. 索引对象不可变，保证数据安全
3. 常见的index种类：Index索引、Int64Index整数索引、MultiIndex层级索引、DatetimeIndex时间戳类型

重新索引

reindex创建一个符合新索引的新对象

1. 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

2. 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

增

1. 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

2. 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

删

1. 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

2. 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

3. 需要注意的是，使用drop也可以在原数据上直接进行修改，只需要设置inplace属性

# inplace属性 在原对象上删除，并不会返回新的对象
ps.drop('d',inplace=True)
print(ps)
# a    0
# b    1
# c    2
# dtype: int64

改

1. 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

2. 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中的查找操作

1. 行索引

# 行索引
ps1
# a    1000
# b       1
# c       2
# d       3
# e       4
# dtype: int64
print(ps1['a'])
# 1000
print(ps1[0])
# 1000

2. 切片索引，需要注意的是，利用位置切片索引，不包含终止索引；利用标签切片索引，包含终止索引。

# 切片索引
# 位置切片索引，不包含终止索引
print(ps1[1:4])
# b    1
# c    2
# d    3
# dtype: int64
# 标签切片索引，包含终止索引
print(ps1['b':'d'])
# b    1
# c    2
# d    3
# dtype: int64

3. 不连续索引

# 不连续索引
print(ps1[['b','e']])
# b    1
# e    4
# dtype: int64
print(ps1[[0,2,3]])
# a    1000
# c       2
# d       3
# dtype: int64

4. 布尔索引

# 布尔索引
ps1[ps1>2]
# a    1000
# d       3
# e       4
# dtype: int64

DataFrame中的查找操作

1. 列索引，通过列索引查找某一列数据，返回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

2. 通过列索引和行索引取到某一行某一列的具体数据

pd1['A']['a']
# 1000

3. 切片索引，此时的切片是针对行来说的

# 切片
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混合运算

1. 匹配列索引

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

2. 匹配行索引

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

1. 通过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

2. 通过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

排序

1. 索引排序

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

2. 按值排序
   （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']))

唯一值和成员属性

1. 使用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)

2. 使用is_unique判断是否唯一

s1.index.is_unique
# False
s1.is_unique
# False

3. 使用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

4. 判断数据是否存在

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

处理缺失数据

1. 判断是否存在缺失值

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

2. 丢弃缺失数据

df3.dropna() # 默认丢弃行
df3.dropna(axis=1) # 丢弃列

3. 填充缺失数据

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

层级索引

1. 选取指定外层索引和内层索引

s1 = 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(type(s1.index))
# <class 'pandas.core.indexes.multi.MultiIndex'>
# 选取
# 外层选取
s1['b']
# 0   -0.685567
# 1    0.227194
# 2    0.453674
# dtype: float64

# 内层选取
s1[:,2] # 选取所有的外层索引，内层索引为2
# a    1.908277
# b    0.453674
# c   -0.350985
# d    0.893875
# dtype: float64

s1['a',2]
# 1.908276903906101

2. 交换内层索引和外层索引

# 交换内层索引和外层索引
s1.swaplevel()

pandas统计计算和描述

df = pd.DataFrame([[1.4,np.nan],[7.1,-4.5],
                 [np.nan,np.nan],[0.75,-1.3]],
                 index=['a','b','c','d'],
                 columns=['one','two'])
df.sum() # 默认按列求和
# one    9.25
# two   -5.80
# dtype: float64
df.sum(axis=1) # nan自动排除
# a    1.40
# b    2.60
# c    0.00
# d   -0.55
# dtype: float64
df.sum(axis=1,skipna=False)
# a     NaN
# b    2.60
# c     NaN
# d   -0.55
# dtype: float64

df.idxmax() # 返回最大值的索引
# one    b
# two    d
# dtype: object

df.cumsum() # 样本值的累计和
#     one  two
# a  1.40  NaN
# b  8.50 -4.5
# c   NaN  NaN
# d  9.25 -5.8

df.describe() # 汇总统计
#             one       two
# count  3.000000  2.000000
# mean   3.083333 -2.900000
# std    3.493685  2.262742
# min    0.750000 -4.500000
# 25%    1.075000 -3.700000
# 50%    1.400000 -2.900000
# 75%    4.250000 -2.100000
# max    7.100000 -1.300000
s1 = pd.Series(['a','a','b','c']*4)
s1.describe()
# count     16
# unique     3
# top        a
# freq       8
# dtype: object