Pandas练习

背景介绍

本数据集包括了2015年至2017年我国36个主要一线城市、特区的一些年度数据，包括产值、人口、就业、教育、医疗、经济贸易、房地产投资等方面。

包含文件：

• 2015年国内主要城市年度数据.csv
• 2016年国内主要城市年度数据.csv
• 2017年国内主要城市年度数据.csv

数据特征

数据集名称	数据类型	特征数	包含城市数量	缺失值	相关人物
国内主要城市年度数据	数值型、字符型	13	36	有	描述性分析（可视化）等

数据属性

NO	字段名称	数据类型	字段描述
1	地区	String	城市名称
2	年份	Int	数据所对应的时间
3	国内生产总值	Float	单位：亿元
4	第一产业增加值	Float	单位：亿元
5	第二产业增加值	Float	单位：亿元
6	第三产业增加值	Float	单位：亿元
7	社会商品零售总额	Float	单位：亿元
8	货物进出口总额	Float	单位：百万美元
9	年末总人口	Float	单位：万人
10	在岗职工平均工资	Int	单位：元
11	普通高等学校在校学生数	Float	单位：万人
12	医院、卫生院数	Int	单位：个
13	房地产开发投资额	Float	单位：亿元

数据来源

国家统计局:https://data.stats.gov.cn/easyquery.htm?cn=E0105

分析非常常用的知识点，知识点概述如下：

1、数据集基本信息探索
    数据基本情况
    数量探索
    相关性分析
    绘总统计
    数据抽样
2、应用函数 apply
3、合并数据
4、索引问题
5、排序问题
6、重复数据处理
7、数据分组
8、处理缺失值
9、选择数据
10、pandas时间序列
11、pandas可视化

1、pandas 基本信息探索

(1) 基本情况

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

中文设置

plt.rcParams['font.sans-serif'] = ["SimHei"]
df = pd.read_csv('data/2015年国内主要城市年度数据.csv')
print('--' * 20, '\n【1】数据集基本情况探索')

print('\n>>>样本形状:\n', df.shape) # 样本形状、样本数、特征数探索
print('\n>>>样本索引、列名探索:\n', df.index, df.columns)  # 样本索引、索引转换成列表、列名探索
print('\n>>>某列类型、全部样本类型探索:\n', df['年份'].dtypes, '\n', df.dtypes)  # 某列类型、全部样本类型探索
print('\n>>>')
print(df.info())

(2) 数量探索

探索某列、全部样本非 NA 值的数量

print(df['年份'].count(), '\n', df.count())

探索某列的值，也可以探索全部样本的值

df['年份'].values

value_counts探索某列中各元素值出现的次数(只能探索某列的)

count 计算每列或每行的非NA单元格。

df['第一产业增加值'].value_counts().head()
df['年份'].value_counts().head()

unique()函数用于获取Series对象的唯一值。唯一性按出现顺序返回。基于哈希表的唯一，因此不排序

print("唯一值:\n",df['国内生产总值'].unique())

nunique唯一值得数量

print("\n唯一值的数量:\n",df['国内生产总值'].nunique())
print("唯一值:\n",df['年份'].unique())

nunique唯一值得数量

print("\n唯一值的数量:\n",df['年份'].nunique())

探索每一列缺失值数量

print("探索每一列缺失值数量:\n",df.isnull().sum())

不是缺失值数量

print("\n不是缺失值数量:\n",df.notnull().sum())

某列取值、多列取值

print('取出一列:\n', df['年份'].head(),"类型:",type(df['年份']))

#取出多列:
print('\n取出多列:\n', df[['地区', '年份']].head(), "类型:", type(df[['地区', '年份']]))

(3) 相关性分析

探索特征之间相关性

探索某列、全部样本的方差

print('年末总人口方差:\n', df['年末总人口'].var())

print('\n总体数据方差:\n', df.var(), )

探索某列、全部样本的标准差

print('年末总人口标准差:\n', df['年末总人口'].std())

print('\n总体数据标准差:\n', df.std(), )

(4) 汇总统计

样本数据汇总统计

每一列求和

print('每一列求和:\n', df.sum())

某列逐行累加(可以全部样本每一列都累加)

print(df['地区'].cumsum().head())

最大最小值

print('最大值>>>\n', df.max().head())
print('\n最小值>>>\n', df.min().head())

返回 '国内生产总值' 列最大、最小值所对应的索引号

print('\n>>>', df['国内生产总值'].idxmax(), '\n', df['国内生产总值'].idxmin())
print('\n>>>', df.mean(), df.median())  # 平均值、中位数

汇总统计信息，是上面方法的统一

