码迷，mamicode.com
首页 > 编程语言 > 详细

python-pandas基础数据结构（DataFrame）

时间：2020-04-29 20:06:07      阅读：59      评论：0      收藏：0      [点我收藏+]

标签：多重   values   color   索引   必须   rop   panda   数位   返回结果   

一、DataFrame简述

       DataFrame可以把它理解成是表格型的数据结构，也是一种带有标签的二维数组。DataFrame带有行标签（index）和列标签（columns），其中values属性可以查询DataFrame数据，返回的是二维数组结构。

a = {‘a‘:[0,1,2],
     ‘b‘:[3,4,5],
     ‘c‘:[6,7,8]}
df = pd.DataFrame(a)       
print(df,type(df),‘\n‘)
print(df.index,type(df.index),‘\n‘)
print(df.columns,type(df.columns),‘\n‘)
print(df.values,type(df.values)

#运行结果
   a  b  c
0  0  3  6
1  1  4  7
2  2  5  8 <class ‘pandas.core.frame.DataFrame‘> 

RangeIndex(start=0, stop=3, step=1) <class ‘pandas.indexes.range.RangeIndex‘> 

Index([‘a‘, ‘b‘, ‘c‘], dtype=‘object‘) <class ‘pandas.indexes.base.Index‘>

[[0 3 6]
 [1 4 7]
 [2 5 8]] <class ‘numpy.ndarray‘>

二、DataFrame的创建

1、由数组/list组成的字典来创建

a1 = {‘a‘:[0,1,2],
     ‘b‘:[3,4,5],
     ‘c‘:[6,7,8]}
df1 = pd.DataFrame(a1)       
print(df1)

a2 = {‘one‘:np.random.rand(2),
     ‘two‘:np.random.rand(2)}
df2 = pd.DataFrame(a2)      
print(df2)

#运行结果
  a  b  c
0  0  3  6
1  1  4  7
2  2  5  8
        one       two
0  0.964716  0.420940
1  0.356944  0.893939

 

#接上面
df1 = pd.DataFrame(a1,columns = [‘b‘,‘a‘,‘c‘,‘new‘]) 
print(df1)
#可以重新定义columns的顺序，格式为list，若新增列则赋予NaN

df2 = pd.DataFrame(a2,index = list(‘ab‘))   
print(df2)
#可以重新定义index，格式为list，长度必须与原来保持一致

#运行结果
   b  a  c  new
0  3  0  6  NaN
1  4  1  7  NaN
2  5  2  8  NaN
        one       two
a  0.110687  0.824890
b  0.634459  0.112624

2、由Series组成的字典来创建

a = {‘one‘:pd.Series(np.random.rand(2)),
     ‘two‘:pd.Series(np.random.rand(3))}
df = pd.DataFrame(a)
print(df)

#运行结果
      one       two
0  0.371240  0.971477
1  0.122308  0.534714
2       NaN  0.306376

3、由字典组成的字典来创建

a = {‘Jack‘:{‘Math‘:90,‘English‘:90,‘Chinese‘:90},
    ‘Tom‘:{‘Math‘:80,‘English‘:80,‘Chinese‘:80},
    ‘Marry‘:{‘Math‘:70,‘English‘:70,‘Chinese‘:70}}
df1 = pd.DataFrame(a)        
print(df1)       # 由字典组成的字典创建Dataframe，columns为字典的key，index为子字典的key

df2 = pd.DataFrame(a,columns = [‘Tom‘,‘Jack‘,‘July‘])
print(df2)       #columns参数可以改变顺序、增加、减少现有列，如出现新的列，值为NaN

df3 = pd.DataFrame(a,index = [‘Math‘,‘a‘,‘b‘,‘c‘])
print(df3)       # index在这里和之前不同，并不能改变原有index，如果指向新的标签，值为NaN 

#运行结果
        Jack  Marry  Tom
Chinese    90     70   80
English    90     70   80
Math       90     70   80
         Tom  Jack July
Chinese   80    90  NaN
English   80    90  NaN
Math      80    90  NaN
      Jack  Marry   Tom
Math  90.0   70.0  80.0
a      NaN    NaN   NaN
b      NaN    NaN   NaN
c      NaN    NaN   NaN

4、由字典组成的列表来创建

a = [{‘one‘:1,‘two‘:2},
     {‘one‘:10,‘two‘:20,‘three‘:30}]
df1 = pd.DataFrame(a)
df2 = pd.DataFrame(a,index = [‘a‘,‘b‘])  #index是直接改变值的
print(df1)
print(df2)

#运行结果
   one  three  two
0    1    NaN    2
1   10   30.0   20
   one  three  two
a    1    NaN    2
b   10   30.0   20

5、由二维数组来创建

a = np.random.rand(9).reshape(3,3)
df = pd.DataFrame(a,index = list(‘abc‘),columns = [‘one‘,‘two‘,‘three‘])
print(df)
#注：这里的index和columns长度必须和二维数组一致

#运行结果
       one       two     three
a  0.478309  0.741675  0.953912
b  0.034855  0.561662  0.563623
c  0.139156  0.705862  0.491152

三、DataFrame的索引和切片

1、列切片

df = pd.DataFrame(np.arange(12).reshape(3,4),
                columns = list(‘abcd‘),
                index = [‘one‘,‘two‘,‘three‘])
print(df)
data1 = df[[‘a‘,‘b‘]]    #注：这里面还需要一个括号
print(data1)
#一般用df[]进行列切片，括号里填列名，如果填数字的话默认行切片，且不能单独选择，如df[0]是不行的

#运行结果
       a  b   c   d
one    0  1   2   3
two    4  5   6   7
three  8  9  10  11
       a  b
one    0  1
two    4  5
three  8  9

2、行切片（用.loc和.iloc这两种方法）

      .loc[ ]方法是通过标签的名字进行索引的，它既可以单索引切片，也可以多索引切片，且是末端包含的，并且.loc[ ]可以索引超过已有行的位置。

    .iloc方法是按照整数位置来索引的，括号里填的是整数，它是不能索引超过已有行的，而且是末端不包含的。

df = pd.DataFrame(np.arange(12).reshape(3,4),
                columns = list(‘abcd‘),
                index = [‘one‘,‘two‘,‘three‘])
print(df)
data1 = df.loc[‘one‘]     #单个位置的索引
data2 = df.loc[[‘one‘,‘three‘]]     #多个位置的索引，这里面要有括号
data3 = df.loc[‘one‘:‘three‘]       #还可以切片索引
data4 = df.loc[[‘one‘,‘four‘]]      #对没有的index进行索引，返回NaN
print(data1,‘\n‘)
print(data2,‘\n‘)
print(data3,‘\n‘)
print(data4,‘\n‘)

#运行结果
       a  b   c   d
one    0  1   2   3
two    4  5   6   7
three  8  9  10  11
a    0
b    1
c    2
d    3
Name: one, dtype: int32 

       a  b   c   d
one    0  1   2   3
three  8  9  10  11 

       a  b   c   d
one    0  1   2   3
two    4  5   6   7
three  8  9  10  11 

        a    b    c    d
one   0.0  1.0  2.0  3.0
four  NaN  NaN  NaN  NaN 
df = pd.DataFrame(np.arange(12).reshape(3,4),
                columns = list(‘abcd‘),
                index = [‘one‘,‘two‘,‘three‘])
print(df)
data1 = df.iloc[1]
data2 = df.iloc[[0,2]]
data3 = df.iloc[:2]
print(data1,‘\n‘)
print(data2,‘\n‘)
print(data3,‘\n‘)

#运行结果
      a  b   c   d
one    0  1   2   3
two    4  5   6   7
three  8  9  10  11
a    4
b    5
c    6
d    7
Name: two, dtype: int32 

       a  b   c   d
one    0  1   2   3
three  8  9  10  11 

     a  b  c  d
one  0  1  2  3
two  4  5  6  7

3、布尔型索引（和Series的原理类似）

 

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                columns = list(‘abcd‘),
                index = [‘one‘,‘two‘,‘three‘,‘four‘])
