Pandas常用操作

参考天池AI
github博客传送门
博客园传送门

安装pandas
通过命令提示符 pip install pandas
或者通过第三方发放版 Anaconda 进行鼠标操作安装

Numpy学习教程传送门

https://blog.csdn.net/zhanghao3389/article/details/82791862

Series 的创建

import numpy as np, pandas as pd

# 通过一维数组创建序列
arr1 = np.arange(10)  # 创建一个0~9的numpy数组对象
print(arr1)           # 打印这个数组
print(type(arr1)) 　　#打印这个数组的类型
s1 = pd.Series(arr1)　# 将数组转换为 Series
print(s1)             # 打印出这个Series
print(type(s1))       # 打印出这个Series的数据类型类型

通过字典的方式创建序列

dic1 = {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}  # 创建一个字典dic1
print(dic1)           # 打印这个字典
print(type(dic1))     # 打印这个字典的数据类型
s2 = pd.Series(dic1)  # 将这个字典转换为Series
print(s2)             # 打印转换后的Series
print(type(s2))       #打印转化后的Series数据类型 

DataFrame的创建

数据框的创建主要有三种方式
1.通过二维数组创建数据框

arr2 = np.array(np.arange(12)).reshape(4, 3)  # 创建一个0~11的数组,然后reshape成4*3的矩阵
print(arr2)               # 打印出这个矩阵
print(type(arr2))         # 打印出这个矩阵的数据类型
df1 = pd.DataFrame(arr2)  # 将这个矩阵转换为 DataFrame
print(df1)                # 打印出转换后的DataFrame
print(type(df1))          # 打印出这个DataFrame的数据类型

2.通过字典的方式创建数据框
(1)字典列表

dic2 = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}  # 创建一个字典
print(dic2)        # 打印出这个字典的内容
print(type(dic2))  # 打印出这个字典的数据类型

df2 = pd.DataFrame(dic2)  # 将这个字典转换为DataFrame
print(df2)                # 打印出转化后的DataFrame
print(type(df2))          # 打印出这个DataFrame的数据类型

(2)嵌套字典

dic3 = {'one': {'a': 1, 'b': 2, 'c': 3, 'd': 4}, 'two': {'a': 5, 'b': 6, 'c': 7, 'd': 8},
        'three': {'a': 9, 'b': 10, 'c': 11, 'd': 12}}  # 创建了一个嵌套的字典
print(dic3)        # 打印出这个嵌套的字典
print(type(dic3))  # 打印出这个字典的数据类型

df3 = pd.DataFrame(dic3)  # 将这个嵌套字典转换为DataFrame
print(df3)                # 打印出转换后的DataFrame
print(type(df3))          # 打印出这个DataFrame的数据类型

3.通过数据框的方式创建数据框

df4 = df3[['one', 'three']]  # 通过调用df3中的两列数据进行创建DataFrame
print(df4)                   # 打印出这个调用df3中数据的DataFrame
print(type(df4))             # 打印出这个DataFrame的数据类型

s3 = df3['one']  # 通过调用df3中的一列数据进行创建DataFrame会创建出Series
print(s3)        # 打印出这个Series
print(type(s3))  # 打印出这个Series的数据类型

通过索引值或索引标签获取数据

import numpy as np, pandas as pd

s4 = pd.Series(np.array([1, 1, 2, 3, 5, 8]))  # 创建一个Series数据
print(s4)        # 打印出这个数据
print(s4.index)  # 打印出这个数据的索引

现在我们为序列设定一个自定义的索引值:

s4.index = ['a', 'b', 'c', 'd', 'e', 'f']  # 手动修改s4这个数据的索引(index)
print(s4)                             # 打印修改索引后的Series
print('s4[3]:\n', s4[3])              # 取出下标为 3 的数据
print('s4[e]:\n', s4['e'])            # 取出索引为 e 的数据
print('s4[1,3,5]:\n', s4[[1, 3, 5]])  # 取出下标为 1 3 5 的数据
print("s4[['a','b','d','f']]:\n", s4[['a', 'b', 'd', 'f']])  # 取出索引为 a b d f 的数据
print('s4[:4]:\n', s4[:4])            # 切片到下标为 4 的所有数据
print("s4['c':]:\n", s4['c':])        # 切片索引为 c 开始后面所有的数据
print("s4['b':'e']:\n", s4['b':'e'])  # 切片索引为 b 开始 e 结束(左闭右开)的所有数据

