数据分析学习笔记（九） -- Pandas：数据结构及基本使用

三种数据结构

Series：系列（数组）
DataFrame：数据帧（表）
Panel：面板（表容器）

描述和对比

数据结构	维数	描述
Series	1	数据均匀的数组
DataFrame	2	大小可变的表结构数据
Panel	3	大小可变，可理解为表容器

注：较高维数据结构是其较低维数据结构的容器，例如：DataFrame其实就是Series的容器。三种数据结构中，DataFrame被广泛使用，是Pandas里最重要的数据结构之一。

Series对象创建及操作

Series对象是以一维数组的形式存储数据的，因此通常需要一个一位数组作为数据源

创建Series对象

# Series对象
s = pd.Series([2, 4, np.nan, 'lolita'])
print(s)
'''
0         2
1         4
2       NaN
3    lolita
dtype: object'''
s = pd.Series(list('abcde'))
print(s)
'''
0    a
1    b
2    c
3    d
4    e
dtype: object'''
# 如果是多维度的数据则会发生错误
s = pd.Series(np.arange(8).reshape(2,4))
print(s)
'''raise Exception('Data must be 1-dimensional')
Exception: Data must be 1-dimensional
'''

查看和修改数组

查看Series数据和普通的一维数组切片类似，可通过下标实现

s = pd.Series(list('abcde'))

获取数据

value = s[2]
print(value)
'''c'''
value = s[1:3]
print(value)
'''
1    b
2    c
dtype: object
'''

修改数据值

s[3:] = np.arange(0, len(s)-3)
print(s)
'''
0    a
1    b
2    c
3    0
4    1
dtype: object'''

修改数组大小

s[len(s)] = 3
print(s)
'''
0    a
1    b
2    c
3    0
4    1
5    3
dtype: object'''

DataFrame对象创建及操作

DataFrame对象是Series对象的容器，因此它是二维的对象，跟numpy中的二维数组不同的是，DataFrame对象有行索引和列索引，从直观上来看，DataFrame和表有些类似，因此可以将其当作表结构的数据来看待。

创建DataFrame对象

首先，我们使用numpy创建一个二维数组作为数据源，并且不设置行索引和列索引

df = pd.DataFrame(np.arange(15).reshape(3,5))
print(df)
'''
    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14'''

我们可以看出，不设置行索引和列索引，DataFrame会默认使用数字来表示。

接下来，我们为DataFame指定行列索引

# 行索引
dates = pd.date_range('20180506', periods=7)
print(dates)
'''
DatetimeIndex(['2018-05-06', '2018-05-07', '2018-05-08', '2018-05-09',
               '2018-05-10', '2018-05-11', '2018-05-12'],
              dtype='datetime64[ns]', freq='D')
              '''
# 列索引
columns = list('ABCD')
df = pd.DataFrame(np.random.randn(7,4), index=dates, columns=columns)
print(df)
'''
                   A         B         C         D
2018-05-06 -0.274367  0.402984 -0.381829  0.123850
2018-05-07  0.422842  0.548137 -0.183929  0.800568
2018-05-08 -0.485918 -2.088587  1.407923 -0.249723
2018-05-09  1.929589  0.579739  1.395986 -0.602761
2018-05-10  0.016730  0.278051  0.100124 -0.208399
2018-05-11  1.050533  0.147563  0.480859 -0.608219
2018-05-12  0.253236 -1.476788  0.115376 -0.488298
'''

另外，我们还可以通过可转换为类似系列的对象的字典来创建DataFrame。

如：

# 另外一种创建DataFrame方式
df2 = pd.DataFrame({
    'A':pd.Series(1, index=list(range(4))),
    'B':26,
    'C':pd.Timestamp('20180506'),
    'D':np.array(np.arange(4))
})
print(df2)
'''
   A   B          C  D
0  1  26 2018-05-06  0
1  1  26 2018-05-06  1
2  1  26 2018-05-06  2
3  1  26 2018-05-06  3'''

选择区域，查看数据

示例数据

dates = pd.date_range('20180506', periods=7)
columns = list('ABCD')
df = pd.DataFrame(np.random.randn(7,4), index=dates, columns=columns)

1、直接操作DataFrame数组获取其中的数据

a. 通过列标签选择某一列