print(df,‘\n‘)

data1 = df[df > 50]   #放回符合条件的值，不符合条件的值为NaN
print(data1,‘\n‘)

data2 = df[df[‘a‘] > 50]    #先单列做判断，再返回结果为True的行
print(data2,‘\n‘)

data3 = df[df[[‘a‘,‘b‘]] > 50]     #多列做判断
print(data3,‘\n‘)

data4 = df[df.loc[[‘one‘,‘two‘]] > 50]    #多行做判断
print(data4)

#运行结果
               a          b          c          d
one    62.787540  20.666730  91.358127   9.435425
two    53.820915  56.264460  54.644562  75.337214
three  26.538461  48.790031  86.984291   2.213960
four   94.865606  73.560053   5.123474  84.851537 

               a          b          c          d
one    62.787540        NaN  91.358127        NaN
two    53.820915  56.264460  54.644562  75.337214
three        NaN        NaN  86.984291        NaN
four   94.865606  73.560053        NaN  84.851537 

              a          b          c          d
one   62.787540  20.666730  91.358127   9.435425
two   53.820915  56.264460  54.644562  75.337214
four  94.865606  73.560053   5.123474  84.851537 

               a          b   c   d
one    62.787540        NaN NaN NaN
two    53.820915  56.264460 NaN NaN
three        NaN        NaN NaN NaN
four   94.865606  73.560053 NaN NaN 

               a         b          c          d