自动化对齐
如果有两个序列，需要对这两个序列进行算术运算，这时索引的存在就体现的它的价值了—自动化对齐.

s5 = pd.Series(np.array([10, 15, 20, 30, 55, 80]), index=['a', 'b', 'c', 'd', 'e', 'f'])  # 创建一个Series并指定索引
print(s5)       # 打印出这个Series

s6 = pd.Series(np.array([12, 11, 13, 15, 14, 16]), index=['a', 'c', 'g', 'b', 'd', 'f'])  # 创建一个Series并指定索引
print(s6)       # 打印出这个Series
print(s5 + s6)  # 将两个Series进行相加操作
print(s5 / s6)  # 将两个Series进行相除操作
# 由于s5中没有对应的g索引，s6中没有对应的e索引，所以数据的运算会产生两个缺失值NaN。
# 注意，这里的算术结果就实现了两个序列索引的自动对齐，而非简单的将两个序列加总或相除对于数据框的对齐，不仅仅是行索引的自动对齐，同时也会自动对齐列索引（变量名）

利用pandas查询数据

import pandas as pd

# 可以通过布尔索引有针对的选取原数据的子集、指定行、指定列等。
stu_dic = {'Age': [14, 13, 13, 14, 14, 12, 12, 15, 13, 12, 11, 14, 12, 15, 16, 12, 15, 11, 15],
           'Height': [69, 56.5, 65.3, 62.8, 63.5, 57.3, 59.8, 62.5, 62.5, 59, 51.3, 64.3, 56.3, 66.5, 72, 64.8, 67, 57.5, 66.5],
           'Name': ['Alfred', 'Alice', 'Barbara', 'Carol', 'Henry', 'James', 'Jane', 'Janet', 'Jeffrey', 'John',  'Joyce', 'Judy', 'Louise', 'Marry', 'Philip', 'Robert', 'Ronald', 'Thomas', 'Willam'],
           'Sex': ['M', 'F', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'F', 'F', 'M', 'M', 'M', 'M', 'M'],
           'Weight': [112.5, 84, 98, 102.5, 102.5, 83, 84.5, 112.5, 84, 99.5, 50.5, 90, 77, 112, 150, 128, 133, 85, 112]}
# 创建了一个DataFrame数据框
student = pd.DataFrame(stu_dic)

查询数据的前5行或末尾5行 student.head() student.tail()

print(student)                      # 打印这个数据框
print('前五行:\n', student.head())  # 查询这个数据框的前五行
print('后五行:\n', student.tail())  # 查询这个数据框的后五行

查询指定的行

print(student.loc[[0, 2, 4, 5, 7]])  # 这里的loc索引标签函数必须是中括号[]

查询指定的列

print(student[['Name', 'Height', 'Weight']].head())  # 如果多个列的话，必须使用双重中括号

也可通过loc索引标签查询指定的列

print(student.loc[:, ['Name', 'Height', 'Weight']].head)

查询出所有12岁以上的女生信息

print(student[(student['Sex'] == 'F') & (student['Age'] > 12)])

查询出所有12岁以上的女生姓名,身高和体重

print(student[(student['Sex'] == 'F') & (student['Age'] > 12)][['Name', 'Height', 'Weight']])

利用pandas的DataFrames进行统计分析

import numpy as np, pandas as pd

np.random.seed(1234)
d1 = pd.Series(2 * np.random.normal(size=100) + 3)
d2 = np.random.f(2, 4, size=100)
d3 = np.random.randint(1, 100, size=100)

print('非空元素计算: ', d1.count())       # 非空元素计算
print('最小值: ', d1.min())              # 最小值
print('最大值: ', d1.max())              # 最大值
print('最小值的位置: ', d1.idxmin())     # 最小值的位置，类似于R中的which.min函数
print('最大值的位置: ', d1.idxmax())     # 最大值的位置，类似于R中的which.max函数
print('10%分位数: ', d1.quantile(0.1))  # 10%分位数
print('求和: ', d1.sum())               # 求和
print('均值: ', d1.mean())              # 均值
print('中位数: ', d1.median())          # 中位数
print('众数: ', d1.mode())              # 众数
print('方差: ', d1.var())               # 方差
print('标准差: ', d1.std())             # 标准差
print('平均绝对偏差: ', d1.mad())       # 平均绝对偏差
print('偏度: ', d1.skew())             # 偏度
print('峰度: ', d1.kurt())             # 峰度
print('描述性统计指标: ', d1.describe())  # 一次性输出多个描述性统计指标
# 必须注意的是，descirbe方法只能针对序列或数据框，一维数组是没有这个方法的

