Pandas基本常用操作

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	样本标准差