print('\n>>>', df.describe().T)
df.describe()
for (columnName, columnData) in df.iteritems():
    print('Colunm Name : ', columnName)
    print('Column Contents : ', columnData.values)
    print("===============")

(5) 数据抽样

有时候我们做研究分析或者数据量过大时，

只希望抽取一部分数据做研究，因此要进行数据抽样处理

replace允许或不允许对同一行进行多次采样,默认就是False

data = df.sample(n=5, replace=False)  # 不放回随机抽样 5 个数据
data

2、pandas 中的应用函数 apply

我们发现数据集中有浮点型数据，但是我们只需要整形数据，

因此我们很有必要使用应用函数对原数据进行类型转换

def fun(x):
    x = int(x)
    return x

data1 = df['国内生产总值'].apply(fun)

data1.head()
data2 = df['地区'].apply(lambda x: x + 'QQ')
data2.head()
data3 = df.iloc[:, :].apply(np.sum)
data3.head()

3、合并数据

df1 = pd.read_csv('data/2015年国内主要城市年度数据.csv')
df2 = pd.read_csv('data/2016年国内主要城市年度数据.csv')
df3 = pd.read_csv('data/2017年国内主要城市年度数据.csv')
#通常用来连接DataFrame对象。默认情况下是对两个DataFrame对象进行纵向连接，

当然通过设置参数，也可以通过它实现DataFrame对象的横向连接

df_1 = pd.concat(objs=[df1, df2, df3])  # 合并数据，以行的维度合并
df_1.sample(n=7, replace=False)  # 随机不放回抽样 7 个数据

以指定值合并，在本案例中不适用

df_2 = pd.merge(left=df1, right=df2, on='地区', how='outer')
df_2

4、索引问题

单个索引，inplace=False 不覆盖的情况下，

要使用一个变量 来间接操作

设置索引时的情况

d = df_1.set_index(keys='年份')
print(d.iloc[: , :4].head())

注意在取消索引操作时，inplace=True 设置为 True，以便后面可以查看到取消后的情况

d.reset_index(inplace=True)
d.iloc[: , :4].head()  # 取消索引时的情况

多级索引

inplace=True 覆盖的情况下，直接使用 df_1 访问.

注意：

   在 inplace=True 覆盖原数据情况下，运行第 2 或多次，
  就会出现报错的情况，同时代码并没有语法错误，
  原因是原数据被覆盖了。解决方法是：重新运行所有代码，
  如果不是很必要，尽量不要执行覆盖原数据的操作

df_1.set_index(keys=['地区', '年份'], inplace=True)  # 设置多级索引，覆盖原数据
print(df_1.iloc[: , :4].head())  

df_1.reset_index(inplace=True)
df_1.iloc[: , :4].head()

5、排序问题

通过索引排序

data = df_1.sample(n=5, replace=False)  # 通过随机不放回抽样 5 个数据

通过索引排列，升序排列、不覆盖原数据、如有缺失值则放在前面

data.sort_index(ascending=True, na_position='first')

多重索引的dataframe

