pandas索引操作
Pandas的索引操作
1. Pandas单层索引操作
创建一个Series和DataFrame：
ps1 = pd.Series(range(5), index=list("abcde"))
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=list("abc"), columns=list("ABC"))
display(ps1, pd1)
结果：
1.1 增
(1). reindex - 在原来索引数据的基础上，创建一个属于新索引的新对象，即创建新对象
Series:
创建新Series对象
ps2 = ps1.reindex(list("abcdef"))
结果：
a 0.0
b 1.0
c 2.0
d 3.0
e 4.0
f NaN
dtype: float64
f在原索引数据中不存在，就为缺失值
DataFrame:
创建新DataFrame对象
默认增加行：
pd2 = pd1.reindex(list("abcd"))
结果：
增加列：
pd3 = pd1.reindex(columns=list("BCDA"))
结果：可以自定义顺序
(2). 增加行
Series:
方法一：（改变原对象）
ps1['g'] = 11
结果：
a 0
b 1
c 2
d 3
e 4
g 11
dtype: int64
方法二：（创建新对象，不改原对象）
ps1 = pd.Series({"f":888})
ps4 = ps1.append(s1)
ps4
结果：
a 0
b 1
c 2
d 3
e 4
f 888
dtype: int64
DataFrame:
增加列：
结尾插入
- 方法一
pd1["D"] = [99,88,77]
结果：
- 方法二：
pd1.D = [99,88,77]
指定插入：
- 方法三：
pd1.insert(loc, column, value, allow_duplicates=False)
pd1.insert(0, "E", [6, 66, 666])
pd1
结果：
增加行：
- 方法一
pd1.loc['d'] = 3
结果：
- 方法二
row = {"E": 8, "A": 5, "B":3}
pd1.append(row, ignore_index=True)
ignore_index 默认为False，为True时会生成新的对象使用新的索引(自动产生)
1.2 删
DataFrame:
- 方法1 - 删除
列数据，改变原数据（删除单个数据）
del pd1["A"]
结果：
对于Series同理
del ps1["A"]
- 方法2 - 删除
列数据，改变原数据（删除单个数据）：
del(pd1["A"])
结果：
对于Series同理
del(ps1["A"])
- 方法3 - 删除
行或列数据，可指定更改或不更改原数据，默认不更改原数据（删除多个数据）：
.drop(index=None, columns=None, axis=0, inplace=False)
pd1.drop(columns=["A", "C"])
结果：
默认删除行：
pd1.drop(index=["a", "c"])
or
pr1.drop(["a", "c"])
结果：
查看原数据, 不改变:
加上参数inplace，为True替代原数据，为False不更改原数据，默认为False
pd1.drop(index=["a", "c"], inplace=True)
查看原数据:
pd1
1.3 改
1. 改变DataFrame索引(不可更改)
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=list("abc"), columns=list("ABC"))
pd1.index[1]
结果：
'b'
更改：
pd1.index[1] = "B"
报错：
TypeError: Index does not support mutable operations
pandas库的索引不支持可变操作！保证数据的安全
2. 改变值
Series:
ps1["a"] = 987
or
ps1[0] = 987
结果：
a 987
b 1
c 2
d 3
e 4
dtype: int64
DataFrame:
- 方法一：
pd1["A"] = [33,44,55]
结果：
- 方法二：
# pd1.B生成series对象
pd1.B = [22,44,66]
结果：
- 方法三
pd1.loc["a"] = [999,888,777]
pd1
结果：
指定一个值修改：
pd1.loc["a","B"] = 9000
or
pd1["B"]["a"] = 9000
# pd1["B"]为series对象
结果：
- 方法四
将A、B两列数值乘以2
pd1[["A", "B"]].transform(lambda x: x*2)
1.4 查
(1). Series:
- 标签和下标查找
ps1["a"]
or
ps1[0]
- 切片查找
位置索引(下标)切片
ps1[1:4]
标签切片
ps1["b":"d"]
- 不连续切片
不连续位置索引 ( 下标切片 )切片
ps1[[1,3]]
不连续标签索引切片
ps1[["b","d"]]
(2). DataFrame:
列选取：
1.一列：
- 标签
pd1["A"]
只能标签，下标pd1[0]报错
2.多列：
- 不连续切片：
不连续标签索引切片：
pd1[["A","D"]]
只能标签索引，下标索引pd1[[0, 4]]报错
- 连续切片：
pd1[:4]
or
pd1[:"D"]
3.选取一个值：
pd1["A"]["a"]
1.5 高级索引
(1). loc 标签索引
注意：loc标签索引的切片，如：[a:b] 包含b值
Series:
ps1["a":"c"]
ps1.loc["a":"c"]
DataFrame:
先索引行，再选取列
pd1.loc["a":"b", "A":"B"]
(2). iloc 位置索引
Series：
ps1[1:3]
ps1.iloc[1:3]
DataFrame：
ps1.iloc[0:2, 0:3]
(3). ix 位置和标签混合使用(不推荐了，废弃了，官方建议使用iloc表示下标，loc表示标签，分开来使用)
ps1.ix[1:3]
2. Pandas层级索引
应用：数据重塑，分组操作
2.1. 层级索引
s1 = pd.Series(np.random.randn(12), index=[list("aaabbbcccddd"),list("012012012012")])
s1
层级索引
type(s1.index)
# 结果
pandas.core.indexes.multi.MultiIndex
2.2 选取内外层索引
选取外层
s1["a"]
# 结果
0 -2.223384
1 -2.046496
2 -2.014837
dtype: float64
内层选取(内层只能为单一值)
s1[:, "2"]
# 结果
a -2.014837
b -0.222377
c 0.230387
d -0.268586
dtype: float64
单值选取
s1["a", "1"]
# 结果
-2.046496324441556
2.3 交换内外层索引位置
(1). 交换内外层的索引：
swaplevel()函数
0 a -2.223384
1 a -2.046496
2 a -2.014837
0 b 0.925066
1 b -0.603006
2 b -0.222377
0 c 0.340287
1 c 0.350538
2 c 0.230387
0 d 1.809419
1 d 1.421640
2 d -0.268586
dtype: float64
选取abcd的0,1：
s2 = s1.swaplevel()
s2[["0","1"]]
# 结果
0 a -2.223384
1 a -2.046496
0 b 0.925066
1 b -0.603006
0 c 0.340287
1 c 0.350538
0 d 1.809419
1 d 1.421640
dtype: float64
(2). 交换并排序分层：
s1.swaplevel().sortlevel()
# 结果
2.4 层级索引转变为单层行与列索引
p = s1.unstack()
p
还原：
p.stack()
a 0 0.964190
1 0.362503
2 -0.581239
b 0 -0.662040
1 -0.749162
2 1.511100
c 0 -0.649047
1 -0.968815
2 0.445595
d 0 -2.207308
1 -0.084686
2 -0.750083
dtype: float64
