10 分钟入门 Mars DataFrame#
本页面是一个对 Mars DataFrame 的简短介绍，内容修改自 10 分钟入门 pandas 。
如果没有说明，我们默认导入下面的包：
In [1]: import mars
In [2]: import mars.tensor as mt
In [3]: import mars.dataframe as md
Now create a new default session.
In [4]: mars.new_session()
Out[4]: <mars.deploy.oscar.session.SyncSession at 0x7fcef52ca250>
创建对象#
通过传入一个包含值的 list 来创建 Series 实例，并使用默认的整数索引：
In [5]: s = md.Series([1, 3, 5, mt.nan, 6, 8])
In [6]: s.execute()
Out[6]:
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64
通过一个 Mars Tensor 来创建 DataFrame 实例，并使用时间日期索引和列标签：
In [7]: dates = md.date_range('20130101', periods=6)
In [8]: dates.execute()
Out[8]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'],
dtype='datetime64[ns]', freq='D')
In [9]: df = md.DataFrame(mt.random.randn(6, 4), index=dates, columns=list('ABCD'))
In [10]: df.execute()
Out[10]:
A B C D
2013-01-01 -0.347952 -0.284136 2.050235 -0.677082
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
2013-01-04 -1.565335 1.142683 0.002600 -2.853052
2013-01-05 0.207287 0.511100 0.232881 0.125601
2013-01-06 0.662122 -1.714874 -0.011835 -0.407454
通过值可转换为序列的字典来创建 DataFrame 实例：
In [11]: df2 = md.DataFrame({'A': 1.,
....: 'B': md.Timestamp('20130102'),
....: 'C': md.Series(1, index=list(range(4)), dtype='float32'),
....: 'D': mt.array([3] * 4, dtype='int32'),
....: 'E': 'foo'})
....:
In [12]: df2.execute()
Out[12]:
A B C D E
0 1.0 2013-01-02 1.0 3 foo
1 1.0 2013-01-02 1.0 3 foo
2 1.0 2013-01-02 1.0 3 foo
3 1.0 2013-01-02 1.0 3 foo
最终生成的 DataFrame 中，每列的类型均不相同。
In [13]: df2.dtypes
Out[13]:
A float64
B datetime64[ns]
C float32
D int32
E object
dtype: object
查看数据#
下面是显示 DataFrame 中开头和结尾若干行的方法：
In [14]: df.head().execute()
Out[14]:
A B C D
2013-01-01 -0.347952 -0.284136 2.050235 -0.677082
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
2013-01-04 -1.565335 1.142683 0.002600 -2.853052
2013-01-05 0.207287 0.511100 0.232881 0.125601
In [15]: df.tail(3).execute()
Out[15]:
A B C D
2013-01-04 -1.565335 1.142683 0.002600 -2.853052
2013-01-05 0.207287 0.511100 0.232881 0.125601
2013-01-06 0.662122 -1.714874 -0.011835 -0.407454
显示索引和列：
In [16]: df.index.execute()
Out[16]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'],
dtype='datetime64[ns]', freq='D')
In [17]: df.columns.execute()
Out[17]: Index(['A', 'B', 'C', 'D'], dtype='object')
DataFrame.to_tensor() 将 DataFrame 中的数据转换为 Mars Tensor 表示。注意当 DataFrame 中的列类型不同时，该操作可能代价很高。这也揭示了 DataFrame 和 Tensor 之间一项最基本的差异：在 Tensor 中，对于整个 Tensor 对象只有一个 dtype，但 DataFrame 对每列都有一个 dtype。当调用 DataFrame.to_tensor() 时，Mars DataFrame 将会找出一个可存储 DataFrame 中 所有 对象的 dtype，这可能是一个 object，并将导致 DataFrame 中的每个值都被转换为一个 Python 对象。
在上面的 df 对象中，DataFrame 实例中的值均为浮点数，因而 DataFrame.to_tensor() 执行速度会很快，且不需要数据复制。
In [18]: df.to_tensor().execute()
Out[18]:
array([[-3.47952173e-01, -2.84136166e-01, 2.05023518e+00,
-6.77081832e-01],
[ 6.32981520e-01, -3.92973464e-01, 1.08252175e+00,
1.84517167e+00],
[-5.49196555e-01, -8.45192965e-02, -2.53009885e+00,
-2.19418847e+00],
[-1.56533533e+00, 1.14268269e+00, 2.59958147e-03,
-2.85305202e+00],
[ 2.07287200e-01, 5.11100344e-01, 2.32881418e-01,
1.25601332e-01],
[ 6.62122421e-01, -1.71487362e+00, -1.18354954e-02,
-4.07454051e-01]])
而对于 df2 对象，DataFrame 实例中有不同的数据类型，因而 DataFrame.to_tensor() 执行代价就相对较高了。
In [19]: df2.to_tensor().execute()
Out[19]:
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'foo']],
dtype=object)
备注
DataFrame.to_tensor() 在输出结果中 不保留 索引或列标签。
describe() 将会为你的数据显示一份简单的统计摘要：
In [20]: df.describe().execute()
Out[20]:
A B C D
count 6.000000 6.000000 6.000000 6.000000
mean -0.160015 -0.137120 0.137717 -0.693501
std 0.848690 0.963040 1.530837 1.680095
min -1.565335 -1.714874 -2.530099 -2.853052
25% -0.498885 -0.365764 -0.008227 -1.814912
50% -0.070332 -0.184328 0.117740 -0.542268
75% 0.526558 0.362195 0.870112 -0.007663
max 0.662122 1.142683 2.050235 1.845172
按坐标排序：
In [21]: df.sort_index(axis=1, ascending=False).execute()
Out[21]:
D C B A
2013-01-01 -0.677082 2.050235 -0.284136 -0.347952
2013-01-02 1.845172 1.082522 -0.392973 0.632982
2013-01-03 -2.194188 -2.530099 -0.084519 -0.549197
2013-01-04 -2.853052 0.002600 1.142683 -1.565335
2013-01-05 0.125601 0.232881 0.511100 0.207287
2013-01-06 -0.407454 -0.011835 -1.714874 0.662122
按值排序：
In [22]: df.sort_values(by='B').execute()
Out[22]:
A B C D
2013-01-06 0.662122 -1.714874 -0.011835 -0.407454
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-01 -0.347952 -0.284136 2.050235 -0.677082
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
2013-01-05 0.207287 0.511100 0.232881 0.125601
2013-01-04 -1.565335 1.142683 0.002600 -2.853052
选择数据#
备注
尽管在交互式分析场景下，使用标准的 Python / Numpy 表达式选择和设置 DataFrame 数据非常自然且便于使用，但对生产代码，我们推荐使用经过优化的数据访问方法，即 .at、.iat、.loc 和 .iloc。
获取数据#
选择一列，将返回一个 Series 实例。这一操作等价于 df.A ：
In [23]: df['A'].execute()
Out[23]:
2013-01-01 -0.347952
2013-01-02 0.632982
2013-01-03 -0.549197
2013-01-04 -1.565335
2013-01-05 0.207287
2013-01-06 0.662122
Freq: D, Name: A, dtype: float64
通过 [] 选择数据，将在行中选取。
In [24]: df[0:3].execute()
Out[24]:
A B C D
2013-01-01 -0.347952 -0.284136 2.050235 -0.677082
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
In [25]: df['20130102':'20130104'].execute()
Out[25]:
A B C D
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
2013-01-04 -1.565335 1.142683 0.002600 -2.853052
按标签选择数据#
通过行标签选择一行数据：
In [26]: df.loc['20130101'].execute()
Out[26]:
A -0.347952
B -0.284136
C 2.050235
D -0.677082
Name: 2013-01-01 00:00:00, dtype: float64
在特定坐标上指定标签：
In [27]: df.loc[:, ['A', 'B']].execute()
Out[27]:
A B
2013-01-01 -0.347952 -0.284136
2013-01-02 0.632982 -0.392973
2013-01-03 -0.549197 -0.084519
2013-01-04 -1.565335 1.142683
2013-01-05 0.207287 0.511100
2013-01-06 0.662122 -1.714874
在多个坐标上指定标签，带有这些标签的 所有数据 均会被选取：
In [28]: df.loc['20130102':'20130104', ['A', 'B']].execute()
Out[28]:
A B
2013-01-02 0.632982 -0.392973
2013-01-03 -0.549197 -0.084519
2013-01-04 -1.565335 1.142683
在特定坐标上降低返回对象的维度：
In [29]: df.loc['20130102', ['A', 'B']].execute()
Out[29]:
A 0.632982
B -0.392973
Name: 2013-01-02 00:00:00, dtype: float64
获得一个常量：
In [30]: df.loc['20130101', 'A'].execute()
Out[30]: -0.34795217258891187
快速获取一个常数（和前述方法等价）：
In [31]: df.at['20130101', 'A'].execute()
Out[31]: -0.34795217258891187
按位置选择#
通过传入的整数选择相应位置的数据：
In [32]: df.iloc[3].execute()
Out[32]:
A -1.565335
B 1.142683
C 0.002600
D -2.853052
Name: 2013-01-04 00:00:00, dtype: float64
通过整数切片来选择数据，与 Numpy / Python 行为一致：
In [33]: df.iloc[3:5, 0:2].execute()
Out[33]:
A B
2013-01-04 -1.565335 1.142683
2013-01-05 0.207287 0.511100
通过整数列表选择相应位置的数据，与 Numpy / Python 行为一致：
In [34]: df.iloc[[1, 2, 4], [0, 2]].execute()
Out[34]:
A C
2013-01-02 0.632982 1.082522
2013-01-03 -0.549197 -2.530099
2013-01-05 0.207287 0.232881
显示对行切片：
In [35]: df.iloc[1:3, :].execute()
Out[35]:
A B C D
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-03 -0.549197 -0.084519 -2.530099 -2.194188
显示对列切片：
In [36]: df.iloc[:, 1:3].execute()
Out[36]:
B C
2013-01-01 -0.284136 2.050235
2013-01-02 -0.392973 1.082522
2013-01-03 -0.084519 -2.530099
2013-01-04 1.142683 0.002600
2013-01-05 0.511100 0.232881
2013-01-06 -1.714874 -0.011835
显示获取某个位置的常数：
In [37]: df.iloc[1, 1].execute()
Out[37]: -0.3929734640856764
快速获取一个常数（和前述方法等价）：
In [38]: df.iat[1, 1].execute()
Out[38]: -0.3929734640856764
布尔索引#
使用一行布尔值选择数据：
In [39]: df[df['A'] > 0].execute()
Out[39]:
A B C D
2013-01-02 0.632982 -0.392973 1.082522 1.845172
2013-01-05 0.207287 0.511100 0.232881 0.125601
2013-01-06 0.662122 -1.714874 -0.011835 -0.407454
从 DataFrame 选择满足某个布尔条件的值：
In [40]: df[df > 0].execute()
Out[40]:
A B C D
2013-01-01 NaN NaN 2.050235 NaN
2013-01-02 0.632982 NaN 1.082522 1.845172
2013-01-03 NaN NaN NaN NaN
2013-01-04 NaN 1.142683 0.002600 NaN
2013-01-05 0.207287 0.511100 0.232881 0.125601
2013-01-06 0.662122 NaN NaN NaN
数据操作#
统计#
除缺失值外的常见操作：
计算描述统计值：
In [41]: df.mean().execute()
Out[41]:
A -0.160015
B -0.137120
C 0.137717
D -0.693501
dtype: float64
在另一条坐标轴上进行相同的操作：
In [42]: df.mean(1).execute()
Out[42]:
2013-01-01 0.185266
2013-01-02 0.791925
2013-01-03 -1.339501
2013-01-04 -0.818276
2013-01-05 0.269218
2013-01-06 -0.368010
Freq: D, dtype: float64
在维度不同的对象上进行操作，这需要进行对齐。此外，Mars DataFrame 会自动在给定的坐标轴上对数据进行广播操作。
In [43]: s = md.Series([1, 3, 5, mt.nan, 6, 8], index=dates).shift(2)
In [44]: s.execute()
Out[44]:
2013-01-01 NaN
2013-01-02 NaN
2013-01-03 1.0
2013-01-04 3.0
2013-01-05 5.0
2013-01-06 NaN
Freq: D, dtype: float64
In [45]: df.sub(s, axis='index').execute()
Out[45]:
A B C D
2013-01-01 NaN NaN NaN NaN
2013-01-02 NaN NaN NaN NaN
2013-01-03 -1.549197 -1.084519 -3.530099 -3.194188
2013-01-04 -4.565335 -1.857317 -2.997400 -5.853052
2013-01-05 -4.792713 -4.488900 -4.767119 -4.874399
2013-01-06 NaN NaN NaN NaN
应用函数#
在数据上应用函数：
In [46]: df.apply(lambda x: x.max() - x.min()).execute()
Out[46]:
A 2.227458
B 2.857556
C 4.580334
D 4.698224
dtype: float64
字符串方法#
如同下面的例子展示的那样，Series 对象通过 str 属性提供了一系列字符串操作方法以便于操作每一个元素。注意通过 str 进行的模式匹配通常会默认（在某些情形下会一直）用到 正则表达式 。更多的信息可在 向量化字符串方法 中查看。
In [47]: s = md.Series(['A', 'B', 'C', 'Aaba', 'Baca', mt.nan, 'CABA', 'dog', 'cat'])
In [48]: s.str.lower().execute()
Out[48]:
0 a
1 b
2 c
3 aaba
4 baca
5 NaN
6 caba
7 dog
8 cat
dtype: object
数据合并#
拼接#
Mars DataFrame 提供一系列的方法方便地将 Series 和 DataFrame 对象连接到一起。这些方法基于一系列在索引上的集合逻辑以及关系代数上的功能来实现 Join / 合并这样的操作。
通过 concat(): 拼接 DataFrame 对象：
In [49]: df = md.DataFrame(mt.random.randn(10, 4))
In [50]: df.execute()
Out[50]:
0 1 2 3
0 -1.396295 0.781454 0.955552 0.752733
1 -1.293398 -0.378893 -0.438218 -0.703153
2 0.298174 0.303068 -1.182341 0.871465
3 -1.046251 -1.822435 -0.092565 -0.285036
4 0.976723 0.470151 0.022455 -0.386167
5 1.614889 -0.471205 -0.425416 -1.077311
6 0.607132 -0.050254 -1.597734 -0.695528
7 -0.122293 0.483638 0.568422 -0.250431
8 -0.187512 1.705195 0.582557 -1.141696
9 0.377351 -1.300661 -2.446026 -0.233203
# break it into pieces
In [51]: pieces = [df[:3], df[3:7], df[7:]]
In [52]: md.concat(pieces).execute()
Out[52]:
0 1 2 3
0 -1.396295 0.781454 0.955552 0.752733
1 -1.293398 -0.378893 -0.438218 -0.703153
2 0.298174 0.303068 -1.182341 0.871465
3 -1.046251 -1.822435 -0.092565 -0.285036
4 0.976723 0.470151 0.022455 -0.386167
5 1.614889 -0.471205 -0.425416 -1.077311
6 0.607132 -0.050254 -1.597734 -0.695528
7 -0.122293 0.483638 0.568422 -0.250431
8 -0.187512 1.705195 0.582557 -1.141696
9 0.377351 -1.300661 -2.446026 -0.233203
Join#
SQL 样式的数据合并。参考 Database style joining 章节以获取更多信息。
In [53]: left = md.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
In [54]: right = md.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
In [55]: left.execute()
Out[55]:
key lval
0 foo 1
1 foo 2
In [56]: right.execute()
Out[56]:
key rval
0 foo 4
1 foo 5
In [57]: md.merge(left, right, on='key').execute()
Out[57]:
key lval rval
0 foo 1 4
1 foo 1 5
2 foo 2 4
3 foo 2 5
另一个可供参考的例子如下：
In [58]: left = md.DataFrame({'key': ['foo', 'bar'], 'lval': [1, 2]})
In [59]: right = md.DataFrame({'key': ['foo', 'bar'], 'rval': [4, 5]})
In [60]: left.execute()
Out[60]:
key lval
0 foo 1
1 bar 2
In [61]: right.execute()
Out[61]:
key rval
0 foo 4
1 bar 5
In [62]: md.merge(left, right, on='key').execute()
Out[62]:
key lval rval
0 foo 1 4
1 bar 2 5
分组#
当提到“分组”时，我们指的是下面一个或多个步骤组成的过程：
拆分 ：根据某些条件将数据拆分成组
应用函数 ：对每一组数据分别应用某个函数
合并 ：将结果合并为一组数据
In [63]: df = md.DataFrame({'A': ['foo', 'bar', 'foo', 'bar',
....: 'foo', 'bar', 'foo', 'foo'],
....: 'B': ['one', 'one', 'two', 'three',
....: 'two', 'two', 'one', 'three'],
....: 'C': mt.random.randn(8),
....: 'D': mt.random.randn(8)})
....:
In [64]: df.execute()
Out[64]:
A B C D
0 foo one 0.083169 1.758496
1 bar one 1.509185 0.661700
2 foo two 1.555205 0.540139
3 bar three 0.939691 0.585837
4 foo two 0.780735 -0.210219
5 bar two -0.802737 1.366606
6 foo one -1.075537 -0.345651
7 foo three -0.339739 -0.620319
分组，然后在结果上执行 sum() 函数。
In [65]: df.groupby('A').sum().execute()
Out[65]:
C D
A
bar 1.646139 2.614144
foo 1.003831 1.122446
我们也可以利用多列进行分组，这将形成一个多重索引。在此结果上，我们也可以执行 sum 函数。
In [66]: df.groupby(['A', 'B']).sum().execute()
Out[66]:
C D
A B
bar one 1.509185 0.661700
three 0.939691 0.585837
two -0.802737 1.366606
foo one -0.992369 1.412845
three -0.339739 -0.620319
two 2.335940 0.329920
绘图#
我们使用标准的约定来引用 matplotlib API：
In [67]: import matplotlib.pyplot as plt
In [68]: plt.close('all')
In [69]: ts = md.Series(mt.random.randn(1000),
....: index=md.date_range('1/1/2000', periods=1000))
....:
In [70]: ts = ts.cumsum()
In [71]: ts.plot()
Out[71]: <AxesSubplot:>
在 DataFrame 中， plot() 方法可用于方便地绘制带有标签的行数据：
In [72]: df = md.DataFrame(mt.random.randn(1000, 4), index=ts.index,
....: columns=['A', 'B', 'C', 'D'])
....:
In [73]: df = df.cumsum()
In [74]: plt.figure()
Out[74]: <Figure size 640x480 with 0 Axes>
In [75]: df.plot()
Out[75]: <AxesSubplot:>
In [76]: plt.legend(loc='best')
Out[76]: <matplotlib.legend.Legend at 0x7fcef5550350>
读取和写入数据#
CSV#
In [77]: df.to_csv('foo.csv').execute()
Out[77]:
Empty DataFrame
Columns: []
Index: []
In [78]: md.read_csv('foo.csv').execute()
Out[78]:
Unnamed: 0 A B C D
0 2000-01-01 0.049806 -0.699455 0.884895 0.438589
1 2000-01-02 0.043312 0.982661 1.527829 0.306649
2 2000-01-03 -0.651330 2.059194 1.026540 0.520481
3 2000-01-04 -1.698988 2.609883 -0.222185 0.815308
4 2000-01-05 -1.455526 2.662236 0.483316 0.058976
.. ... ... ... ... ...
995 2002-09-22 -15.642899 28.673881 -32.973127 -50.108901
996 2002-09-23 -15.415202 28.358966 -32.475941 -49.171250
997 2002-09-24 -16.535211 29.236033 -32.225691 -47.905113
998 2002-09-25 -16.337957 30.018430 -31.373268 -48.151713
999 2002-09-26 -17.427032 30.803276 -30.281811 -47.607642
[1000 rows x 5 columns]