这里自定义一个函数，将这些统计描述指标全部汇总到一起:

def stats(x):
    return pd.Series([x.count(), x.min(), x.idxmin(), x.quantile(.25), x.median(), x.quantile(.75),x.mean(), x.max(), x.idxmax(), x.mad(), x.var(), x.std(), x.skew(), x.kurt()],index=['Count', 'Min', 'Whicn_Min', 'Q1', 'Median', 'Q3', 'Mean', 'Max','Which_Max', 'Mad', 'Var', 'Std', 'Skew', 'Kurt'])

print(stats(d1))  # 打印统计后的指标

将这个函数 应用到每一列中

df = pd.DataFrame(np.array([d1,d2,d3]).T,columns=['x1','x2','x3'])
print(df.head())
print(df.apply(stats))

连续变量的相关系数（corr）和协方差矩阵（cov）的求解

print(df.corr())

相关系数的计算可以调用pearson方法或kendell方法或spearman方法，默认使用pearson方法。

print(df.corr('spearman'))

关注某一个变量与其余变量的相关系数的话，可以使用corrwith,如下方只关心x1与其余变量的相关系数

print(df.corrwith(df['x1']))

数值型变量间的协方差矩阵

print(df.cov())

利用pandas实现SQL操作

import pandas as pd, numpy as np

# 原数据
stu_dic = {'Age': [14, 13, 13, 14, 14, 12, 12, 15, 13, 12, 11, 14, 12, 15, 16, 12, 15, 11, 15],
           'Height': [69, 56.5, 65.3, 62.8, 63.5, 57.3, 59.8, 62.5, 62.5, 59, 51.3, 64.3, 56.3, 66.5, 72, 64.8, 67, 57.5, 66.5],
           'Name': ['Alfred', 'Alice', 'Barbara', 'Carol', 'Henry', 'James', 'Jane', 'Janet', 'Jeffrey', 'John', 'Joyce', 'Judy', 'Louise', 'Marry', 'Philip', 'Robert', 'Ronald', 'Thomas', 'Willam'],
           'Sex': ['M', 'F', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'F', 'F', 'M', 'M', 'M', 'M', 'M'],
           'Weight': [112.5, 84, 98, 102.5, 102.5, 83, 84.5, 112.5, 84, 99.5, 50.5, 90, 77, 112, 150, 128, 133, 85, 112]}
student = pd.DataFrame(stu_dic)  # 将数据转换为DataFrame
print(student)                   # 打印出这个数据

增

添加新行或增加新列

dic = {'Name': ['LiuShunxiang', 'Zhangshan'], 'Sex': ['M', 'F'], 'Age': [27, 23], 'Height': [165.7, 167.2],'Weight': [61, 63]}  # 需要增加的数据
student2 = pd.DataFrame(dic)  # 增加数据
print(student2)               # 打印出增加数据后的DataFrame

现在将student2中的数据新增到student中 可以通过 concat函数实现

student3 = pd.concat([student, student2])
print(student3)

注意 注意到了吗？在数据库中union必须要求两张表的列顺序一致，而这里concat函数可以自动对齐两个数据框的变量！

新增列的话,其实在pandas中就更简单了,例如在student2中新增一列学生成绩

print(pd.DataFrame(student2, columns=['Age', 'Weight', 'Name', 'Sex', 'Weight', 'Score']))

删

删除数据框student2通过del命令实现,该命令可以删除Python的所有对象

del student2  # 删除数据框 student2, 通过del命令可以删除Python的所有对象
print(student2)

删除指定的行

print(student.drop([0, 1, 3, 6]))

删除所有14岁以下的学生

print(student['Age'] > 14)

删除指定的列

print(student.drop(['Height', 'Weight'], axis=1).head())  # axis默认为0选择行

改

修改原始记录的 结合布尔索引和赋值的方法

student3.loc[student3['Name'] == 'LiuShunxiang', 'Height'] = 173
print(student3[student3['Name'] == 'LiuShunxiang'][['Name', 'Height']])

查

有关数据查询部分
聚合,排序和多表连接操作
聚合:pandas模块中可以通过groupby()函数实现数据的聚合操作

print(student.groupby('Sex').mean())

如果不对原始数据作限制的话，聚合函数会自动选择数值型数据进行聚合计算。如果不想对年龄计算平均值的话，就需要剔除改变量

