You can run this notebook in a live session or view it on Github.

DataFrames: Read and Write Data¶

Dask Dataframes can read and store data in many of the same formats as Pandas dataframes. In this example we read and write data with the popular CSV and Parquet formats, and discuss best practices when using these formats.

In [1]:

from IPython.display import HTML

HTML('<iframe width="560" height="315" src="https://www.youtube.com/embed/0eEsIA0O1iE?rel=0&amp;controls=0&amp;showinfo=0" frameborder="0" allowfullscreen></iframe>')

/home/travis/miniconda/envs/test/lib/python3.6/site-packages/IPython/core/display.py:689: UserWarning: Consider using IPython.display.IFrame instead
  warnings.warn("Consider using IPython.display.IFrame instead")

Out[1]:

Start Dask Client for Dashboard¶

Starting the Dask Client is optional. It will provide a dashboard which is useful to gain insight on the computation.

The link to the dashboard will become visible when you create the client below. We recommend having it open on one side of your screen while using your notebook on the other side. This can take some effort to arrange your windows, but seeing them both at the same is very useful when learning.

In [2]:

from dask.distributed import Client
client = Client(n_workers=1, threads_per_worker=4, processes=False, memory_limit='2GB')
client

Out[2]:

Client

Scheduler: inproc://10.20.2.186/7482/1
Dashboard: http://localhost:8787/status

Cluster

Workers: 1
Cores: 4
Memory: 2.00 GB

Create artificial dataset¶

First we create an artificial dataset and write it to many CSV files.

You don’t need to understand this section, we’re just creating a dataset for the rest of the notebook.

In [3]:

import dask
df = dask.datasets.timeseries()
df

Out[3]:

Dask DataFrame Structure:

	id	name	x	y
npartitions=30
2000-01-01	int64	object	float64	float64
2000-01-02	...	...	...	...
...	...	...	...	...
2000-01-30	...	...	...	...
2000-01-31	...	...	...	...

Dask Name: make-timeseries, 30 tasks

In [4]:

import os
import datetime

if not os.path.exists('data'):
    os.mkdir('data')

def name(i):
    """ Provide date for filename given index

    Examples
    --------
    >>> name(0)
    '2000-01-01'
    >>> name(10)
    '2000-01-11'
    """
    return str(datetime.date(2000, 1, 1) + i * datetime.timedelta(days=1))

df.to_csv('data/*.csv', name_function=name);

Read CSV files¶

We now have many CSV files in our data directory, one for each day in the month of January 2000. Each CSV file holds timeseries data for that day. We can read all of them as one logical dataframe using the dd.read_csv function with a glob string.

In [5]:

