Pandas
一、 介绍
Pandas的名称来自于面板数据(panel data)和Python数据分析(data analysis)。 Pandas是一个强大的分析结构化数据的工具集,基于NumPy构建,提供了高级数据结构和数据操作工具,它是使Python成为强大而高效的数据分析环境的重要因素之一。
- 一个强大的分析和操作大型结构化数据集所需的工具集
- 基础是NumPy,提供了高性能矩阵的运算
- 提供了大量能够快速便捷地处理数据的函数和方法
- 应用于数据挖掘,数据分析
- 提供数据清洗功能
对于数据来说,首先的操作是对数据的清洗,包括缺失值,非法值,Nan值的处理,以及数据类型的转换,前期对数据的清洗会花费较长的时间,这样后期对数据的处理将十分的方便。
二、 数据结构及基本操作
1. Series
- Series是一种类似于一维数组的对象,组成。
- 一组数据(各种NumPy数据类型),组与之对应的索引(数据标签),
- 索引(index)在左
- 数据(values)在右
- 索引是自动创建
1.1 通过list构建Series
import pandas as pd
# 不指定索引,默认是从0开始
# ser_obj = pd.Series(range(1,5))
# 指定索引
ser_obj = pd.Series(range(1,6), index = ['a', 'b', 'c', 'd', 'e'])
# 查看前3行数据
ser_obj.head(3)
1.2 通过dict构建Series
import pandas as pd
# 字典的键为对应Series中的索引,字典的值为对应Series中的值
dict = {"first":"人生苦短,我用Python","second":"hello","third":"word"}
ser_obj = pd.Series(dict)
print(ser_obj)
# 输出索引
print(ser_obj.index)
# 输出数据
print(ser_obj.values)
# 根据位置获取数据
print(ser_obj[1])
# 根据索引获取数据
print(ser_obj["second"])
# 支持连续切片操作,此时的切片操作是基于行
print(ser_obj[1:3])
# 支持不连续切片, 此时的切片操作是基于列
print(ser_obj[["first","third"]])
2. DataFrame
- 一个表格型的数据结构,它含有一组有序的列,每列可以是不同类型的值。DataFrame既有行索引也有列索引,数据是以二维结构存放的。
- 类似多维数组/表格数据 (如,excel, R中的data.frame)
- 每列数据可以是不同的类型
- 索引包括列索引和行索引
2.1 通过numpy.ndarray构建DataFrame
import numpy as np
import pandas as pd
arr_obj = np.random.rand(3,4)
df_obj = pd.DataFrame(arr_obj)
print(df_obj)
# 查看前两行
print(df_obj.head(2))
2.2 通过dict构建DataFrame
(a) 使用numpy自定义数据
dict = {
"A":1,
"B":pd.Timestamp("20200101"),
"C":pd.Series(range(10,14),dtype="float64"),
"D":["python","java","c++","c"],
"E":np.array([3] *4,dtype="int32"),
"F":"上海"
}
df_obj = pd.DataFrame(dict)
print(df_obj)
# 增加新的一列数据
df_obj["new_col"] = np.arange(1,5)
print(df_obj)
# 支持数学运算
df_obj["second_new_col"] = df_obj["new_col"] + 12
print(df_obj)
# 删除列,使用列名称
del df_obj["E"]
(b) dict初始化数据
data = {'a':[11,22,33],'b':[44,55,66]}
test = pd.DataFrame(data)
test
© 自定义index和data
import pandas as pd
import numpy as np
data = ["a", "b", "c", "d", "e", "f"]
index = np.arange(1, 7)
columns = ["test"]
# 自定义列名
df = pd.DataFrame(data, index,columns=columns)
print(df)
(d) 定义多维DataFrame
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
三、Pandas高级索引
Serics和DataFrame两个数据类型的操作基本一致,索引只在Series中操作,没有在DataFrame中操作,
因为两者的差别不大。
-
Serics支持列表切片索引(连续切片索引,行索引)和列名索引(可以选择不连续的列,选择的列存放在一个列表内,列索引)
import pandas as pd # 字典的键为对应Series中的索引,字典的值为对应Series中的值 dict = {"first":"人生苦短,我用Python","second":"hello","third":"word"} ser_obj = pd.Series(dict) # 支持连续切片操作,此时的切片操作,依据是行 print(ser_obj[1:3]) # 列索引,列表 print(ser_obj[["first","third"]])
-
DataFrame
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd']) print(df_obj[1:3]) print(df_obj[["a","c"]])
如果想获取前三行的b、c两列数据,DateFramed的基础功能实现起来就复杂了
需要使用DataFrame对象的高级索引
下面讲解Pandas高级索引方式
高级索引:标签、位置和混合
1. loc标签索引
loc是基于标签名的索引,也就是我们自定义的索引名
依旧使用上面的案列,获取前三行的b、c两列数据
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
# 不连续索引
print(df_obj.loc[:2,["b","c"])
# 连续索引
print(df_obj.loc[:2,"b":"c"])
2. iloc标签索引
loc是基于编号的索引
依旧使用上面的案列,获取前三行的b、c两列数据
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj.iloc[0:2, 0:3])
3. ix 标签与位置混合索引
-
ix是以上二者的综合,既可以使用索引编号,又可以使用自定义索引,要视情况不同来使用
-
如果索引既有数字又有英文,容易导致定位的混乱,那么这种方式不建议使用的
此方式容易出错,尽量使用
四、 Pandas对齐操作
- 对齐操作是数据清洗的重要过程,可以按索引对齐进行运算
- 如果没对齐的位置则补NaN
- add,sub,mul,div,加减乘除
1. Series
ser_obj1 = pd.Series(range(10, 20), index = range(10))
ser_obj2 = pd.Series(range(20, 25), index = range(5))
# 此时的加法操作,后面5个数据为Nan
# print(ser_obj1 + ser_obj2)
print(ser_obj1.add(ser_obj2))
这样的操作可能会对数据造成不可误差,因此使用fill_value属性
ser_obj1 = pd.Series(range(10, 20), index = range(10))
ser_obj2 = pd.Series(range(20, 25), index = range(5))
# 使用默认的值
print(ser_obj1.add(ser_obj2,fill_value=0))
2. DataFrame
df_obj1 = pd.DataFrame(np.ones((2,2)),columns = ['a','b'])
df_obj2 = pd.DataFrame(np.ones((3,3)),columns = ['a','b','c'])
print(dfdf_obj11.add(df_obj2,fill_value = 0))
五、Pandas函数应用
- 在numpy里,可以对数组里的每一个元素进行操作的函数称为ufunc 通用函数(universal function)
- 在Pandas里可以直接使用Numpy的ufunc
1. 直接使用Numpy中的函数
范例
df = pd.DataFrame(np.random.randn(5,4) - 1)
print(df)
print(np.abs(df))
2. 通过apply将函数应用到行或者列
axis参数可以指定轴向
- 默认值为0,方向是列
- 值为1,方向是行
df = pd.DataFrame(np.random.randn(5,4))
# lambda函数,返回最大值
f = lambda x : x.max()
# axis默认为列方向
print(df.apply(lambda x : x.max()))
# 行方向
print(df.apply(lambda x : x.max(), axis=1))
3. applymap函数映射到整个DataFrame对象
df = pd.DataFrame(np.random.randn(5,4))
print(df)
f1 = lambda x : '%.2f' % x
print(df.applymap(f1))
f2 = lambda x: x+x
print(df.applymap(f2))
六、排序
1. 索引排序
(a) Series
ser_obj2 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))
print(ser_obj2)
# 默认升序
print(ser_obj2.sort_index())
# 降序排序
print(ser_obj2.sort_index(ascending = False))
(b) DataFrame
df_obj = pd.DataFrame(np.random.randn(3, 5),
index=np.random.randint(3, size=3),
columns=np.random.randint(5, size=5))
print(df_obj)
# 修改axis和accending两个参数,可以改变行、列排序和升序、降序
df_obj_sort = df_obj.sort_index(axis=0, ascending=False)
print(df_obj_sort)
2. 值排序
(a) Series
ser_obj = pd.Series(np.random.randint(10,20,size= 10))
print(ser_obj)
# 默认升序
print(ser_obj.sort_values())
# 降序
print(ser_obj.sort_values(ascending = False))
(b) DaraFrame
df4 = pd.DataFrame(np.random.randn(3, 5),
index=np.random.randint(2, size=3),
columns=np.random.randint(4, size=5))
print(df4)
# by参数
# 行索引,直接使用行号
# 列索引,使用列表
print(df4.sort_values(by=[1, ], ))
七、缺失值和Nan值处理
df_obj = pd.DataFrame([
[1, 2, np.nan, np.nan],
[np.nan, 3, 4, np.nan],
list(range(4))])
print(df_obj)
# 返回布尔值矩阵
print(df_obj.isnull())
# 删除Nan值所在行列,axis=1列, axis=0行
print(df_obj.dropna(axis=1))
# 将Nan值替换为设置值
print(df_obj.fillna(0))
八、层级索引
存在两层及其以上的索引层级,如下的格式。
a 0 -0.816360
1 -0.459840
2 0.664878
b 0 0.039940
1 1.049324
2 -0.525796
c 0 -1.887801
1 1.361369
2 0.120353
d 0 -1.432332
1 0.143934
2 0.320637
利用代码方式生成层级Series对象
ser_obj = pd.Series(np.random.randn(12),
index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
[0, 1, 2] * 4])
print(type(ser_obj.index))
# <class 'pandas.core.indexes.multi.MultiIndex'>
可以用for循环的方式查看ser_obj.index,这样便于理解层级索引的概念。
获取元素的方式与单层结构的Series和DataFrame基本一致
# 获取所有a索引的数据
print(ser_obj["a"])
# 获取a索引下的第一个数据
print(np.round(ser_obj["a"][0], 6))
# 获取第一层索引下的第一条数据
print(ser_obj[:,1])
九、 Pandas统计计算
describe() 产生数据集的数据描述
统计了每一列的个数,平均值,标准差,最小值,分位数的分布,最大值等
df_obj = pd.DataFrame(np.random.randn(5, 4), columns=['a', 'b', 'c', 'd'])
print(df_obj)
print(df_obj.describe())
常用方法
方法 | 说明 |
---|---|
count | 非NA值的数量 |
describe | 针对Series和DataFrame列计算统计 |
min、max | 计算最值 |
argmin、argmax | 计算能够获取到的最值索引位置 |
idxmin、idxmax | 计算能够获取到的最值索引值 |
sum | 样本求和 |
mean | 样本平均数 |
median | 样本中位数 |
var | 样本方差 |
std | 样本标准差 |
十、基本操作
1、逐行读取数据,并修改对应数据
# remove_data,为一个DataFrame对象
for indexs in remove_data.index:
# 逐行查看,values可以用int型索引
remove_data.loc[indexs].values[0:-1]
# 逐行修改列值
remove_data.loc[indexs, "Norm_peptide"] = norm_protein
# 也可以用loc方法查看指定元素
remove_data.loc[indexs].values[10]
2、删除
# data为DataFrame对象
# Gene_ID是data的列索引值
# not_ensenbl是存储Gene_ID的列表
res= data[~data.Gene_ID.isin(not_ensembl)]
3、map结合lambda的复杂使用
data = [[0, '1,4,8,32'], [1, '2,16'], [2, '2,32'], [3, '1,4,8,32'], [4, '1,4']]
df = pd.DataFrame(data, columns=["id", "val"])
df["new"] = df["val"].str.split(",")
df["province"] = df["new"].map(lambda x: 1 if ("1" in x) else (2 if ("2" in x) else 0))
df["city"] = df["new"].map(lambda x: 4 if ("4" in x) else 0)
df["district"] = df["new"].map(lambda x: 32 if ("32" in x) else (16 if ("16" in x) else (8 if ("8" in x) else 0)))
print df
十一、 透视表
https://www.cnblogs.com/traditional/p/11967360.html