Pandas使用（三）

描述性统计的概述和计算

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'), columns=list('abcd'))
   ...:
Out[3]:
   a  b   c   d
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

In [4]: df = pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'), columns=list('abcd'))

In [5]: # 计算nan的个数

In [6]: df.count()
Out[6]:
a    3
b    3
c    3
d    3
dtype: int64

In [7]: # 计算最小值

In [8]: df.min()
Out[8]:
a    0
b    1
c    2
d    3
dtype: int32

# 计算出最大值,默认为行
In [9]: df.max()
Out[9]:
a     8
b     9
c    10
d    11
dtype: int32
    
# 查看相关信息
In [10]: df.info()
<class 'pandas.core.frame.DataFrame'>
Index: 3 entries, a to c
Data columns (total 4 columns):
a    3 non-null int32
b    3 non-null int32
c    3 non-null int32
d    3 non-null int32
dtypes: int32(4)
memory usage: 72.0+ bytes

# 计算出总和
In [11]: df.sum()
Out[11]:
a    12
b    15
c    18
d    21
dtype: int64

# 计算出最小的标签索引
In [12]: df.idxmin()
Out[12]:
a    a
b    a
c    a
d    a
dtype: object

# 计算出最大的标签索引
In [13]: df.idxmax()
Out[13]:
a    c
b    c
c    c
d    c
dtype: object

# 平均值
In [14]: df.mean()
Out[14]:
a    4.0
b    5.0
c    6.0
d    7.0
dtype: float64

# 中文数
In [15]: df.median()
Out[15]:
a    4.0
b    5.0
c    6.0
d    7.0
dtype: float64

# 方差
In [16]: df.var()
Out[16]:
a    16.0
b    16.0
c    16.0
d    16.0
dtype: float64

# 标准差
In [17]: df.std()
Out[17]:
a    4.0
b    4.0
c    4.0
d    4.0
dtype: float64

# 累计总和
In [18]: df.cumsum()
Out[18]:
    a   b   c   d
a   0   1   2   3
b   4   6   8  10
c  12  15  18  21

# 百分比
In [19]: df.pct_change()
Out[19]:
     a    b         c         d
a  NaN  NaN       NaN       NaN
b  inf  4.0  2.000000  1.333333
c  1.0  0.8  0.666667  0.571429

# 快速综合统计
In [20]: df.describe()
Out[20]:
         a    b     c     d
count  3.0  3.0   3.0   3.0
mean   4.0  5.0   6.0   7.0
std    4.0  4.0   4.0   4.0
min    0.0  1.0   2.0   3.0
25%    2.0  3.0   4.0   5.0
50%    4.0  5.0   6.0   7.0
75%    6.0  7.0   8.0   9.0
max    8.0  9.0  10.0  11.0

如果DataFrame中存在了nan会怎么样？

• 注意 : 当数组中存在了nan进行计算的时候并不会把值全部变成nan。
  • 主要是sum里面有个参数skipna=True
  • skipna : 默认为True， 默认跳过nan, 当指定为Fales的时候就变成了nan

# @Time : 2020/5/13 21:25 
# @Author : SmallJ 

import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))

# 设置两个值为nan
df.loc['b', ['b', 'c']] = np.nan
print(df)
print('-'*50)
# 当存在两个nan的时候进行计算的时候会怎么样
# 进行列轴进行加法运算
print(df.sum(axis=1))

   a    b     c   d
a  0  1.0   2.0   3
b  4  NaN   NaN   7
c  8  9.0  10.0  11
--------------------------------------------------
a     6.0
b    11.0
c    38.0
dtype: float64

练习

1.读取苹果公司股票数据，保存为csv文件。
2.读取该csv文件，绘制展示各个指标的走势情况。
3.对其进行统计量分析(数据中各项指标统计结果，保留两位小数)。
4.数据变化情况统计
• 每一天各项指标的差异值
• 计算其增长率
• 计算其平均增长率，并且观察哪个平均增长率最高

# @Time : 2020/5/13 21:44 
# @Author : SmallJ 

"""
1.读取苹果公司股票数据，保存为csv文件。
2.读取该csv文件，绘制展示各个指标的走势情况。
3.对其进行统计量分析(数据中各项指标统计结果，保留两位小数)。
4.数据变化情况统计
• 每一天各项指标的差异值
• 计算其增长率
• 计算其平均增长率，并且观察哪个平均增长率最高
"""