one    62.787540       NaN  91.358127        NaN
two    53.820915  56.26446  54.644562  75.337214
three        NaN       NaN        NaN        NaN
four         NaN       NaN        NaN        NaN

4、多重索引（同时筛选行和列）

    我们可以先筛选列，在筛选行，即处理数据的时候先筛选字段，再筛选数据的量。

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                columns = list(‘abcd‘),
                index = [‘one‘,‘two‘,‘three‘,‘four‘])
print(df,‘\n‘)

print(df[‘a‘].loc[[‘one‘,‘three‘]],‘\n‘)
print(df[df[‘a‘] > 50].iloc[:2])

#运行结果
               a          b          c          d
one    50.411475  31.087751  18.958850  46.813210
two    23.162358  39.535175  45.106366  78.041107
three  91.972419  82.752934  94.821926  86.654188
four   63.743092  62.591314  59.975080  29.558177 

one      50.411475
three    91.972419
Name: a, dtype: float64 

               a          b          c          d
one    50.411475  31.087751  18.958850  46.813210
three  91.972419  82.752934  94.821926  86.654188

 四、DataFrame的基本操作方法

1、查看和转置（类似于Series）

df = pd.DataFrame(np.random.rand(12).reshape(6,2)*100,
                 columns = [‘one‘,‘two‘])
print(df.head(2))    #查看头部数据
print(df.tail())     #查看尾部数据，不填数字默认5条
print(df.T)          #转置，行列互换

#运行结果
        one        two
0  53.489385  31.202920
1   5.997141   3.141106
         one        two
1   5.997141   3.141106
2  96.424950  29.471567
3  27.111331  80.542447
4  35.198373  62.578070
5  28.974724  40.596728
             0         1          2          3          4          5
one  53.489385  5.997141  96.424950  27.111331  35.198373  28.974724
two  31.202920  3.141106  29.471567  80.542447  62.578070  40.596728

2、添加

df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                 columns = list(‘abcd‘))
print(df)
df[‘e‘] = 10     #添加列
print(df)
df.loc[4] = 20   #添加行
print(df)

#运行结果
        a          b          c          d
0  77.383301  91.582829  12.947135  33.315974
1  86.272310  41.139458  86.445219  99.999344
2  89.409235  28.999194  22.190588  13.010493
           a          b          c          d   e
0  77.383301  91.582829  12.947135  33.315974  10
1  86.272310  41.139458  86.445219  99.999344  10
2  89.409235  28.999194  22.190588  13.010493  10
           a          b          c          d   e
0  77.383301  91.582829  12.947135  33.315974  10
1  86.272310  41.139458  86.445219  99.999344  10
2  89.409235  28.999194  22.190588  13.010493  10
4  20.000000  20.000000  20.000000  20.000000  20

3、修改

df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                 columns = list(‘abcd‘))
print(df)
df1 = df.copy()
df2 = df.copy()

df1[[‘a‘,‘b‘]] = 20   #直接索引修改
print(df1)

df2.loc[df2[‘b‘] > 50,‘a‘] = 0   #逗号前面是条件，逗号面是要改变的列名
print(df2)

#运行结果
           a          b          c          d
0  58.247472  70.337448  63.115804  91.517310
1  59.591559  28.327665  66.339979   0.902682
2  21.920386  17.240483  36.502033  93.849510
      a     b          c          d
