Pandas基本常用操作

时间:2020-9-17 作者:admin

Pandas

一、 介绍

Pandas的名称来自于面板数据(panel data)和Python数据分析(data analysis)。 Pandas是一个强大的分析结构化数据的工具集,基于NumPy构建,提供了高级数据结构和数据操作工具,它是使Python成为强大而高效的数据分析环境的重要因素之一。

  • 一个强大的分析和操作大型结构化数据集所需的工具集
  • 基础是NumPy,提供了高性能矩阵的运算
  • 提供了大量能够快速便捷地处理数据的函数和方法
  • 应用于数据挖掘,数据分析
  • 提供数据清洗功能

二、 数据结构及基本操作

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(16), 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 样本标准差
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。