Python数据分析

Posted 雨宙

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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'>
  1. 索引对象不可变，保证数据安全
  2. 常见的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
  1. 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
  1. 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
  1. 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
  1. 需要注意的是，使用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
  1. 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
  1. 切片索引，需要注意的是，利用位置切片索引，不包含终止索引；利用标签切片索引，包含终止索引。
# 切片索引
# 位置切片索引，不包含终止索引
print(ps1[1:4])
# b    1
# c    2
# d    3
# dtype: int64
# 标签切片索引，包含终止索引
print(ps1['b':'d'])
# b    1
# c    2
# d    3
# dtype: int64
  1. 不连续索引
# 不连续索引
print(ps1[['b','e']])
# b    1
# e    4
# dtype: int64
print(ps1[[0,2,3]])
# a    1000
# c       2
# d       3
# dtype: int64
  1. 布尔索引
# 布尔索引
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
  1. 通过列索引和行索引取到某一行某一列的具体数据
pd1['A']['a']
# 1000
  1. 切片索引，此时的切片是针对行来说的
# 切片
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
  1. 匹配行索引
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
  1. 通过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
  1. 按值排序
    （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)
  1. 使用is_unique判断是否唯一
s1.index.is_unique
# False
s1.is_unique
# False
  1. 使用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
  1. 判断数据是否存在
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
  1. 丢弃缺失数据
df3.dropna() # 默认丢弃行
df3.dropna(axis=1) # 丢弃列
  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

层级索引

  1. 选取指定外层索引和内层索引
s1 = pd.Series(np.random.randn以上是关于Python数据分析的主要内容，如果未能解决你的问题，请参考以下文章
 

 python第十四课--排序及自定义函数之案例一：选择排序


 python - 如何通过考虑规则来使python中的日期升序？ [复制]


 Python描述 LeetCode 23. 合并K个升序链表


 pandas层次化索引


 python基础装饰器


 Python一路走来 - python基础 数据类型