!ls data/*.csv | head

data/2000-01-01.csv
data/2000-01-02.csv
data/2000-01-03.csv
data/2000-01-04.csv
data/2000-01-05.csv
data/2000-01-06.csv
data/2000-01-07.csv
data/2000-01-08.csv
data/2000-01-09.csv
data/2000-01-10.csv

In [6]:

!head data/2000-01-01.csv

timestamp,id,name,x,y
2000-01-01 00:00:00,994,Alice,-0.18965000428464318,0.40185901334900387
2000-01-01 00:00:01,997,Ray,-0.9878792900579152,0.7262983988729725
2000-01-01 00:00:02,994,Ray,0.49197195121379234,-0.31655436199318987
2000-01-01 00:00:03,968,Wendy,-0.2551931249290731,-0.5632693620347848
2000-01-01 00:00:04,1008,Ray,-0.15034571925999063,-0.1585889694378544
2000-01-01 00:00:05,1001,Yvonne,-0.4844970397302528,0.4767920873403344
2000-01-01 00:00:06,975,Norbert,0.33175511233673394,-0.7962492116062827
2000-01-01 00:00:07,1010,Ingrid,-0.15070203009234784,-0.08898373156661599
2000-01-01 00:00:08,956,Dan,0.5334017031973775,0.1328777374270096

In [7]:

!head data/2000-01-30.csv

timestamp,id,name,x,y
2000-01-30 00:00:00,1009,Ingrid,-0.8422015943655032,0.9328895152726109
2000-01-30 00:00:01,1006,Yvonne,-0.7858884103772514,-0.9217685141801719
2000-01-30 00:00:02,989,Charlie,-0.19912937651613816,0.41703079128786547
2000-01-30 00:00:03,967,Michael,0.44989586013333827,-0.3649415378035117
2000-01-30 00:00:04,1033,Jerry,0.9916278167944677,-0.12322569374086645
2000-01-30 00:00:05,987,George,0.8607627861590261,-0.14430554374870375
2000-01-30 00:00:06,993,Sarah,0.47241835966756063,0.05996545053573832
2000-01-30 00:00:07,996,Bob,0.6419598793054246,0.8285705471403713
2000-01-30 00:00:08,979,Wendy,-0.34907691583348255,0.7603009918203001

We can read one file with pandas.read_csv or many files with dask.dataframe.read_csv

In [8]:

import pandas as pd

df = pd.read_csv('data/2000-01-01.csv')
df.head()

Out[8]:

	timestamp	id	name	x	y
0	2000-01-01 00:00:00	994	Alice	-0.189650	0.401859
1	2000-01-01 00:00:01	997	Ray	-0.987879	0.726298
2	2000-01-01 00:00:02	994	Ray	0.491972	-0.316554
3	2000-01-01 00:00:03	968	Wendy	-0.255193	-0.563269
4	2000-01-01 00:00:04	1008	Ray	-0.150346	-0.158589

In [9]:

import dask.dataframe as dd

df = dd.read_csv('data/2000-*-*.csv')
df

Out[9]:

Dask DataFrame Structure:

	timestamp	id	name	x	y
npartitions=30
	object	int64	object	float64	float64
	...	...	...	...	...
...	...	...	...	...	...
	...	...	...	...	...
	...	...	...	...	...

Dask Name: from-delayed, 90 tasks

In [10]:

df.head()

Out[10]:

	timestamp	id	name	x	y
0	2000-01-01 00:00:00	994	Alice	-0.189650	0.401859
1	2000-01-01 00:00:01	997	Ray	-0.987879	0.726298
2	2000-01-01 00:00:02	994	Ray	0.491972	-0.316554
3	2000-01-01 00:00:03	968	Wendy	-0.255193	-0.563269
4	2000-01-01 00:00:04	1008	Ray	-0.150346	-0.158589

Tuning read_csv¶

The Pandas read_csv function has many options to help you parse files. The Dask version uses the Pandas function internally, and so supports many of the same options. You can use the ? operator to see the full documentation string.

In [11]:

pd.read_csv?

In [12]:

dd.read_csv?

In this case we use the parse_dates keyword to parse the timestamp column to be a datetime. This will make things more efficient in the future. Notice that the dtype of the timestamp column has changed from object to datetime64[ns].

In [13]:

df = dd.read_csv('data/2000-*-*.csv', parse_dates=['timestamp'])
df

Out[13]:

Dask DataFrame Structure:

	timestamp	id	name	x	y
npartitions=30
	datetime64[ns]	int64	object	float64	float64
	...	...	...	...	...
...	...	...	...	...	...
	...	...	...	...	...
	...	...	...	...	...

Dask Name: from-delayed, 90 tasks

Do a simple computation¶

Whenever we operate on our dataframe we read through all of our CSV data so that we don’t fill up RAM. This is very efficient for memory use, but reading through all of the CSV files every time can be slow.

In [14]:

%time df.groupby('name').x.mean().compute()

CPU times: user 7.65 s, sys: 556 ms, total: 8.2 s
Wall time: 5.6 s

Out[14]:

name
Alice      -0.000485
Bob         0.002645
Charlie     0.000763
Dan        -0.000220
Edith      -0.002685
Frank      -0.001568
George     -0.002056
Hannah      0.001327
Ingrid      0.000537
Jerry      -0.000760
Kevin       0.000860
Laura      -0.004510
Michael     0.000503
Norbert     0.001735
Oliver      0.000016
Patricia    0.002992
Quinn       0.001035
Ray         0.000823
Sarah      -0.001467
Tim        -0.000702
Ursula      0.002708
Victor     -0.000376
Wendy      -0.000234
Xavier     -0.000164
Yvonne     -0.002010
Zelda      -0.000736
Name: x, dtype: float64

In [15]:

Write to Parquet¶

Instead, we’ll store our data in Parquet, a format that is more efficient for computers to read and write.

In [15]:

df.to_parquet('data/2000-01.parquet', engine='pyarrow')

In [16]:

!ls data/2000-01.parquet/

_common_metadata  part.16.parquet  part.23.parquet  part.3.parquet
part.0.parquet    part.17.parquet  part.24.parquet  part.4.parquet
part.10.parquet   part.18.parquet  part.25.parquet  part.5.parquet
part.11.parquet   part.19.parquet  part.26.parquet  part.6.parquet
part.12.parquet   part.1.parquet   part.27.parquet  part.7.parquet
part.13.parquet   part.20.parquet  part.28.parquet  part.8.parquet
part.14.parquet   part.21.parquet  part.29.parquet  part.9.parquet
part.15.parquet   part.22.parquet  part.2.parquet

Read from Parquet¶

In [17]:

df = dd.read_parquet('data/2000-01.parquet', engine='pyarrow')
df

Out[17]:

Dask DataFrame Structure:

	timestamp	id	name	x	y
npartitions=30
	datetime64[ns]	int64	object	float64	float64
	...	...	...	...	...
...	...	...	...	...	...
	...	...	...	...	...
	...	...	...	...	...

Dask Name: read-parquet, 30 tasks

In [18]:

%time df.groupby('name').x.mean().compute()

CPU times: user 1.67 s, sys: 328 ms, total: 2 s
Wall time: 1.41 s

Out[18]:

name
Alice      -0.000485
Bob         0.002645
Charlie     0.000763
Dan        -0.000220
Edith      -0.002685
Frank      -0.001568
George     -0.002056
Hannah      0.001327
Ingrid      0.000537
Jerry      -0.000760
Kevin       0.000860
Laura      -0.004510
Michael     0.000503
Norbert     0.001735
Oliver      0.000016
Patricia    0.002992
Quinn       0.001035
Ray         0.000823
Sarah      -0.001467
Tim        -0.000702
Ursula      0.002708
Victor     -0.000376
Wendy      -0.000234
Xavier     -0.000164
Yvonne     -0.002010
Zelda      -0.000736
Name: x, dtype: float64

Select only the columns that you plan to use¶

Parquet is a column-store, which means that it can efficiently pull out only a few columns from your dataset. This is good because it helps to avoid unnecessary data loading.

In [19]:

%%time
df = dd.read_parquet('data/2000-01.parquet', columns=['name', 'x'], engine='pyarrow')
df.groupby('name').x.mean().compute()

CPU times: user 1.56 s, sys: 224 ms, total: 1.79 s
Wall time: 1.33 s

Here the difference is not that large, but with larger datasets this can save a great deal of time.

Learn more¶

http://dask.pydata.org/en/latest/dataframe-create.html