from pandas_datareader import data as web
import pandas as pd
import datetime
import matplotlib.pyplot as plt

# DataReader 参数
# name : 股票的名字
# start : 为开始时间
# end : 为结束时间

# start = datetime.datetime(2019, 1, 1)
# end = datetime.date.today()
#
# aapl_stock = web.DataReader("AAPL", 'yahoo', start, end)
# print(aapl_stock)

# 保存到本地csv数据
# df = pd.DataFrame(aapl_stock)
# df.to_csv('stock.csv')

# 读取csv数据
# data = pd.read_csv('stock.csv')
# df = pd.DataFrame(data)
# print(df)

# 读取该csv文件，绘制展示各个指标的走势情况。
# index_col : 为索引指定标签
# parse_dates : 将时间转变为标准格式
AAPL_data = pd.read_csv('stock.csv', index_col=0, parse_dates=True)
# print(AAPL_data.head())  # 读取前5行数据
# figsize : 为图片大小
# subplots : 默认为False 当设置为True时将所有图片绘制到子图中
# AAPL_data.plot(figsize=(16, 8), subplots=True)
# plt.show()

# 对其进行统计量分析(数据中各项指标统计结果，保留两位小数)。
# print(AAPL_data.describe())

#
# print(AAPL_data.aggregate())

# 每一天各项指标的差异值
# print(AAPL_data.diff())

# 计算其增长率
# print(AAPL_data.pct_change().head())

# 计算其平均值增长率,并且观察哪一个平均增长最高
data = AAPL_data.pct_change().mean().plot(kind='bar', figsize=(14, 8))
plt.show()

5-3 Pandas数据清洗

数据清洗介绍

数据清洗实际上也是数据质量分析，检查原始数据中是否存在脏数据(不符合要求，或者不能直接进行数据分析的数据)，并且处理脏数据。

常见的情况

• 缺失值
• 异常值
• 重复数据

处理缺失值

Pandas使用浮点值nan(not a number)表示缺失值，并且缺失值在数据中时常出现。那么Pandas的目的之一就是**“无痛地”**处理缺失值。

判断数据是否为nan

• pd.isnull(df)

  • 返回哪些值是缺失值的布尔值

• pd.notnull(df)

  • 返回值是isnull的反集

注意

• Python内建None值也被当作nan

# @Time : 2020/5/14 0:18 
# @Author : SmallJ 

import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))

df.loc['b', ['b', 'c']] = np.nan

# print(df)
# 判断数据是否为nan,当为nan时返回true,当不为nan时返回False
# print(pd.isnull(df))

# 同理,跟null相反
print(pd.notnull(df))

过滤缺失值

dropna(axis=0, how='any', inplace=False)

• axis : 指定轴 默认为0代表行
• how : 默认为any代表删除含有nan的行， 当为all时代表删除所有值为nan的行
• inplace : 修改被调用的对象，而不是一个备份

一维数组

# @Time : 2020/5/14 0:18 
# @Author : SmallJ 

import pandas as pd
import numpy as np

# df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))
#
# df.loc['b', ['b', 'c']] = np.nan
#
# # print(df)
# # 判断数据是否为nan,当为nan时返回true,当不为nan时返回False
# # print(pd.isnull(df))
#
# # 同理,跟null相反
# print(pd.notnull(df))

# 数据清洗 一维数组
ds = pd.Series([1, 2, np.nan, 3, np.nan])

# 传统式方法处理nan
# 采用布尔索引的方式进行过滤
# print(ds[ds.notnull()])

print(ds)
print('-'*100)
# dropna(axis=0,how='any',inplace=False)
# axis : 指定轴
# how : 默认为any 代表删除含有nan的行 当为all时代表删除所有行
# inplace : 修改被调用的对象而不是一个备份

print(ds.dropna())

二维数组

# @Author : SmallJ 
import pandas as pd
import numpy as np

# 二维数组
df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))

# 设置nan
df.loc['b', ['b', 'c']] = np.nan

print(df)
print('-'*50)
# 二维数组进行数据清洗
# 采用dropna
# 默认情况下dropna中的axis指定为0,默认删除含有nan的行

# how 里面有两个参数
# any : 代表含有nan的值
# all : 代表所有为nan的值

