pandas学习日记
pandas学习
ps:还有一些没学完，但是这些已经leisi了
文章目录
- pandas学习
-
- 基础使用
- 选择数据
- loc的用法
-
- 切片的方法
- iloc的用法
- 数据的筛选
- 值的修改
- 插入行与列
- 处理丢失的数据
- 字符串的操作
- contact合成
- merge的合并
-
-
-
- 一对多的合并
-
- 分别一对多
- 多对多的合并
-
-
- groupyby的使用
- multiindex的使用
-
-
-
- 分组后选取数据的方法
-
-
基础使用
pandas基础的创建单元
s = pd.Series([1, 3, 6, np.nan, 44, 1])
# 创建一个1d数组中
dates = pd.date_range('1-1-1', periods=6)
#
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=['a', 'b', 'c', 'd'])
创建一个类似excel的二维数据 左边那一栏 上面那一栏
df = pd.DataFrame({
'a': 1,
'b': pd.Timestamp('20221020'),
'c': pd.Series(1, index=list(range(5,9)), dtype='float32'),
'd': np.array([3] * 4, dtype='int32'),
'e': pd.Categorical(["test", "train", "test", "train"]),
'f': 'foo'
# 当然也可以使用字典的方式来创建
})
输出
0 1.0
1 3.0
2 6.0
3 NaN
4 44.0
5 1.0
dtype: float64
DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03', '2001-01-04',
'2001-01-05', '2001-01-06'],
dtype='datetime64[ns]', freq='D')
a b c d
2001-01-01 -0.475200 1.366880 0.132136 0.925819
2001-01-02 -0.585239 -1.386966 -1.296105 0.061802
2001-01-03 -0.164937 1.313903 -1.428874 -0.184463
2001-01-04 1.492335 1.331895 -0.176759 -2.846150
2001-01-05 -1.186766 1.891096 1.588832 -0.118273
2001-01-06 0.189556 -0.061725 -0.833017 1.085365
a b c d e f
5 1 2022-10-20 1.0 3 test foo
6 1 2022-10-20 1.0 3 train foo
7 1 2022-10-20 1.0 3 test foo
8 1 2022-10-20 1.0 3 train foo
对于dataframe数据的简单查看
print(df.dtypes)# 每一列的type
print(df.index)# 左边那一栏
print(df.columns)# 上面那一栏
print(df.values)# 中间数据
print(df.T)# 行变成列，列表航
输出
a int64
b datetime64[ns]
c float32
d int32
e category
f object
dtype: object
Int64Index([5, 6, 7, 8], dtype='int64')
Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
[[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'test' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'train' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'test' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'train' 'foo']]
a c d
count 4.0 4.0 4.0
mean 1.0 1.0 3.0
std 0.0 0.0 0.0
min 1.0 1.0 3.0
25% 1.0 1.0 3.0
50% 1.0 1.0 3.0
75% 1.0 1.0 3.0
max 1.0 1.0 3.0
5 ... 8
a 1 ... 1
b 2022-10-20 00:00:00 ... 2022-10-20 00:00:00
c 1.0 ... 1.0
d 3 ... 3
e test ... train
f foo ... foo
[6 rows x 4 columns]
sort的操作
print(df.sort_index(axis=1,ascending=False))
1代表对左右的操作 FALSE代表是升序，TRUE是降序
print(df.sort_index(axis=0,ascending=False))
输出
f e d c b a
5 foo test 3 1.0 2022-10-20 1
6 foo train 3 1.0 2022-10-20 1
7 foo test 3 1.0 2022-10-20 1
8 foo train 3 1.0 2022-10-20 1
a b c d e f
8 1 2022-10-20 1.0 3 train foo
7 1 2022-10-20 1.0 3 test foo
6 1 2022-10-20 1.0 3 train foo
5 1 2022-10-20 1.0 3 test foo
选择数据
data = pd.date_range('20221020',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=data,columns=['a','b','c','d'])
输出，基础的数据
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
2022-10-23 12 13 14 15
2022-10-24 16 17 18 19
2022-10-25 20 21 22 23
获取一列的数据
print(df['a'])
输出
2022-10-20 0
2022-10-21 4
2022-10-22 8
2022-10-23 12
2022-10-24 16
2022-10-25 20
获取多行的数据1
print(df[0:3])# 第一行到第三行
# 这种直接使用[]的如果里面是数字一般选择的是左边那一栏，但是如果是标签筛选，则会报错
# 需要使用loc才可以
输出
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
获取多行的数据2
print(df['20221020':'20221022'])# 第20221020到20221022的一行行的数据
输出
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
loc的用法
loc是通过标签来获取数据
获取一行的
print(df.loc['20221022'])
# 只能左边那栏的数据单独使用
输出
a 8
b 9
c 10
d 11
Name: 2022-10-22 00:00:00, dtype: int32
获取上面那一栏的数据
print(df.loc[:,['a','b']])
# ：代表全部都要了
# 左边那一栏 上面那一栏
输出
a b
2022-10-20 0 1
2022-10-21 4 5
2022-10-22 8 9
2022-10-23 12 13
2022-10-24 16 17
2022-10-25 20 21
获取多个列/行的数据
print(df.loc['2022-10-20',['a','b']])
#多个条件记得+[]
输出
a 0
b 1
Name: 2022-10-20 00:00:00, dtype: int32
切片的方法
print(df[2:3])# 类似列表的用法
输出
a b c d
2022-10-22 8 9 10 11
a 12
b 13
c 14
d 15
iloc的用法
类似列表的索引
print(df.iloc[3])
一个数据的时候是对行进行一个索取
输出
a 12
b 13
c 14
d 15
Name: 2022-10-23 00:00:00, dtype: int32
第四行第二个数据的选取（因为是类似列表的选取）
print(df.iloc[3,1])
输出
13
切片的取法
类似列表
print(df.iloc[3:5,1:2])
输出
b
2022-10-23 13
2022-10-24 17
多个的筛选
print(df.iloc[[1,3,5],1:2])
输出
b
2022-10-21 5
2022-10-23 13
2022-10-25 21
数据的筛选
对整个的df进行筛选
print(df>8)# 获得true与fasle
输出
a b c d
2022-10-20 False False False False
2022-10-21 False False False False
2022-10-22 False True True True
2022-10-23 True True True True
2022-10-24 True True True True
2022-10-25 True True True True
对整个的df的a列进行筛选
print(df.a>8)# 获得true与fasle
输出
2022-10-20 False
2022-10-21 False
2022-10-22 False
2022-10-23 True
2022-10-24 True
2022-10-25 True
通过筛选结果，来选取数据
print(df[df.a>8])
这是先通过筛选a列，然后以a列作为标准
去筛选出a列所代表的那一行是可以的
进而得出结果
输出
a b c d
2022-10-23 12 13 14 15
2022-10-24 16 17 18 19
2022-10-25 20 21 22 23
值的修改
就是相当与直接赋值发
df.iloc[2,2]=1111
df.loc['20221020','b']=2222
df[df.a>4]=0
df['a']=22222# 对整个a列都赋一样的值
df['a'] = np.arange(6).reshape(6,1)
df['a'] = pd.Series([1,2,3,4,5,6],index=pd.date_range('20221020',periods=6))
插入行与列
插入列1
df.loc[:, 'charu'] = df['d']-df['a']
直接赋值法，如果df当中没有，就会创建一个
# 但是创建的时候，要重新赋值才会修改数据！！！！
df.insert(loc=2, column='chasini', value=df['d']-df['a'])
# 插入的位置 插入列的名字 插入的信息
# 就是列表的索引，如果位置上面有数据，就会把数据挤走
插入列2 assign
# 类似直接赋值法，但是需要赋值，才会修改数据
df1 = df1.assign(f = ['f','f','f'])
print(df1)
插入行
df.loc[5]= [1,2,3,4,5,6]
类似上面的直接赋值法，有则赋值，无则创建
处理丢失的数据
丢弃数据
print(df.dropna(axis=0,how='any'))
# dropna表示根据参数会将一整个一维数据丢弃
# axis表示是左右还是上下 1数值表示一列都会被丢掉
# 0表示左右一行会被丢掉
# how后面的参数 any表示只要有一个数据丢失就全部丢掉
# all代表全部都没有了才会丢掉
填充数据
print(df.fillna(value=0))
# 进行填入，value表示的填充的是0
判断是否有丢失的数据
print(df.isnull())
# print(df.notnull)#不是空的数据
# 是否有确实的数据
# 但是数据一大就不行好搜查了
print(np.any(df.isnull())==True)
# 记住就好，是true就有，fasle就是没有数据确实
字符串的操作
df = pd.DataFrame(data={'a':['笑死','深圳大学'],
'b':['aa','a']})
df['a']=df['a'].str.replace('深圳','sz')
# 要把数据赋值进去了
print(df)
输出
a b
0 笑死 aa
1 sz大学 a
contact合成
先来几个frame
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=['a','b','c','d'])
print(df1,df2,df3)
输出
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
a b c d
0 1.0 1.0 1.0 1.0
1 1.0 1.0 1.0 1.0
2 1.0 1.0 1.0 1.0
a b c d
0 2.0 2.0 2.0 2.0
1 2.0 2.0 2.0 2.0
2 2.0 2.0 2.0 2.0
res = pd.concat([df1,df2,df3],axis = 1,ignore_index=True)
# 让新的忽略掉之前左边那一栏，重新搞0123456
# 1就是竖直方向不改变，所以左右合并，0同理，左右不变，所以上下变长
输出
0 1 2 3 4 5 6 7 8 9 10 11
0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
1 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
比较简单
下面是，如果标签不一样，或者有冲突怎么办？
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'],index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['b','c','d','e'],index=[2,3,4])
# 两者的数据不太一样，index column不太一样。。。。。
输出
a b c d
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 0.0 0.0 0.0 0.0
b c d e
2 1.0 1.0 1.0 1.0
3 1.0 1.0 1.0 1.0
4 1.0 1.0 1.0 1.0
如果使用contact，那么他的操作就是一个都不会拉下
如果数据a没有x标签，但是数据b有，那么表现出来a当中的x标签就会是nan
如果数据a，b都有相同的一个标签，那么就会出现2个标签，用于区分
print(pd.concat([df1,df2],axis=0))# 没有的那一行或者列，会用nan替代
print(pd.concat([df1,df2],axis=1))# 如果index有冲突，他会重新列多一行出来
输出
a b c d e
1 0.0 0.0 0.0 0.0 NaN
2 0.0 0.0 0.0 0.0 NaN
3 0.0 0.0 0.0 0.0 NaN
2 NaN 1.0 1.0 1.0 1.0
3 NaN 1.0 1.0 1.0 1.0
4 NaN 1.0 1.0 1.0 1.0
a b c d b c d e
1 0.0 0.0 0.0 0.0 NaN NaN NaN NaN
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
4 NaN NaN NaN NaN 1.0 1.0 1.0 1.0
所以，为了避免出现nan
contact里面有个参数叫join，他能决定合并的类型
res = pd.concat([df1,df2],join='inner')# 之后只会出现相同的部分
res = pd.concat([df1,df2],join='inner',ignore_index=True)# 同理index
print(res)
默认的axis是0
输出
b c d
1 0.0 0.0 0.0
2 0.0 0.0 0.0
3 0.0 0.0 0.0
2 1.0 1.0 1.0
3 1.0 1.0 1.0
4 1.0 1.0 1.0
merge的合并
merge的特点是只对两个数据进行合并
创建数据
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k2','k3'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
输出
key a b
0 k0 a0 b0
1 k1 a1 b1
2 k2 a2 b2
3 k3 a3 b3
key c d
0 k0 c0 d0
1 k1 c1 d1
2 k2 c2 d2
3 k3 c3 d3
开始合并
res = pd.merge(left,right,on='key')
# on 表示 key那一栏会被合并
print(res)# 数据key合并了，其余的继续
on 表示 key那一栏会被合并，并且默认对于key只会输出相同参数的行列
就是相当于把key变成了index
如果是除了key以外的，有相同的标签，那么也会分裂成两个（下面会讲）
输出
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 c2 d2
3 k3 a3 b3 c3 d3
一对多的合并
就是left里 key1仅对应一个值
而right里面，key1却对应了两个值
这个时候，left的a就会在left与right同一个值的时候，进行一个复制
为了保证数据的完整填充
left = pd.DataFrame({'key1':['k0','k1','k2'],
'a':['a0','a1','a2']})
right = pd.DataFrame({'key1':['k0','k0','k1','k1','k2','k2'],
'c':['c01','c02','c11','c12','c21','c22']})
res = pd.merge(left,right)
print(res)
输出
key1 a c
0 k0 a0 c01
1 k0 a0 c02
2 k1 a1 c11
3 k1 a1 c12
4 k2 a2 c21
5 k2 a2 c22
分别一对多
就是left的al对了2个值
而rigt的al也对了2个值
为了数据的完整性
所以这两个值要分别遍历，因为他们都是属于al这个大家庭
就是
这个是key1的al有两个值a1 ,a2
而key2的al也有两个值c1 ,c2
那么就会输出 a1c1
a1c2
a2c1
a2c2
left = pd.DataFrame({'key':['al','al','k1','k1','k2'],
'a':['a01','a02','a11','a12','a2']})
right = pd.DataFrame({'key':['al','al','k1','k1','k2','k2'],
'c':['c01','c02','c11','c12','c21','c22']})
res = pd.merge(left,right)
print('here',res)
后面的k1同理
输出
key a c
0 al a01 c01
1 al a01 c02
2 al a02 c01
3 al a02 c02
4 k1 a11 c11
5 k1 a11 c12
6 k1 a12 c11
7 k1 a12 c12
8 k2 a2 c21
9 k2 a2 c22
多对多的合并
就是两个数据的值是你玩你的，我玩我的，没什么交集
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='inner')
# inner就是代表只会合并一样的数据
print(res)
因为inner
所以 对于作为index的key来说，之后有k0,k1被输出，其余数据一样
输出
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
left
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='left')
print(res)
# left指的是 以left的key为标准，不理right了,所以右边没有的就只能是nan了
# how='left'
# 右边同理
输出
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 NaN NaN
3 k3 a3 b3 NaN NaN
outer
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='outer')
print(res)
# outer就是指，谁也别惯着谁，你没有就是nan。。。。
# 笑死
输出
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 NaN NaN
3 k3 a3 b3 NaN NaN
4 k4 NaN NaN c2 d2
5 k5 NaN NaN c3 d3
多个key，就是多个相同的标签
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'a':['ac0','ac1','ac2','ac3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,on='key')
print(res)# 要以key为标准，不然他会以a做标准
# 仅输出了，两行，因为how是默认inner的
# 现在会出现a-x和a-y，就是为了区分两个不一样的数据
输出
key a_x b a_y d
0 k0 a0 b0 ac0 d0
1 k1 a1 b1 ac1 d1
改变上面为了区分的后缀 _X _y
使用suffixes=[‘left’,‘right’],，靠左的就是附在左边的后缀（具体看代码）
res = pd.merge(left,right,on='key',suffixes=['left','right'])
# 这可以改变那个后缀，把上面那个a_x变成a_left，有点肌内。。。
print(res)
输出
key aleft b aright d
0 k0 a0 b0 ac0 d0
1 k1 a1 b1 ac1 d1
累死。。。
groupyby的使用
先来一个数据
（ps:这里的key里面有a,b但是column里面也有a,b，请注意区分，实在不想改了）
df = pd.DataFrame({'key':['a','b','a','b','a','b','a','b'],
'key2':['x','y','x','y','m','n','m','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
输出
key key2 a b
0 a x 1 9
1 b y 2 10
2 a x 3 11
3 b y 4 12
4 a m 5 13
5 b n 6 14
6 a m 7 15
7 b n 8 16
分组
print(df.groupby('key').sum())
就是对key里面的同类进行一个合并
key里面的a，b有很多，那么就会分成a,b两组（指的是key的值而不是a，b标签）
后面有写就是sum，a里面是和key同类的行，就相加
只会输出，那些可以求和的数据
还有mean…
输出
a b
key
a 16 48
b 20 52
一个方法，可以不让key变成索引，只是单纯的进行归类、
print(df.groupby('key',as_index=False).sum())
输出
key a b
0 a 16 48
1 b 20 52
但是我们又发现key里面也有同类项，所以我们又可以进行一个多次分组
代码：
print(df.groupby(['key','key2']).mean())
# 4个a里面2个是m，2个是n
# 那么就会将a组分成两个小组，am和an
# b组也是类似的
输出
a b
key key2
a m 6.0 14.0
x 2.0 10.0
b n 7.0 15.0
y 3.0 11.0
对于分组我们也可以获得我们想要的多个数据
在这里插入代码片print(df.groupby('key').agg([np.sum,np.mean,np.std]))
# 酱紫就可以输出多个你想要的数据 记得加上括号，括号！！！！！
输出
a b
sum mean std sum mean std
key
a 16 4.0 2.581989 48 12.0 2.581989
b 20 5.0 2.581989 52 13.0 2.581989
当然，我们也可以分别获取我们想要的数据
print(df.groupby('key').agg({'a':np.sum,'b':np.std}))
# 酱紫就可以分别进行一个的输出
输出，记得是key里面a的那一列的数据
sum mean std
key
a 16 4.0 2.581989
b 20 5.0 2.581989
and
print(df.groupby('key')['a'].agg([np.sum,np.mean,np.std]))
# ！！！这里！！！！
# 酱紫就可以只查看a那一列的数据了
输出，记得是key里面a的那一列的数据
sum mean std
key
a 16 4.0 2.581989
b 20 5.0 2.581989
因为groupby输出的是一个生成器，所以我们不能直接print
所以我们可以进行一个for循环
例如
g = df.groupby('key')
for name,group in g:
print(name)
print(group)
# 进行全部数据的一个获取
输出
key key2 a b
0 a x 1 9
2 a x 3 11
4 a m 5 13
6 a m 7 15
b
key key2 a b
1 b y 2 10
3 b y 4 12
5 b n 6 14
7 b n 8 16
我们也是可以直接获取到其中的一份数据
代码
g.get_group('a')
输出
key key2 a b
0 a x 1 9
2 a x 3 11
4 a m 5 13
6 a m 7 15
当然，也可以有二级分组的数据
g = df.groupby(['key','key2'])
for x,y in g:
print(x)
print(y)
但是会复杂很多，分出来的组也会变多
输出
('a', 'm')
key key2 a b
4 a m 5 13
6 a m 7 15
('a', 'x')
key key2 a b
0 a x 1 9
2 a x 3 11
('b', 'n')
key key2 a b
5 b n 6 14
7 b n 8 16
('b', 'y')
key key2 a b
1 b y 2 10
3 b y 4 12
当然，类似上面的方法
我们也可以直接获取到某一个组的数据
print(g.get_group([（'a','x'）))
**这里要注意里面要写的是 ( ) **
输出
key key2 a b
0 a x 1 9
2 a x 3 11
累死了
最后一部分了
multiindex的使用
较难，但是类似groupby
创建数据
df = pd.DataFrame({'key':['a','b','a','b','a','b','a','b'],
'key2':['x','x','y','y','m','m','n','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
df = df.sort_values(by='key',ascending=True)
# 小技巧，可以用来整理数据，是的分析数据的时候速度变快
print(df)
输出
key key2 a b
0 a x 1 9
2 a y 3 11
4 a m 5 13
6 a n 7 15
1 b x 2 10
3 b y 4 12
5 b m 6 14
7 b n 8 16
（当然我们也有另外的方式整理数据
print(df.sort_index(axis=0))
0表示对数值方向的数据进行梳理
输出
key key2 a b
0 a x 1 9
1 b x 2 10
2 a y 3 11
3 b y 4 12
4 a m 5 13
5 b m 6 14
6 a n 7 15
7 b n 8 16
))))
然后，我们进行一个分组
ser = df.groupby(['key','key2'])['a'].mean()
# 表示分组 分完组之后再去数据！！
print(ser)
输出
key key2
a m 5.0
n 7.0
x 1.0
y 3.0
b m 6.0
n 8.0
x 2.0
y 4.0
我们可以获取到全部的index
print(ser.index)
输出
MultiIndex([('a', 'm'),
('a', 'n'),
('a', 'x'),
('a', 'y'),
('b', 'm'),
('b', 'n'),
('b', 'x'),
('b', 'y')],
names=['key', 'key2'])
然后我们也可以让ser的index有所改变
print('here',ser.unstack())
输出
key2 m n x y
key
a 5.0 7.0 1.0 3.0
b 6.0 8.0 2.0 4.0
然后我们可以得知，unstack的作用就是将数据变成一层一层的，有多个index
然后是选取数据的方法
print(ser.loc['a'])# 就是pandas的loc，没什么好说的
print(ser.loc['a','m'])
print(ser.loc[:,'m'])
输出
key2
m 5.0
n 7.0
x 1.0
y 3.0
Name: a, dtype: float64
5.0
key
a 5.0
b 6.0
Name: a, dtype: float64
分组后选取数据的方法
先来几个数据
df = pd.DataFrame({'key':['one','two','one','two','one','two','one','two'],
'key2':['x','x','y','y','m','m','n','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
df1 = df.set_index(['key','key2'])# 相当于分组，以key和key2进行分组
df1 = df1.sort_index()
输出
key key2 a b
one m 5 13
n 7 15
x 1 9
y 3 11
two m 6 14
n 8 16
x 2 10
y 4 12
选取数据，用loc，用法一致
print(df1.loc[('one','m')])
输出
key2 a b
m 5 13
n 7 15
x 1 9
y 3 11
and
print(df1.loc[('one','m')])
# 如果是上一层与下一层的关系就要打 (),注意！！！！
# 是两者都是index情况下要打，key与key2要，但是a与b不用
# 不能直接m，因为要通过one才能到m
输出
a 5
b 13
Name: (one, m), dtype: int64
下一级，如果要去index外的标签数据捏？
print(df1.loc[('one','m'),'a'])
# 注意！！！！如果是index外的就直接写在外面
输出
5
and
print(df1.loc[('one',['m','n']),:])
# 同理，m与n同级要打[]，and为了防止系统以为one,..
# 后面的....是代表column，所以在外面也打上 ,:
输出
a b
key key2
one m 5 13
n 7 15
同理，继续下一级
print(df1.loc[('one',['m','n']),'a'])
# 但是这一种用法就不一样了，可以直接省略掉,:
# 因为a就是一个colum！！！！a是column！！！但是前面括号的是index
print(df1.loc[('one',['m','n']),['a','b']])
输出，应该不难吧
key key2
one m 5
n 7
Name: a, dtype: int64
a b
key key2
one m 5 13
n 7 15
万一index的值比较多怎么办捏？
print(df1.loc[(slice(None),['m','n']),:])
# slice代表的是ab那一级的全部，就不用打a，b
# 如果第一级数据多的话，就可以用这个，来获取全部的数据
输出
key key2
one m 5 13
n 7 15
two m 6 14
n 8 16