Skip to main content
`Ctrl`+`K`

# pandas.merge_ordered

pandas.merge_ordered(left, right, on=None, left_on=None, right_on=None, left_by=None, right_by=None, fill_method=None, suffixes=('_x', '_y'), how='outer')

  Perform a merge for ordered data with optional filling/interpolation.

  Designed for ordered data like time series data. Optionally perform group-wise merge (see examples).

  Parameters:
    left DataFrame or named Series

      First pandas object to merge.

    right DataFrame or named Series

      Second pandas object to merge.

    on Hashable or a sequence of the previous

      Field names to join on. Must be found in both DataFrames.

    left_on Hashable or a sequence of the previous, or array-like

      Field names to join on in left DataFrame. Can be a vector or list of vectors of the length of the DataFrame to use a particular vector as the join key instead of columns.

    right_on Hashable or a sequence of the previous, or array-like

      Field names to join on in right DataFrame or vector/list of vectors per left_on docs.

    left_by column name or list of column names

      Group left DataFrame by group columns and merge piece by piece with right DataFrame. Must be None if either left or right are a Series.

    right_by column name or list of column names

      Group right DataFrame by group columns and merge piece by piece with left DataFrame. Must be None if either left or right are a Series.

    fill_method{‘ffill’, None}, default None

      Interpolation method for data.

    suffixes list-like, default is (“_x”, “_y”)

      A length-2 sequence where each element is optionally a string indicating the suffix to add to overlapping column names in left and right respectively. Pass a value of None instead of a string to indicate that the column name from left or right should be left as-is, with no suffix. At least one of the values must not be None.

    how{‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘outer’

      - left: use only keys from left frame (SQL: left outer join)

      - right: use only keys from right frame (SQL: right outer join)

      - outer: use union of keys from both frames (SQL: full outer join)

      - inner: use intersection of keys from both frames (SQL: inner join).

  Returns:
    DataFrame

      The merged DataFrame output type will be the same as ‘left’, if it is a subclass of DataFrame.

  See also

  `merge`

    Merge with a database-style join.

  `merge_asof`

    Merge on nearest keys.

  Examples

      >>> from pandas import merge_ordered
      >>> df1 = pd.DataFrame(
      ...     {
      ...         "key": ["a", "c", "e", "a", "c", "e"],
      ...         "lvalue": [1, 2, 3, 1, 2, 3],
      ...         "group": ["a", "a", "a", "b", "b", "b"],
      ...     }
      ... )
      >>> df1
        key  lvalue group
      0   a       1     a
      1   c       2     a
      2   e       3     a
      3   a       1     b
      4   c       2     b
      5   e       3     b

      >>> df2 = pd.DataFrame({"key": ["b", "c", "d"], "rvalue": [1, 2, 3]})
      >>> df2
        key  rvalue
      0   b       1
      1   c       2
      2   d       3

      >>> merge_ordered(df1, df2, fill_method="ffill", left_by="group")
        key  lvalue group  rvalue
      0   a       1     a     NaN
      1   b       1     a     1.0
      2   c       2     a     2.0
      3   d       2     a     3.0
      4   e       3     a     3.0
      5   a       1     b     NaN
      6   b       1     b     1.0
      7   c       2     b     2.0
      8   d       2     b     3.0
      9   e       3     b     3.0