0  20.0  20.0  63.115804  91.517310
1  20.0  20.0  66.339979   0.902682
2  20.0  20.0  36.502033  93.849510
           a          b          c          d
0   0.000000  70.337448  63.115804  91.517310
1  59.591559  28.327665  66.339979   0.902682
2  21.920386  17.240483  36.502033  93.849510

4、删除

     del 删除列，改变了原来的数据；.drop()也是删除，可以删除行和列，当会生成新的数据，不改变原数据。

df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                 columns = list(‘abcd‘),
                 index = [‘one‘,‘two‘,‘three‘])
print(df)
del df[‘d‘]
print(df)

print(df.drop([‘one‘]))    #默认是删除行,括号里填入行名
print(df.drop([‘a‘],axis = 1))     #加了参数后，删除列，括号里填入列名

#运行结果
              a          b          c          d
one    54.013312  42.523130   6.792826  35.433455
two    18.595228  75.123504  17.026400  10.564516
three   7.532090  76.689347  43.479484  20.220647
               a          b          c
one    54.013312  42.523130   6.792826
two    18.595228  75.123504  17.026400
three   7.532090  76.689347  43.479484
               a          b          c
two    18.595228  75.123504  17.026400
three   7.532090  76.689347  43.479484
               b          c
one    42.523130   6.792826
two    75.123504  17.026400
three  76.689347  43.479484

5、对齐

df1 = pd.DataFrame(np.random.rand(10,4),
                  columns = list(‘abcd‘))
df2 = pd.DataFrame(np.random.rand(7,3),
                  columns = list(‘abc‘))
print(df1 + df2) #按照列和行标签进行对齐的，对不齐的值为NaN

#运行结果
          a         b         c   d
0  0.716637  1.150983  1.369721 NaN
1  0.226954  0.821476  0.277249 NaN
2  0.771878  1.078424  0.248526 NaN
3  1.120488  1.107775  0.749390 NaN
4  0.975615  0.515302  0.987700 NaN
5  0.957985  1.459794  1.080611 NaN
6  0.665720  1.114098  0.453194 NaN
7       NaN       NaN       NaN NaN
8       NaN       NaN       NaN NaN
9       NaN       NaN       NaN NaN

6、排序

（1）.sort_values( [列名]，ascending = True/False )方法，是按照值进行排序的，ascending的升降序的参数，True是升序，False是降序。这个方法不改变原数据。

df = pd.DataFrame(np.random.rand(4,3)*100,
                 columns = list(‘abc‘))
print(df)
df1 = df.sort_values([‘a‘])    #默认是升序，且这个方法不会改变原数据
df2 = df.sort_values([‘a‘],ascending = False)  
print(df1)
print(df2)

#运行结果
          a          b          c
0  16.014360  18.315673   4.582076
1  17.572265  12.793833  36.774427
2  82.945503  61.148299  34.235598
3  47.561511  46.960933  18.928759
           a          b          c
0  16.014360  18.315673   4.582076
1  17.572265  12.793833  36.774427
3  47.561511  46.960933  18.928759
2  82.945503  61.148299  34.235598
           a          b          c
2  82.945503  61.148299  34.235598
3  47.561511  46.960933  18.928759
1  17.572265  12.793833  36.774427
0  16.014360  18.315673   4.582076

（2）.sort_index( ascending = True/False)方法，是按照行标签进行排序的，ascending的升降序的参数，True是升序，False是降序。这个方法不改变原数据。

df1 = pd.DataFrame(np.random.rand(5,2),
                  index = [4,3,1,2,5])
df2 = pd.DataFrame(np.random.rand(5,2),
                  index = [‘d‘,‘c‘,‘a‘,‘b‘,‘e‘])
print(df1.sort_index())
print(df2.sort_index(ascending = False))

#运行结果
         0         1
1  0.263742  0.462527
2  0.485418  0.621751
3  0.888531  0.886704
4  0.179775  0.148224
5  0.141401  0.009850
          0         1
e  0.743093  0.529084
d  0.546709  0.898403
c  0.092891  0.543375
b  0.685351  0.017085
a  0.768035  0.215217

 

python-pandas基础数据结构（DataFrame）

标签：多重   values   color   索引   必须   rop   panda   数位   返回结果   

原文地址：https://www.cnblogs.com/sparkingplug/p/12782585.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！