data = df['A']     # 等同于 df.A
print(data)
'''
2018-05-06    0.151124
2018-05-07    0.771603
2018-05-08   -1.457813
2018-05-09   -0.102214
2018-05-10   -1.266102
2018-05-11    0.780995
2018-05-12    0.957048
Freq: D, Name: A, dtype: float64'''

b. 通过列标签获取某些行

data = df['20180506':'20180510']
print(data)
'''
                   A         B         C         D
2018-05-06 -0.361994 -2.217695 -0.789552 -0.966792
2018-05-07  0.479107  0.723792  0.976540  1.522255
2018-05-08  1.463182 -0.106349 -1.781704 -1.399375
2018-05-09  0.728835  0.768247  0.206403 -0.759910
2018-05-10  0.862932  0.025200 -0.246032  0.626610'''

c. 通过切片方式选择某些行

data = df[1:5:2]
print(data)
'''
                   A         B         C         D
2018-05-07  0.479107  0.723792  0.976540  1.522255
2018-05-09  0.728835  0.768247  0.206403 -0.759910'''

2、函数 loc + 标签获取数据

a. 通过行标签

data = df.loc['20180508']
print(data)
'''
A   -0.084551
B    0.666451
C    2.010399
D    0.121208
Name: 2018-05-08 00:00:00, dtype: float64'''

b. 通过列标签

data = df.loc[:, 'A':'C']
print(data)
'''
                   A         B         C
2018-05-06  0.268044 -2.011492  0.934763
2018-05-07  1.054199 -0.147792 -0.464180
2018-05-08 -0.132866  0.494600 -0.275043
2018-05-09  0.713573  1.727417 -0.121440
2018-05-10  0.479439  1.195971  2.710756
2018-05-11  0.374772 -0.800548  0.239096
2018-05-12 -1.009797  0.224585 -0.577983'''

c. 行标签＋列标签

# 行标签 ＋ 列标签
data = df.loc[dates[1:4], ['C','B']]
print(data)
'''
                   C         B
2018-05-07 -0.981423  1.515804
2018-05-08  2.010399  0.666451
2018-05-09 -0.541498 -0.760648'''

说明：loc函数，第一个参数为行标签，第二个是列标签；参数可以是标签数组

3、函数 iloc ＋索引获取数据

a. 通过行索引

data = df.iloc[2]
print(data)
'''
A   -0.118724
B    0.328970
C    0.748574
D    0.654055
Name: 2018-05-08 00:00:00, dtype: float64'''

b. 通过列索引

data = df.iloc[:, :3:2]
print(data)
'''
                   A         C
2018-05-06  0.548679 -0.420244
2018-05-07  0.028167 -0.878201
2018-05-08 -0.118724  0.748574
2018-05-09 -1.015111 -1.348442
2018-05-10 -0.226723  0.486991
2018-05-11 -0.553960 -0.485923
2018-05-12  1.044797 -0.158911'''

c. 通过行索引＋列索引

data = df.iloc[2:4, :2]
print(data)
'''
                   A         B
2018-05-08 -0.118724  0.328970
2018-05-09 -1.015111  0.239186'''

说明：参数可以是索引数组，如df.iloc[[1,3,4],[2,3]]

4、布尔索引：通过筛选条件

a. 某一列作为筛选条件

data = df[df.A>0]
print(data)
'''
                   A         B         C         D
2018-05-08  0.516235  3.104029 -1.670880 -0.437195
2018-05-11  0.974800 -2.326192 -0.281022 -0.476735'''

b. 所有数据筛选

data = df[df>0]
print(data)
'''
                   A         B         C         D
2018-05-06       NaN  0.805111       NaN  0.257760
2018-05-07       NaN  1.852752  0.154370       NaN
2018-05-08       NaN  1.023995       NaN  1.861297
2018-05-09  0.606395       NaN  0.650511  0.287029
2018-05-10  0.257984  0.632350  0.743557  0.548811
2018-05-11       NaN  0.986047       NaN  0.393672
2018-05-12  1.622094       NaN       NaN       NaN'''

c. isin() 筛选条件

如果想要通过是否存在某些对象来筛选，可以使用isin()函数来构建条件

首先我们为测试数据添加一条数据

df['E'] = ['jim', 'baobe', 'sam', 'tom', 'tonny', 'shilly', 'tom']

构建筛选条件筛选数据

