[人工智能]3-2 Pandas的索引操作

2. Pandas的索引操作

2.1 索引对象Index

1. Series和DataFrame中的索引都是Index对象

import numpy as np
import pandas as pd

#Series和DataFrame中的索引都是Index对象
ps=pd.Series(range(5),index=['a','b','c','d','e'])
#结果为：pandas.core.indexes.base.Index
type(ps.index)

pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['A','B','C'])
#结果为：pandas.core.indexes.base.Index
print(type(pd1.index))
#结果为：pandas.core.indexes.base.Index
print(type(pd1.columns))

2. 索引对象不可变，保证了数据的安全

# 错误代码 索引不可修改
pd1.index[1]=2

3. 常见的Index种类

2.2 索引的一些基本操作

2.2.1 重新索引

#reindex 创建一个符合新索引的新对象 索引f对应的值为NaN
ps2 = ps.reindex(['a','b','c','d','e','f'])
#结果为：
#a    0.0
#b    1.0
#c    2.0
#d    3.0
#e    4.0
#f    NaN
ps2

#DataFrame行索引重建
pd2 = pd1.reindex(['a','b','c','d'])
#结果为：
#	 A	 B	 C
#a	0.0	1.0	2.0
#b	3.0	4.0	5.0
#c	6.0	7.0	8.0
#d	NaN	NaN	NaN
pd2

#DataFrame列索引重建
pd3 = pd1.reindex(columns=['C','B','A'])
#结果为：
#	C	B	A
#a	2	1	0
#b	5	4	3
#c	8	7	6
pd3

2.2.2 增

1. Serise

#在原Serise上增加一个索引
ps['g'] = 9

#增加索引并生成新的Series对象
#创建一个新索引的Serise
s1 = pd.Series({'f':999})
ps3 = ps.append(s1)
ps3

2. DataFrame

#增加列（在原DataFrame上操作）
#新增列的值全为9
pd1[4] = 9
#新增列的值
pd1[4] = 9
#结果为：
#	A	B	C	4
#a	0	1	2	9
#b	3	4	5	9
#c	6	7	8	9
pd1

#插入列（在原DataFrame上操作）
#第0个位置插入索引为E的列 值为[9,99,999]
pd1.insert(0,'E',[9,99,999])
#结果为：
#E	A	B	C	4
#a	9	0	1	2	9
#b	99	3	4	5	9
#c	999	6	7	8	9
pd1

#增加行
#标签索引loc
pd1.loc['d'] = [1,1,1,1,1]
#结果为：
#	E	A	B	C	4
#a	9	0	1	2	9
#b	99	3	4	5	9
#c	999	6	7	8	9
#d	1	1	1	1	1
pd1
#创建字典
row = {'E':6,'A':6,'B':6,'C':6,4:6}
#追加新的行 生成新的dataframe （ignore_index忽略原来的索引）
pd5 = pd1.append(row,ignore_index=True)
#结果为：
#	E	A	B	C	4
#0	9	0	1	2	9
#1	99	3	4	5	9
#2	999	6	7	8	9
#3	1	1	1	1	1
#4	6	6	6	6	6
pd5

2.2.3 删

1. 在原有数据结构上删除

#删除Series中索引b的值（在原有数据结构上删除）
del ps['b']
ps

#删除DataFrame中索引为E的列（在原有数据结构上删除）
del pd1['E']

2.不改变原有数据，生成新的对象

#drop 删除轴上数据
#Series
#删除索引g 产生新的对象（删除一条）
ps6 = ps.drop('g')
ps6

#删除多条
ps1.drop(['c','d'])

#dataframe drop默认删除行索引
#删除索引为a的一行数据（删除一条）
pd1.drop('a')
#删除多条
pd1.drop(['a','d'])
#删除列
#axis=1为删除列
pd1.drop('A',axis=1)
#与axis=1等价
pd1.drop('A',axis='columns')
#inplace属性 True表示在原对象上删除，并不会返回新的对象
ps.drop('g',inplace=True)

2.2.4 改

#Series
#通过标签修改
ps['a']=999
#通过位置索引修改
ps[0] = 888

#DataFrame
#修改一列的数据
#索引A列的数据全部更改为9
pd1['A'] = 9
#修改一列数据
pd1['A'] = [9,10,11]
pd1
#对象.列的形式修改数据值
pd1.A = 6

#修改行数据
#loc标签索引
pd1.loc['a'] = 777
pd1
#修改a行A列的数值
pd1.loc['a','A'] = 1000

2.2.5 查

#Series
#1.行索引
#查看标签索引a对应的值
ps['a']
#查看位置索引0对应的值
ps[0]
#2.切片索引
#位置切片索引(取不到末位)
ps[1:4]
#标签切片索引(可以取到末位)
ps['b':'d']
#3.不连续索引
#标签索引
ps[['b','e']]
#位置索引
ps[[0,2]]
#4.布尔索引
#查询出值大于2的数据
ps[ps>2]

#DataFrame
#1.列索引
pd1['A']
#取多列
pd1[['A','C']]
#选取一个值
#选取A列a行的数据值
pd1['A']['a']
#2.切片
#获取前两行
pd1[:2]

2.3 高级索引

2.3.1 loc标签索引

#loc是基于标签名的索引 自定义的索引名
#Series
#截取索引a-c之间的行
ps['a':'c']
ps.loc['a':'c']

#DataFrame
#第一个参数是索引行，第二个参数是列
#取到a-b之间行的A列
pd1.loc['a':'b','A']
#取到a-b之间行的A-C之间的列
pd1.loc['a':'b','A':'C']

2.3.2 iloc位置索引

#iloc位置索引
#Series
#不包含末位数据
ps[1:3]
#不包含末位数据
ps.iloc[1:3]

#DataFrame
#取到0-1行的第0列数据（不包含末位数据）
pd1.iloc[0:2,0]
#取到0-1行的0-2列数据（不包含末位数据）
pd1.iloc[0:2,0:3]

2.3.3 ix标签与位置混合索引

#ix标签与位置混合索引（已弃用）
ps.ix[1:3]
ps.ix['b':'c']

pd1.ix[0:2,0]