文章目录
索引对象
Index类对象，该对象不可以进行修改（不可变性），以保证数据的安全。
多个数据结构之间共享index类对象
基于Index类对象的不可变性，实现两个以上数据结构共享一个索引
import pandas as pd
import numpy as np
ser_obj1 = pd.Series(range(3), index=['a', 'b', 'c'])
ser_obj2 = pd.Series(['a', 'b', 'c'], index=ser_obj1.index)
print(ser_obj2.index is ser_obj1.index)
print(ser_obj1)
print(ser_obj2)
输出结果：
True
a 0
b 1
c 2
dtype: int64
a a
b b
c c
dtype: object
is与==的区别
is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；而==比较的是对象的值是否相等。
重置索引——reindex()
该方法的作用时对原索引和新索引进行匹配，新索引含有原索引的数据，而原索引数据按照新索引排序。
语法格式：
DataFrame.reindex(labels = None, index = None, columns = None, axis = None, method = None,
copy = None, level = None, fill_value = nan, limit = None, tolerance = None)
上述方法的部分参数含义如下：
index：用作索引的新序列
method：插值填充方式
fill_value：引入缺失值时使用的替代值
limit：前向或者后向填充时的最大填充量
如果新索引中没有原索引的数据，那么将新添加的索引的值填充为NaN。
ser_obj5 = pd.Series(range(1, 6, 1), index=['c', 'd', 'a', 'b', 'e'])
print("ser_obj5", ser_obj5)
ser_obj6 = ser_obj5.reindex(['a', 'b', 'c', 'd', 'e', 'f'])
print("ser_obj6", ser_obj6)
输出结果：
ser_obj5
c 1
d 2
a 3
b 4
e 5
dtype: int64
ser_obj6
a 3.0
b 4.0
c 1.0
d 2.0
e 5.0
f NaN
dtype: float64
如果不想填充为NaN，则可使用fill_value参数来指定缺失值。
ser_obj7 = ser_obj5.reindex(['a', 'b', 'c', 'd', 'e', 'f'], fill_value=6)
print("ser_obj7", ser_obj7)
输出结果：
ser_obj7
a 3
b 4
c 1
d 2
e 5
f 6
dtype: int64
fill_value参数会让所有的缺失值都填充为同一个值。
如果期望使用相邻的元素值（上或下一个元素的值）进行填充，则可使用method参数。
| 参数 | 说明 |
|---|---|
| ffill 或 pad | 前向填充值 |
| bfill 或 backfill | 后向填充值 |
| nearest | 从最近的索引值填充（先后再前） |
ser_obj3 = pd.Series([1, 3, 5, 7], index=[0, 2, 3, 6])
print("ser_obj3", ser_obj3)
ser_obj4 = ser_obj3.reindex(range(7), method="nearest")
print("ser_obj4", ser_obj4)
输出结果：
ser_obj3
0 1
2 3
3 5
6 7
dtype: int64
ser_obj4
0 1
1 3
2 3
3 5
4 5
5 7
6 7
dtype: int64
索引操作
Series的索引操作
两种索引方式：
print("ser_obj1[2]:", ser_obj1[2]) # 使用索引位置获得数据
print("ser_obj1['c']:", ser_obj1['c']) # 使用索引名称获取数据
ser_obj1
a 0
b 1
c 2
dtype: int64
输出结果：
ser_obj1[2]: 2
ser_obj1['c']: 2
切片
位置索引进行切片，切片结果包含起始位置不包括结束位置（前闭后开）
索引名称进行切片，切片结果包含起始位置包括结束位置（前闭后闭）
print("ser_obj5[2:4]:\n", ser_obj5[2:4]) # 使用位置索引进行切片
print("ser_obj7['b':'d']:\n", ser_obj7['b':'d']) # 使用索引名称进行切片
ser_obj5
c 1
d 2
a 3
b 4
e 5
dtype: int64
ser_obj7
a 3
b 4
c 1
d 2
e 5
f 6
dtype: int64
输出结果：
ser_obj5[2:4]:
a 3
b 4
dtype: int64
ser_obj7['b':'d']:
b 4
c 1
d 2
dtype: int64
不连续索引
print("ser_obj5[[0, 2, 4]]:\n", ser_obj5[[0, 2, 4]]) # 通过不连续位置索引获取数据集
print("ser_obj7[['a', 'c', 'e']]:\n", ser_obj7[['a', 'c', 'e']]) # 通过不连续索引名称获取数据集
输出结果：
ser_obj5[[0, 2, 4]]:
c 1
a 3
e 5
dtype: int64
ser_obj7[['a', 'c', 'e']]:
a 3
c 1
e 5
dtype: int64
布尔型索引
将布尔型的数组索引作为模板筛选数据，返回与模板中True位置对应的元素
ser_bool = ser_obj7 > 2 # 创建布尔型Series对象
print("ser_bool:\n", ser_bool)
print("ser_obj7[ser_bool]:\n", ser_obj7[ser_bool]) # 获取结果为True的数据
输出结果：
ser_bool:
a True
b True
c False
d False
e True
f True
dtype: bool
ser_obj7[ser_bool]:
a 3
b 4
e 5
f 6
dtype: int64
DataFrame的索引操作
DataFrame中每列的数据都是一个Series对象，可以使用列索引获取
arr1 = np.arange(12).reshape(3, 4)
df_obj1 = pd.DataFrame(arr1, columns=['a', 'b', 'c', 'd'])
# 创建DataFrame对象，并为其指定列索引
print("df_obj1:\n", df_obj1)
print("df_obj1['b']:\n", df_obj1['b']) # 获取b列的数据
输出结果：
df_obj1:
a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
df_obj1['b']:
0 1
1 5
2 9
Name: b, dtype: int32
获取不连续的Series对象
print("df_obj1[['b', 'd']]:\n", df_obj1[['b', 'd']])
输出结果：
df_obj1[['b', 'd']]:
b d
0 1 3
1 5 7
2 9 11
切片
print("df_obj1[:2]:\n", df_obj1[:2]) # 使用切片获取第0~1行的数据
print("df_obj1[:3][['b', 'd']]:\n", df_obj1[:3][['b', 'd']])
# 使用切片先通过行索引获取0~2行的数据，再通过不连续列索引获取b、d列的数据
输出结果：
df_obj1[:2]:
a b c d
0 0 1 2 3
1 4 5 6 7
df_obj1[:3][['b', 'd']]:
b d
0 1 3
1 5 7
2 9 11
Pandas库中的操作索引方法
loc：基于标签索引（索引名称，如：a、b等），用于按标签选取数据。当执行切片操作时，既包含起始索引，也包含结束索引。（前闭后闭）
iloc：基于位置索引（整数索引，如：0~length-1），用于按位置选取数据。当执行切片操作时，只包含起始索引，不包含结束索引。（前闭后开）
iloc方法主要使用整数来索引数据，而不能使用字符标签来索引数据。
loc方法只能使用字符标签来索引数据，而不能使用整数来索引数据。不过，当DataFrame对象的行索引或者列索引使用的是整数时，则其就可以使用整数来索引。
print("df_obj1.loc[:, [“d”, “b”]]:\n", df_obj1.loc[:, ["d", "b"]])
print("df_obj1.iloc[:, 3, 1]:\n", df_obj1.iloc[:, [3, 1]])
输出结果：
df_obj1.loc[:, [“d”, “b”]]
d b
0 3 1
1 7 5
2 11 9
df_obj1.iloc[:, 3, 1]:
d b
0 3 1
1 7 5
2 11 9
花式索引【数组索引】
print("df_obj1.loc[:1, [“c”, “a”]]:\n", df_obj1.loc[0:1, ["c", "a"]])
print("df_obj1.iloc[:2, [2, 0]]:\n", df_obj1.iloc[0:2, [2, 0]])
输出结果：
df_obj1.loc[:1, [“c”, “a”]]:
c a
0 2 0
1 6 4
df_obj1.iloc[:2, [2, 0]]:
c a
0 2 0
1 6 4