data = df[df.E.isin(['sam','tom'])]
print(data)
'''
                   A         B         C         D    E
2018-05-08  1.821732  1.077904 -0.833458 -0.478336  sam
2018-05-09  0.106113  1.337638 -0.080521 -0.057544  tom
2018-05-12  0.252590  2.860070  1.128609  0.726241  tom'''

5、head() 和 tail() 函数

我们可以通过head() 和 tail() 函数从首部或者从尾部开始查看数据

a. 查看前2行数据

data = df.head(2)
print(data)
'''
                   A         B         C         D      E
2018-05-06 -1.287527  0.847162 -0.267924 -0.983046    jim
2018-05-07  1.449559  0.075858  1.514339 -0.796074  baobe'''

b. 查看后2行数据

data = df.tail(2)
print(data)
'''
                   A         B         C         D       E
2018-05-11 -0.082329 -1.738341  0.442104  0.798396  shilly
2018-05-12 -1.095280  0.091995 -1.044384 -0.090420     tom'''

排序

a. 索引排序，sort_index()

# 索引排序，axis：1:横向，0:竖向，ascending：True：升序，Flase：降序
df2 = df.sort_index(axis=0, ascending=False)
print(df2)
'''
                   A         B         C         D       E
2018-05-12 -1.172311  0.249176  0.619619  1.201507     tom
2018-05-11 -0.903955  0.479631 -0.963870  0.630743  shilly
2018-05-10  0.338365  2.306580 -0.283463  0.058125   tonny
2018-05-09  0.383475  0.676785  0.526411 -0.818025     tom
2018-05-08 -0.905796 -0.069078  0.073586  1.430755     sam
2018-05-07  0.294005  0.271840  0.428224  1.292046   baobe
2018-05-06  0.260828  0.618682 -1.491793  0.122746     jim
'''

b. 按值排序

df2 = df.sort_values(by='A', ascending=False)
print(df2)
'''
                   A         B         C         D       E
2018-05-10  1.575477  0.344951  0.733876  0.907723   tonny
2018-05-07  0.932946  0.780123 -0.414745  0.658090   baobe
2018-05-11  0.843189 -0.913189 -0.315761  0.660586  shilly
2018-05-08  0.160137 -1.695199  1.934444  0.084714     sam
2018-05-06 -0.293306 -1.162267  0.872631  1.044711     jim
2018-05-12 -0.645678 -0.482878  0.636781  0.217972     tom
2018-05-09 -1.554232 -0.304241  1.669206  1.139795     tom
'''

查看DataFrame的属性信息

index、columns、values、describe()

# 索引
print(df.index)
'''
DatetimeIndex(['2018-05-06', '2018-05-07', '2018-05-08', '2018-05-09',
               '2018-05-10', '2018-05-11', '2018-05-12'],
              dtype='datetime64[ns]', freq='D')
              '''

# 行
print(df.columns)
'''Index(['A', 'B', 'C', 'D', 'E'], dtype='object')'''

# 值
print(df.values)
'''
[[-0.0730245774443805 0.33905255249941385 2.5015746151296807
  -0.33123450303072904 'jim']
 [0.3790907350980047 -0.18159752603921003 0.9152898508787708
  -1.310437299063603 'baobe']
 [-1.0601500232526542 1.3286400269975474 1.0971376542803182
  1.5576173636367971 'sam']
 [1.0412081612316724 -0.4888964096447794 0.780175389471046
  -0.47686838058306735 'tom']
 [-0.10804989737868699 -0.8324112840144998 1.4111047235564484
  -0.48340663193714745 'tonny']
 [0.37660491844670085 0.45699643985409844 0.2527901594952756
  1.289500089112413 'shilly']
 [-0.8105633809548823 0.18592373788802305 0.5400829628974213
  -0.5655611250881947 'tom']]
  '''

# 一些统计信息
print(df.describe())
'''
              A         B         C         D
count  7.000000  7.000000  7.000000  7.000000
mean  -0.036412  0.115387  1.071165 -0.045770
std    0.725524  0.706560  0.732924  1.055322
min   -1.060150 -0.832411  0.252790 -1.310437
25%   -0.459307 -0.335247  0.660129 -0.524484
50%   -0.073025  0.185924  0.915290 -0.476868
75%    0.377848  0.398024  1.254121  0.479133
max    1.041208  1.328640  2.501575  1.557617
'''