# inplace 是否对原数据进行修改
# 当为True时对原数据进行修改

# 设置一行全部为nan
df.loc['b', ['a', 'd', 'b', 'c']] = np.nan

# 发现第二行的数据全部没有了
print(df.dropna(how='all'))

补全缺失值

fillna(self, value=None, method=None, axis=None, inplace=False, limit=None)

• value : 标量或字典对象用于填充缺失值
• method : 插值方法，默认为"ffill"
  • “bfill” : 使用后面的值进行填充nan
  • “ffill” : 使用前面的值进行填充nan
• axis : 需要填充的轴，默认为0
• inplace : 修改被调用的对象，而不是一个备份
• limit : 用于向前或向后填充时最大的填充范围

# @Time : 2020/5/14 13:47 
# @Author : SmallJ 


import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))

# 设置nan
df.loc['b', :] = np.nan

# fillna : 代表为自定义填充nan值
# value : 填充的值,可以指定单个值进行填充
# axis : 指定轴
# inplace : 对原数据进行修改
# method : 改变插值方式
# limit : 限制填充的行数

# print(df)
#
# print('-'*30)


data = {
    'a': 3.1,
    'b': 3.2,
    'c': 3.3,
    'd': 3.4
}

# 指定所有nan值进行填充
# print(df.fillna(value=3.0))

# 根据列来填充
# print(df.fillna(value=data))

# 插入方式
# ffill : 用前面的值来填充nan
# bfill : 用后面的值填充nan

# 多设置几个nan
# df.loc['c', ['b', 'c']] = np.nan
print(df)

print('-'*30)
# 可以填充平均值或者中位数的值
# print(df.fillna(method='ffill', limit=1))
print(df.fillna(value=df.mean()))

异常值

脏数据也包含不符合要求的数据，那么对这块数据处理不能直接使用fillna填充。使用replace更加灵活

df.replace(to_replace=None,value=None)

• to_replace : 去替换的值
• value : 替换的值

# @Time : 2020/5/14 14:23 
# @Author : SmallJ 


import pandas as pd
import numpy as np

# df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('abc'), columns=list('abcd'))

ps = pd.Series(data=[-1, 11, 17, 19, 22, 55], index=list('abcdef'))

# 为什么要处理异常值
# 就比如说你绘制出来的数据中，其中有的数据离群点太高了,就需要使用replace这个方法来进行处理数据

# 比如说: 当我需要统计中国大学生的年龄的说话，我们会发现数据中有两个数据是不符合的基本要求
# 我们使用fillna就不太方便
# 我们就可以使用df.replace(to_replace=None,value=None)
# to_replace : 为原值
# value : 为要替换的值
# 传入的值: 可以为列表，可以为键
print(ps)
print('-'*50)
print(ps.replace(to_replace=[-1, 55], value=[18, 21]))

处理重复数据

判断重复值

• df.duplicated(subset=None, keep='first')
  • 返回的一个布尔值Series,默认反映的是每一行是否与之前出现过的行相同
  • subset : 指定子列判断重复
  • keep : 默认为first 保留首个出现的 last保留最后出现的

删除重复值

• df.drop_duplicates()
  • subset : 指定子列判断重复
  • keep : 默认为first 保留首个出现的 last保留最后出现的

# @Time : 2020/5/14 15:04 
# @Author : SmallJ 


import pandas as pd
import numpy as np

df = pd.DataFrame({
    'name': ['demo', 'SenvenJ', 'demo', 'SenvenJ'],
    'age': [18, 19, 18, 19],
    'gender': ['male', 'female']*2
})

print(df)
print('-'*30)
# 判断重复值
# 中文意思 : 重复的事件
# 参数 : subset=None, keep="first"
# subset : 指定子列判断重复
# keep : first保留首个出现，last保留最后出现 默认为first
# 判断是否有重复的,当有重复的返回True,没有返回False
#
# print(df.duplicated(keep='last')) # 返回为 False,False,True,True
# print(df.duplicated(keep='last'))  # 返回为 True,True,False,False

# subset : 为检查的字段
# print(df.duplicated(subset=['age', 'gender']))  # 返回False,False,True,True

# 删除重复值,也就是duplicates为True的行
# keep : 默认为first
print(df.drop_duplicates(keep='last'))

转载：https://blog.csdn.net/qq_37662827/article/details/106121145