dataframe.sort_index(level=[0,1],ascending=[False,True])`

• level 按指定索引级别的值排

通过指定列的值排序

df_1.sort_values(by=['地区', '年份'], ascending=[True, False], inplace=False, na_position='first').head(7)

6、重复数据处理

返回唯一值

print('\n>>>', df_1['地区'].unique())  # 唯一值元素
print('\n>>>\n', df_1.nunique())  # 唯一值数量

重复值处理

查找重复值

print('>>>\n', df_1.duplicated(subset=['年份'], keep='first').head())

删除重复值

print('>>>\n', df_1.drop_duplicates(subset=['年份'], keep='first', inplace=False).iloc[:, :4])

查找重复索引

print('\n>>>', df_1.index.duplicated())

7、数据分组

指定一列是聚合列，如：年份

'地区'作为索引分组，'年份'与分组列'地区'聚合

第一种方法

df_1.groupby(by=['地区'], as_index=True).agg({'年份': ['max', 'min', 'median']}).head()

第二种方法，两种方法是等效的

df_1.groupby(by=['地区'], as_index=True).年份.agg(['max', 'min', 'median']).head()

指定多列列是聚合列，如：年份、国内生产总值

df_1.groupby(by=['地区'], as_index=True).agg({'年份': 'max', '国内生产总值': 'describe'}).head()

没有指定聚合列，则代表选择所有列

返回所有列中的最大值

df_1.groupby(by=['地区'], as_index=True).max().head()

8、处理缺失值

在上面的探索中，发现有缺失值，因此有必要进行处理

查看所有数据的缺失情况

df_1.isnull().sum()

第一种方法，删除缺失值数据

df_1.dropna().isnull().sum()

第二种方法，使用填充法填充缺失值

print('\n>>>\n', df1.fillna(method='ffill').head())  # 使用缺失值的前一个值填充(前向填充)
print('>>>\n', df1.fillna(method='bfill').head())  # 使用缺失值的后一个值填充(后向填充)
''' 平均值填充(所有列填充) '''
print('>>>\n', df_1.fillna(value=df_1.mean()).head())

9、选择指定的数据

按标签选择

按行的序号、列的名称选择
df.loc[:, '列名']/df.loc[[0,1, 2], ['列名1', '列名2']]

print('>>>\n', df_1.loc[:, '年份'].head())
print('>>>\n', df_1.loc[[0, 4, 7], ['年份', '国内生产总值']].head())

按位置选择

按行位置(序号)、列位置选择
df.iloc[:, :]/da.iloc[[0, 1, 2], [2, 3, 4]]

print('>>>\n', df_1.iloc[:3, :3])
print('>>>\n', df_1.iloc[[1, 34, 56], [2, 4, 8]])

按条件来选择

筛选出符合条件的列

df_1 = df_1.set_index(["地区","年份"])

国内生产总值大于15678的数据

df_1[df_1['国内生产总值'] > 15678].head()

选择任一值大于1000的列

df_1.loc[:, (df_1>10000).any()]

选择所有值大于1000的列

df_1.loc[:, (df_1>1000).all()]
df_1.loc[:, df_1.isnull().any()]  # 选择含 NaN值的列
df_1.loc[:, df_1.notnull().all()]  # 选择不含NaN值的列

query和filter

在使用pandas进行数据分析时，经常遇到需要过滤信息的场景，此时我们可以用到2种函数，query和filter。

query函数

query函数我认为类似sql语言中的where，可以对dataframe中的特定column进行筛选。具体语法如下：

df.query('列名   判断   值'),如df.query('column1 > 2 and column 2<1')

等于

df[df[列名] 判断 值],如 df[df[column1]>2 & df[column2]<1]

filter函数

filter常规用法，在pandas说明里很好找到：

DataFrame.filter(items=None, like=None, regex=None, axis=None)

#items对列进行筛选#regex表示用正则进行匹配#like进行筛选#axis=0表示对行操作，axis=1表示对列操作

选择指定的列，类似于 df[['某列', '某列']]

df_1.filter(items=['地区', '年份'])  # 选择指定的列
df_1.filter(like='产业', axis=1)  # 选择含有 "产业" 的列

完整代码

from random import sample
import pandas as pd

df = pd.read_csv("./2015年国内主要城市年度数据.csv")

# values_count
v_c = df["年份"].value_counts()
# print(v_c)  # 2015    36
# Name: 年份, dtype: int64

# 唯一值
un = df["年份"].unique()  # 唯一值
# print(un)  # [2015]
un_num = df["年份"].nunique()  # 唯一值的数量
# print(un_num)  # 1

# 探索缺失值
# print(df.isnull().sum())  # 缺失
# print(df.notnull().sum())  # 完整

# 相关性分析
# print("年末总人口方差：\n", df["年末总人口"].var())
# print("总体数据方差：\n", df.var())

# print("年末总人口标准差：\n", df["年末总人口"].std())
# print("总体数据标准差：\n", df.std())

# 循环取出dec的值
# for (column_name, column_data) in df.describe().iteritems():
# print(column_name + ": ")
# print(column_data.values)

# 数据采样
# sample_data = df.sample(n=5, replace=False)
# print(sample_data)
# print("================")

# 数据合并
df1 = pd.read_csv("./2015年国内主要城市年度数据.csv")
df2 = pd.read_csv("./2016年国内主要城市年度数据.csv")
df3 = pd.read_csv("./2017年国内主要城市年度数据.csv")
df_1 = pd.concat(objs=[df1, df2, df3], axis=0)
sample_df_1 = df_1.sample(n=6, replace=False)
# print(sample_df_1)

# 将年份设置成索引
df11 = df.set_index("年份", inplace=False)
# print(df11.iloc[:,:4].head())

df12 = df11.reset_index(inplace=False)
# print(df12.iloc[:,:4].head())

# 找出重复值
print(df_1.duplicated(subset=["年份"], keep="last"))  # 最后一个出现的重复值为False
print(df_1.duplicated(subset=["年份"], keep="first"))  # 第一个出现的重复值为False
print(df_1.duplicated(subset=["年份"], keep=False))  # 重复值都为True
# 删除重复值
print(df_1.head())
df_drop_val = df_1.drop_duplicates(subset=["年份"], keep="first")
print(df_drop_val)

#