print(student.drop('Age', axis=1).groupby('Sex').mean())

groupby还可以使用多个分组变量，例如根本年龄和性别分组，计算身高与体重的平均值

print(student.groupby(['Sex', 'Age']).mean())

对每个分组计算多个统计量

print(student.drop('Age', axis=1).groupby('Sex').agg([np.mean, np.median]))

排序

使用sort_index和sort_values实现序列和数据框的排序工作

Data = pd.Series(np.array(np.random.randint(1, 20, 10)))
print(Data)
print(Data.sort_index())
print(Data.sort_values(ascending=False))

数据框中一般都是按值排序

print(student.sort_values(by=['Age', 'Height']))

多表连接

多表之间的连接也是非常常见的数据库操作，连接分内连接和外连接，
在数据库语言中通过join关键字实现，pandas我比较建议使用merger函数实现数据的各种连接操作。
如下是构造一张学生的成绩表：

dic2 = {'Name': ['Alfred', 'Alice', 'Barbara', 'Carol', 'Henry', 'Jeffrey', 'Judy', 'Philip', 'Robert', 'Willam'], 'Score': [88, 76, 89, 67, 79, 90, 92, 86, 73, 77]}
score = pd.DataFrame(dic2)
print(score)

现在想把学生表student与学生成绩表score做一个关联

stu_score1 = pd.merge(student, score, on='Name')
print(stu_score1)

注意，默认情况下，merge函数实现的是两个表之间的内连接，即返回两张表中共同部分的数据。

可以通过how参数设置连接的方式，left为左连接；right为右连接；outer为外连接。

stu_score2 = pd.merge(student, score, on='Name', how='left')
print(stu_score2)

利用pandas进行缺失值的处理

三类方法 删除法 填补法 插值法

删除法：当数据中的某个变量大部分值都是缺失值，可以考虑删除改变量；当缺失值是随机分布的，且缺失的数量并不是很多是，也可以删除这些缺失的观测。

替补法：对于连续型变量，如果变量的分布近似或就是正态分布的话，可以用均值替代那些缺失值；如果变量是有偏的，可以使用中位数来代替那些缺失值；对于离散型变量，我们一般用众数去替换那些存在缺失的观测。

插补法：插补法是基于蒙特卡洛模拟法，结合线性模型、广义线性模型、决策树等方法计算出来的预测值替换缺失值。

import pandas as pd, numpy as np

stu_score = {'Score': [88.0, 76.0, 89.0, 67.0, 79.0, None, None, None, 90.0, None, None, 92.0, None, None, 86.0, 73.0, None, None, 77.0]}
stu_score2 = pd.DataFrame(stu_score)
s = stu_score2['Score']
print(s)
# 结合sum函数和isnull函数来检测数据中含有多少缺失值
print('缺失值个数:', sum(pd.isnull(s)))

直接删除缺失值

print('s.dropna():\n', s.dropna())

默认情况下,dropna会删除任何含有缺失值得行,我们再构造一个数据库试试

df = pd.DataFrame([[1, 1, 2], [3, 5, np.nan], [13, 21, 34], [55, np.nan, 10], [np.nan, np.nan, np.nan], [np.nan, 1, 2]], columns=('x1', 'x2', 'x3'))
print('df:\n', df)
print('df.dropna():\n', df.dropna())

使用一个常量来填补缺失值，可以使用fillna函数实现简单的填补工作

print('df.fillna(0):\n', df.fillna(0))  # 用 0 填补所有缺失值

采用前项填充或后项填充

print('method="ffill":\n', df.fillna(method='ffill'))
print('method="bfill":\n', df.fillna(method='bfill'))

使用常量填充不同的列

print("{'x1': 1, 'x2': 2, 'x3': 3}:\n", df.fillna({'x1': 1, 'x2': 2, 'x3': 3}))

x1_median = df['x1'].median()
x2_mean = df['x2'].mean()
x3_mean = df['x3'].mean()

print(x1_median)
print(x2_mean)
print(x3_mean)
print(df.fillna({'x1': x1_median, 'x2': x2_mean, 'x3': x3_mean}))

在使用填充法时，相对于常数填充或前项、后项填充，使用各列的众数、均值或中位数填充要更加合理一点，这也是工作中常用的一个快捷手段。

利用pandas实现Excel的数据透视表功能

import pandas as pd, numpy as np

# pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='ALL')
# data：需要进行数据透视表操作的数据框
# values：指定需要聚合的字段
# index：指定某些原始变量作为行索引
# columns：指定哪些离散的分组变量
# aggfunc：指定相应的聚合函数
# fill_value：使用一个常数替代缺失值，默认不替换
# margins：是否进行行或列的汇总，默认不汇总
# dropna：默认所有观测为缺失的列
# margins_name：默认行汇总或列汇总的名称为'All'

stu_dic = {'Age': [14, 13, 13, 14, 14, 12, 12, 15, 13, 12, 11, 14, 12, 15, 16, 12, 15, 11, 15],
           'Height': [69, 56.5, 65.3, 62.8, 63.5, 57.3, 59.8, 62.5, 62.5, 59, 51.3, 64.3, 56.3, 66.5, 72, 64.8, 67, 57.5, 66.5],
           'Name': ['Alfred', 'Alice', 'Barbara', 'Carol', 'Henry', 'James', 'Jane', 'Janet', 'Jeffrey', 'John', 'Joyce', 'Judy', 'Louise', 'Marry', 'Philip', 'Robert', 'Ronald', 'Thomas', 'Willam'],
           'Sex': ['M', 'F', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'F', 'F', 'M', 'M', 'M', 'M', 'M'],
           'Weight': [112.5, 84, 98, 102.5, 102.5, 83, 84.5, 112.5, 84, 99.5, 50.5, 90, 77, 112, 150, 128, 133, 85, 112]}
student = pd.DataFrame(stu_dic)

对一个分组变量（Sex），一个数值变量（Height）作统计汇总

Table1 = pd.pivot_table(student, values=['Height'], columns=['Sex'])
print(Table1)

对一个分组变量(Sex),两个数值变量(Height,Weight)做统计汇总

Table2 = pd.pivot_table(student, values=['Height', 'Weight'], columns=['Sex'])
print(Table2)

对两个分组变量(Sex, Age), 两个数值变量(Height, Weight)做统计汇总

Table3 = pd.pivot_table(student, values=['Height', 'Weight'], columns=['Sex', 'Age'])
print(Table3)

很显然这样的结果并不像Excel中预期的那样，该如何变成列联表的形式的？很简单，只需将结果进行非堆叠操作（unstack）即可

Table4 = pd.pivot_table(student, values=['Height', 'Weight'], columns=['Sex', 'Age']).unstack()
print(Table4)

使用多个聚合函数

Table5 = pd.pivot_table(student, values=['Height', 'Weight'], columns=['Sex'], aggfunc=[np.mean, np.median, np.std])
print(Table5)

有关更多数据透视表的操作，可参考http://python.jobbole.com/81212/

多层索引的使用

Series的层次化索引，索引是一个二维数组，相当于两个索引决定一个值
有点类似于DataFrame的行索引和列索引

import pandas as pd, numpy as np

s = pd.Series(np.arange(1, 10), index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'], [1, 2, 3, 1, 2, 3, 1, 2, 3]])
print('s:\n', s)
print('s.index:\n', s.index)

# 选取外层索引为 a 的数据
print("s['a']:\n", s['a'])
# 选取外层索引为 a 和内层索引为 1 的数据
print("s['a', 1]:\n", s['a', 1])
# 选取外层索引为 a 和内层索引为 1,3的数据
print("s['a'][[1, 3]]:\n", s['a'][[1, 3]])
# 层次化索引的切片,包括右端的索引
print('s[["a", "c"]]:\n', s[['a', 'c']])
print('s["b":"d"]:\n', s['b':'d'])
# 通过unstack方法可以将Series变成一个DataFrame
# 数据的类型以及数据的输出结构都变成了DataFrame,对于不存在的位置使用NaN填充
print('s.unstack():\n', s.unstack())

DataFrame的层次化索引

data = pd.DataFrame(np.random.randint(0, 150, size=(8,12)),columns=pd.MultiIndex.from_product([['模拟考', '正式考'],['数学', '语文', '英语', '物理', '化学', '生物']]),index=pd.MultiIndex.from_product([['期中', '期末'],['雷军', '李斌'],['测试一', '测试二']]))
print('data:\n', data)

print('data["模拟考"]["语文","数学"]:\n', data['模拟考'][['语文', '数学']])
print("data.loc['期中', '雷军', '测试一']['模拟考', '数学']:\n", data.loc['期中', '雷军', '测试一']['模拟考', '数学'])
print("data.loc['期中', '雷军', '测试一']:\n", data.loc['期中', '雷军', '测试一'])

print("data['正式考']:\n", data['正式考'])