Merge, join, and concatenate¶
pandas provides various facilities for easily combining together Series, DataFrame, and Panel objects with various kinds of set logic for the indexes and relational algebra functionality in the case of join / merge-type operations.
Concatenating objects¶
The concat()
function (in the main pandas namespace) does all of
the heavy lifting of performing concatenation operations along an axis while
performing optional set logic (union or intersection) of the indexes (if any) on
the other axes. Note that I say “if any” because there is only a single possible
axis of concatenation for Series.
Before diving into all of the details of concat
and what it can do, here is
a simple example:
In [1]: df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
...: 'B': ['B0', 'B1', 'B2', 'B3'],
...: 'C': ['C0', 'C1', 'C2', 'C3'],
...: 'D': ['D0', 'D1', 'D2', 'D3']},
...: index=[0, 1, 2, 3])
...:
In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
...: 'B': ['B4', 'B5', 'B6', 'B7'],
...: 'C': ['C4', 'C5', 'C6', 'C7'],
...: 'D': ['D4', 'D5', 'D6', 'D7']},
...: index=[4, 5, 6, 7])
...:
In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
...: 'B': ['B8', 'B9', 'B10', 'B11'],
...: 'C': ['C8', 'C9', 'C10', 'C11'],
...: 'D': ['D8', 'D9', 'D10', 'D11']},
...: index=[8, 9, 10, 11])
...:
In [4]: frames = [df1, df2, df3]
In [5]: result = pd.concat(frames)
Like its sibling function on ndarrays, numpy.concatenate
, pandas.concat
takes a list or dict of homogeneously-typed objects and concatenates them with
some configurable handling of “what to do with the other axes”:
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
copy=True)
objs
: a sequence or mapping of Series, DataFrame, or Panel objects. If a dict is passed, the sorted keys will be used as the keys argument, unless it is passed, in which case the values will be selected (see below). Any None objects will be dropped silently unless they are all None in which case a ValueError will be raised.axis
: {0, 1, …}, default 0. The axis to concatenate along.join
: {‘inner’, ‘outer’}, default ‘outer’. How to handle indexes on other axis(es). Outer for union and inner for intersection.ignore_index
: boolean, default False. If True, do not use the index values on the concatenation axis. The resulting axis will be labeled 0, …, n - 1. This is useful if you are concatenating objects where the concatenation axis does not have meaningful indexing information. Note the index values on the other axes are still respected in the join.join_axes
: list of Index objects. Specific indexes to use for the other n - 1 axes instead of performing inner/outer set logic.keys
: sequence, default None. Construct hierarchical index using the passed keys as the outermost level. If multiple levels passed, should contain tuples.levels
: list of sequences, default None. Specific levels (unique values) to use for constructing a MultiIndex. Otherwise they will be inferred from the keys.names
: list, default None. Names for the levels in the resulting hierarchical index.verify_integrity
: boolean, default False. Check whether the new concatenated axis contains duplicates. This can be very expensive relative to the actual data concatenation.copy
: boolean, default True. If False, do not copy data unnecessarily.
Without a little bit of context many of these arguments don’t make much sense.
Let’s revisit the above example. Suppose we wanted to associate specific keys
with each of the pieces of the chopped up DataFrame. We can do this using the
keys
argument:
In [6]: result = pd.concat(frames, keys=['x', 'y', 'z'])
As you can see (if you’ve read the rest of the documentation), the resulting object’s index has a hierarchical index. This means that we can now select out each chunk by key:
In [7]: result.loc['y']
Out[7]:
A B C D
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
It’s not a stretch to see how this can be very useful. More detail on this functionality below.
Note
It is worth noting that concat()
(and therefore
append()
) makes a full copy of the data, and that constantly
reusing this function can create a significant performance hit. If you need
to use the operation over several datasets, use a list comprehension.
frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)
Set logic on the other axes¶
When gluing together multiple DataFrames, you have a choice of how to handle the other axes (other than the one being concatenated). This can be done in the following three ways:
- Take the union of them all,
join='outer'
. This is the default option as it results in zero information loss. - Take the intersection,
join='inner'
. - Use a specific index, as passed to the
join_axes
argument.
Here is an example of each of these methods. First, the default join='outer'
behavior:
In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
...: 'D': ['D2', 'D3', 'D6', 'D7'],
...: 'F': ['F2', 'F3', 'F6', 'F7']},
...: index=[2, 3, 6, 7])
...:
In [9]: result = pd.concat([df1, df4], axis=1, sort=False)
Warning
Changed in version 0.23.0.
The default behavior with join='outer'
is to sort the other axis
(columns in this case). In a future version of pandas, the default will
be to not sort. We specified sort=False
to opt in to the new
behavior now.
Here is the same thing with join='inner'
:
In [10]: result = pd.concat([df1, df4], axis=1, join='inner')
Lastly, suppose we just wanted to reuse the exact index from the original DataFrame:
In [11]: result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
Concatenating using append
¶
A useful shortcut to concat()
are the append()
instance methods on Series
and DataFrame
. These methods actually predated
concat
. They concatenate along axis=0
, namely the index:
In [12]: result = df1.append(df2)
In the case of DataFrame
, the indexes must be disjoint but the columns do not
need to be:
In [13]: result = df1.append(df4)
append
may take multiple objects to concatenate:
In [14]: result = df1.append([df2, df3])
Note
Unlike the append()
method, which appends to the original list
and returns None
, append()
here does not modify
df1
and returns its copy with df2
appended.
Ignoring indexes on the concatenation axis¶
For DataFrame
s which don’t have a meaningful index, you may wish to append
them and ignore the fact that they may have overlapping indexes. To do this, use
the ignore_index
argument:
In [15]: result = pd.concat([df1, df4], ignore_index=True)
This is also a valid argument to DataFrame.append()
:
In [16]: result = df1.append(df4, ignore_index=True)
Concatenating with mixed ndims¶
You can concatenate a mix of Series
and DataFrame
s. The
Series
will be transformed to DataFrame
with the column name as
the name of the Series
.
In [17]: s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')
In [18]: result = pd.concat([df1, s1], axis=1)
Note
Since we’re concatenating a Series
to a DataFrame
, we could have
achieved the same result with DataFrame.assign()
. To concatenate an
arbitrary number of pandas objects (DataFrame
or Series
), use
concat
.
If unnamed Series
are passed they will be numbered consecutively.
In [19]: s2 = pd.Series(['_0', '_1', '_2', '_3'])
In [20]: result = pd.concat([df1, s2, s2, s2], axis=1)
Passing ignore_index=True
will drop all name references.
In [21]: result = pd.concat([df1, s1], axis=1, ignore_index=True)
More concatenating with group keys¶
A fairly common use of the keys
argument is to override the column names
when creating a new DataFrame
based on existing Series
.
Notice how the default behaviour consists on letting the resulting DataFrame
inherit the parent Series
’ name, when these existed.
In [22]: s3 = pd.Series([0, 1, 2, 3], name='foo')
In [23]: s4 = pd.Series([0, 1, 2, 3])
In [24]: s5 = pd.Series([0, 1, 4, 5])
In [25]: pd.concat([s3, s4, s5], axis=1)
Out[25]:
foo 0 1
0 0 0 0
1 1 1 1
2 2 2 4
3 3 3 5
Through the keys
argument we can override the existing column names.
In [26]: pd.concat([s3, s4, s5], axis=1, keys=['red','blue','yellow'])
Out[26]:
red blue yellow
0 0 0 0
1 1 1 1
2 2 2 4
3 3 3 5
Let’s consider a variation of the very first example presented:
In [27]: result = pd.concat(frames, keys=['x', 'y', 'z'])
You can also pass a dict to concat
in which case the dict keys will be used
for the keys
argument (unless other keys are specified):
In [28]: pieces = {'x': df1, 'y': df2, 'z': df3}
In [29]: result = pd.concat(pieces)
In [30]: result = pd.concat(pieces, keys=['z', 'y'])
The MultiIndex created has levels that are constructed from the passed keys and
the index of the DataFrame
pieces:
In [31]: result.index.levels
Out[31]: FrozenList([['z', 'y'], [4, 5, 6, 7, 8, 9, 10, 11]])
If you wish to specify other levels (as will occasionally be the case), you can
do so using the levels
argument:
In [32]: result = pd.concat(pieces, keys=['x', 'y', 'z'],
....: levels=[['z', 'y', 'x', 'w']],
....: names=['group_key'])
....:
In [33]: result.index.levels
Out[33]: FrozenList([['z', 'y', 'x', 'w'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])
This is fairly esoteric, but it is actually necessary for implementing things like GroupBy where the order of a categorical variable is meaningful.
Appending rows to a DataFrame¶
While not especially efficient (since a new object must be created), you can
append a single row to a DataFrame
by passing a Series
or dict to
append
, which returns a new DataFrame
as above.
In [34]: s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])
In [35]: result = df1.append(s2, ignore_index=True)
You should use ignore_index
with this method to instruct DataFrame to
discard its index. If you wish to preserve the index, you should construct an
appropriately-indexed DataFrame and append or concatenate those objects.
You can also pass a list of dicts or Series:
In [36]: dicts = [{'A': 1, 'B': 2, 'C': 3, 'X': 4},
....: {'A': 5, 'B': 6, 'C': 7, 'Y': 8}]
....:
In [37]: result = df1.append(dicts, ignore_index=True)
Database-style DataFrame joining/merging¶
pandas has full-featured, high performance in-memory join operations
idiomatically very similar to relational databases like SQL. These methods
perform significantly better (in some cases well over an order of magnitude
better) than other open source implementations (like base::merge.data.frame
in R). The reason for this is careful algorithmic design and the internal layout
of the data in DataFrame
.
See the cookbook for some advanced strategies.
Users who are familiar with SQL but new to pandas might be interested in a comparison with SQL.
pandas provides a single function, merge()
, as the entry point for
all standard database join operations between DataFrame
objects:
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False,
validate=None)
left
: A DataFrame object.right
: Another DataFrame object.on
: Column or index level names to join on. Must be found in both the left and right DataFrame objects. If not passed andleft_index
andright_index
areFalse
, the intersection of the columns in the DataFrames will be inferred to be the join keys.left_on
: Columns or index levels from the left DataFrame to use as keys. Can either be column names, index level names, or arrays with length equal to the length of the DataFrame.right_on
: Columns or index levels from the right DataFrame to use as keys. Can either be column names, index level names, or arrays with length equal to the length of the DataFrame.left_index
: IfTrue
, use the index (row labels) from the left DataFrame as its join key(s). In the case of a DataFrame with a MultiIndex (hierarchical), the number of levels must match the number of join keys from the right DataFrame.right_index
: Same usage asleft_index
for the right DataFramehow
: One of'left'
,'right'
,'outer'
,'inner'
. Defaults toinner
. See below for more detailed description of each method.sort
: Sort the result DataFrame by the join keys in lexicographical order. Defaults toTrue
, setting toFalse
will improve performance substantially in many cases.suffixes
: A tuple of string suffixes to apply to overlapping columns. Defaults to('_x', '_y')
.copy
: Always copy data (defaultTrue
) from the passed DataFrame objects, even when reindexing is not necessary. Cannot be avoided in many cases but may improve performance / memory usage. The cases where copying can be avoided are somewhat pathological but this option is provided nonetheless.indicator
: Add a column to the output DataFrame called_merge
with information on the source of each row._merge
is Categorical-type and takes on a value ofleft_only
for observations whose merge key only appears in'left'
DataFrame,right_only
for observations whose merge key only appears in'right'
DataFrame, andboth
if the observation’s merge key is found in both.validate
: string, default None. If specified, checks if merge is of specified type.- “one_to_one” or “1:1”: checks if merge keys are unique in both left and right datasets.
- “one_to_many” or “1:m”: checks if merge keys are unique in left dataset.
- “many_to_one” or “m:1”: checks if merge keys are unique in right dataset.
- “many_to_many” or “m:m”: allowed, but does not result in checks.
New in version 0.21.0.
Note
Support for specifying index levels as the on
, left_on
, and
right_on
parameters was added in version 0.23.0.
The return type will be the same as left
. If left
is a DataFrame
and right
is a subclass of DataFrame, the return type will still be
DataFrame
.
merge
is a function in the pandas namespace, and it is also available as a
DataFrame
instance method merge()
, with the calling
DataFrame
being implicitly considered the left object in the join.
The related join()
method, uses merge
internally for the
index-on-index (by default) and column(s)-on-index join. If you are joining on
index only, you may wish to use DataFrame.join
to save yourself some typing.
Brief primer on merge methods (relational algebra)¶
Experienced users of relational databases like SQL will be familiar with the
terminology used to describe join operations between two SQL-table like
structures (DataFrame
objects). There are several cases to consider which
are very important to understand:
- one-to-one joins: for example when joining two
DataFrame
objects on their indexes (which must contain unique values). - many-to-one joins: for example when joining an index (unique) to one or
more columns in a different
DataFrame
. - many-to-many joins: joining columns on columns.
Note
When joining columns on columns (potentially a many-to-many join), any
indexes on the passed DataFrame
objects will be discarded.
It is worth spending some time understanding the result of the many-to-many join case. In SQL / standard relational algebra, if a key combination appears more than once in both tables, the resulting table will have the Cartesian product of the associated data. Here is a very basic example with one unique key combination:
In [38]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
....: 'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3']})
....:
In [39]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
....: 'C': ['C0', 'C1', 'C2', 'C3'],
....: 'D': ['D0', 'D1', 'D2', 'D3']})
....:
In [40]: result = pd.merge(left, right, on='key')
Here is a more complicated example with multiple join keys. Only the keys
appearing in left
and right
are present (the intersection), since
how='inner'
by default.
In [41]: left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
....: 'key2': ['K0', 'K1', 'K0', 'K1'],
....: 'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3']})
....:
In [42]: right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
....: 'key2': ['K0', 'K0', 'K0', 'K0'],
....: 'C': ['C0', 'C1', 'C2', 'C3'],
....: 'D': ['D0', 'D1', 'D2', 'D3']})
....:
In [43]: result = pd.merge(left, right, on=['key1', 'key2'])
The how
argument to merge
specifies how to determine which keys are to
be included in the resulting table. If a key combination does not appear in
either the left or right tables, the values in the joined table will be
NA
. Here is a summary of the how
options and their SQL equivalent names:
Merge method | SQL Join Name | Description |
---|---|---|
left |
LEFT OUTER JOIN |
Use keys from left frame only |
right |
RIGHT OUTER JOIN |
Use keys from right frame only |
outer |
FULL OUTER JOIN |
Use union of keys from both frames |
inner |
INNER JOIN |
Use intersection of keys from both frames |
In [44]: result = pd.merge(left, right, how='left', on=['key1', 'key2'])
In [45]: result = pd.merge(left, right, how='right', on=['key1', 'key2'])
In [46]: result = pd.merge(left, right, how='outer', on=['key1', 'key2'])
In [47]: result = pd.merge(left, right, how='inner', on=['key1', 'key2'])
Here is another example with duplicate join keys in DataFrames:
In [48]: left = pd.DataFrame({'A' : [1,2], 'B' : [2, 2]})
In [49]: right = pd.DataFrame({'A' : [4,5,6], 'B': [2,2,2]})
In [50]: result = pd.merge(left, right, on='B', how='outer')
Warning
Joining / merging on duplicate keys can cause a returned frame that is the multiplication of the row dimensions, which may result in memory overflow. It is the user’ s responsibility to manage duplicate values in keys before joining large DataFrames.
Checking for duplicate keys¶
New in version 0.21.0.
Users can use the validate
argument to automatically check whether there
are unexpected duplicates in their merge keys. Key uniqueness is checked before
merge operations and so should protect against memory overflows. Checking key
uniqueness is also a good way to ensure user data structures are as expected.
In the following example, there are duplicate values of B
in the right
DataFrame
. As this is not a one-to-one merge – as specified in the
validate
argument – an exception will be raised.
In [51]: left = pd.DataFrame({'A' : [1,2], 'B' : [1, 2]})
In [52]: right = pd.DataFrame({'A' : [4,5,6], 'B': [2, 2, 2]})
In [53]: result = pd.merge(left, right, on='B', how='outer', validate="one_to_one")
...
MergeError: Merge keys are not unique in right dataset; not a one-to-one merge
If the user is aware of the duplicates in the right DataFrame
but wants to
ensure there are no duplicates in the left DataFrame, one can use the
validate='one_to_many'
argument instead, which will not raise an exception.
In [53]: pd.merge(left, right, on='B', how='outer', validate="one_to_many")
Out[53]:
A_x B A_y
0 1 1 NaN
1 2 2 4.0
2 2 2 5.0
3 2 2 6.0
The merge indicator¶
merge()
accepts the argument indicator
. If True
, a
Categorical-type column called _merge
will be added to the output object
that takes on values:
Observation Origin _merge
valueMerge key only in 'left'
frameleft_only
Merge key only in 'right'
frameright_only
Merge key in both frames both
In [54]: df1 = pd.DataFrame({'col1': [0, 1], 'col_left':['a', 'b']})
In [55]: df2 = pd.DataFrame({'col1': [1, 2, 2],'col_right':[2, 2, 2]})
In [56]: pd.merge(df1, df2, on='col1', how='outer', indicator=True)
Out[56]:
col1 col_left col_right _merge
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
The indicator
argument will also accept string arguments, in which case the indicator function will use the value of the passed string as the name for the indicator column.
In [57]: pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
Out[57]:
col1 col_left col_right indicator_column
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
Merge Dtypes¶
New in version 0.19.0.
Merging will preserve the dtype of the join keys.
In [58]: left = pd.DataFrame({'key': [1], 'v1': [10]})
In [59]: left
Out[59]:
key v1
0 1 10
In [60]: right = pd.DataFrame({'key': [1, 2], 'v1': [20, 30]})
In [61]: right
Out[61]:
key v1
0 1 20
1 2 30
We are able to preserve the join keys:
In [62]: pd.merge(left, right, how='outer')
Out[62]:
key v1
0 1 10
1 1 20
2 2 30
In [63]: pd.merge(left, right, how='outer').dtypes