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

你可能感兴趣的:(pandas,学习,python)