當前位置: 首頁>>編程示例 >>用法及示例精選 >>正文

Python dask.dataframe.multi.merge_asof用法及代碼示例

用法:

dask.dataframe.multi.merge_asof(left: DataFrame | Series, right: DataFrame | Series, on: IndexLabel | None = None, left_on: IndexLabel | None = None, right_on: IndexLabel | None = None, left_index: bool = False, right_index: bool = False, by=None, left_by=None, right_by=None, suffixes: Suffixes =('_x', '_y'), tolerance=None, allow_exact_matches: bool = True, direction: str = 'backward') → DataFrame

按關鍵距離執行合並。

這類似於left-join，除了我們匹配最近的鍵而不是相等的鍵。兩個 DataFrame 都必須按 key 排序。

對於左側 DataFrame 中的每一行：

  • “backward” 搜索選擇右側 DataFrame 中 ‘on’ 鍵小於或等於左側鍵的最後一行。

  • “forward” 搜索選擇右側 DataFrame 中 ‘on’ 鍵大於或等於左側鍵的第一行。

  • “nearest” 搜索選擇右側 DataFrame 中其 ‘on’ 鍵在絕對距離上與左側鍵最近的行。

默認為“backward”，兼容0.20.0以下的版本。在 0.20.0 版本中添加了方向參數，並引入了“forward” and “nearest”。

在使用 ‘on’ 搜索之前，可選擇使用 ‘by’ 匹配等效鍵。

參數：

left：DataFrame 或命名係列
right：DataFrame 或命名係列
on：標簽

要加入的字段名稱。必須在兩個 DataFrame 中都可以找到。數據必須是有序的。此外，這必須是數字列，例如 datetimelike、integer 或 float。必須給出 On 或 left_on/right_on。

left_on：標簽

在左側 DataFrame 中加入的字段名稱。

right_on：標簽

要在右側 DataFrame 中加入的字段名稱。

left_index：bool

使用左側 DataFrame 的索引作為連接鍵。

right_index：bool

使用正確 DataFrame 的索引作為連接鍵。

by：列名或列名列表

在執行合並操作之前匹配這些列。

left_by：列名

左側 DataFrame 中要匹配的字段名稱。

right_by：列名

要在右側 DataFrame 中匹配的字段名稱。

suffixes：2 長度序列(元組，列表，...)

分別應用於左側和右側重疊列名的後綴。

tolerance：int 或 Timedelta，可選，默認無

在此範圍內選擇asof公差；必須與合並索引兼容。

allow_exact_matches：布爾值，默認為真
  • 如果為 True，則允許匹配相同的 ‘on’ 值(即 less-than-or-equal-to /greater-than-or-equal-to)
  • 如果為 False，則不匹配相同的 ‘on’ 值(即嚴格 less-than /嚴格 greater-than)。
direction：‘backward’(默認)，‘forward’, or ‘nearest’

是否搜索先前、後續或最接近的匹配項。

返回：

merged： DataFrame

例子：

>>> left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
>>> left
    a left_val
0   1        a
1   5        b
2  10        c
>>> right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})
>>> right
   a  right_val
0  1          1
1  2          2
2  3          3
3  6          6
4  7          7
>>> pd.merge_asof(left, right, on="a")
    a left_val  right_val
0   1        a          1
1   5        b          3
2  10        c          7
>>> pd.merge_asof(left, right, on="a", allow_exact_matches=False)
    a left_val  right_val
0   1        a        NaN
1   5        b        3.0
2  10        c        7.0
>>> pd.merge_asof(left, right, on="a", direction="forward")
    a left_val  right_val
0   1        a        1.0
1   5        b        6.0
2  10        c        NaN
>>> pd.merge_asof(left, right, on="a", direction="nearest")
    a left_val  right_val
0   1        a          1
1   5        b          6
2  10        c          7

我們也可以使用索引數據幀。

>>> left = pd.DataFrame({"left_val": ["a", "b", "c"]}, index=[1, 5, 10])
>>> left
   left_val
1         a
5         b
10        c
>>> right = pd.DataFrame({"right_val": [1, 2, 3, 6, 7]}, index=[1, 2, 3, 6, 7])
>>> right
   right_val
1          1
2          2
3          3
6          6
7          7
>>> pd.merge_asof(left, right, left_index=True, right_index=True)
   left_val  right_val
1         a          1
5         b          3
10        c          7

這是一個 real-world times-series 示例

>>> quotes = pd.DataFrame(
...     {
...         "time": [
...             pd.Timestamp("2016-05-25 13:30:00.023"),
...             pd.Timestamp("2016-05-25 13:30:00.023"),
...             pd.Timestamp("2016-05-25 13:30:00.030"),
...             pd.Timestamp("2016-05-25 13:30:00.041"),
...             pd.Timestamp("2016-05-25 13:30:00.048"),
...             pd.Timestamp("2016-05-25 13:30:00.049"),
...             pd.Timestamp("2016-05-25 13:30:00.072"),
...             pd.Timestamp("2016-05-25 13:30:00.075")
...         ],
...         "ticker": [
...                "GOOG",
...                "MSFT",
...                "MSFT",
...                "MSFT",
...                "GOOG",
...                "AAPL",
...                "GOOG",
...                "MSFT"
...            ],
...            "bid": [720.50, 51.95, 51.97, 51.99, 720.50, 97.99, 720.50, 52.01],
...            "ask": [720.93, 51.96, 51.98, 52.00, 720.93, 98.01, 720.88, 52.03]
...     }
... )
>>> quotes
                     time ticker     bid     ask
0 2016-05-25 13:30:00.023   GOOG  720.50  720.93
1 2016-05-25 13:30:00.023   MSFT   51.95   51.96
2 2016-05-25 13:30:00.030   MSFT   51.97   51.98
3 2016-05-25 13:30:00.041   MSFT   51.99   52.00
4 2016-05-25 13:30:00.048   GOOG  720.50  720.93
5 2016-05-25 13:30:00.049   AAPL   97.99   98.01
6 2016-05-25 13:30:00.072   GOOG  720.50  720.88
7 2016-05-25 13:30:00.075   MSFT   52.01   52.03
>>> trades = pd.DataFrame(
...        {
...            "time": [
...                pd.Timestamp("2016-05-25 13:30:00.023"),
...                pd.Timestamp("2016-05-25 13:30:00.038"),
...                pd.Timestamp("2016-05-25 13:30:00.048"),
...                pd.Timestamp("2016-05-25 13:30:00.048"),
...                pd.Timestamp("2016-05-25 13:30:00.048")
...            ],
...            "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
...            "price": [51.95, 51.95, 720.77, 720.92, 98.0],
...            "quantity": [75, 155, 100, 100, 100]
...        }
...    )
>>> trades
                     time ticker   price  quantity
0 2016-05-25 13:30:00.023   MSFT   51.95        75
1 2016-05-25 13:30:00.038   MSFT   51.95       155
2 2016-05-25 13:30:00.048   GOOG  720.77       100
3 2016-05-25 13:30:00.048   GOOG  720.92       100
4 2016-05-25 13:30:00.048   AAPL   98.00       100

默認情況下，我們采用引號的 asof

>>> pd.merge_asof(trades, quotes, on="time", by="ticker")
                     time ticker   price  quantity     bid     ask
0 2016-05-25 13:30:00.023   MSFT   51.95        75   51.95   51.96
1 2016-05-25 13:30:00.038   MSFT   51.95       155   51.97   51.98
2 2016-05-25 13:30:00.048   GOOG  720.77       100  720.50  720.93
3 2016-05-25 13:30:00.048   GOOG  720.92       100  720.50  720.93
4 2016-05-25 13:30:00.048   AAPL   98.00       100     NaN     NaN

我們僅在引號時間和交易時間之間的 2 毫秒內完成

>>> pd.merge_asof(
...     trades, quotes, on="time", by="ticker", tolerance=pd.Timedelta("2ms")
... )
                     time ticker   price  quantity     bid     ask
0 2016-05-25 13:30:00.023   MSFT   51.95        75   51.95   51.96
1 2016-05-25 13:30:00.038   MSFT   51.95       155     NaN     NaN
2 2016-05-25 13:30:00.048   GOOG  720.77       100  720.50  720.93
3 2016-05-25 13:30:00.048   GOOG  720.92       100  720.50  720.93
4 2016-05-25 13:30:00.048   AAPL   98.00       100     NaN     NaN

我們僅在引號時間和交易時間之間的 10 毫秒內截止，並且我們排除了準時的完全匹配。然而，先前的數據將向前傳播

>>> pd.merge_asof(
...     trades,
...     quotes,
...     on="time",
...     by="ticker",
...     tolerance=pd.Timedelta("10ms"),
...     allow_exact_matches=False
... )
                     time ticker   price  quantity     bid     ask
0 2016-05-25 13:30:00.023   MSFT   51.95        75     NaN     NaN
1 2016-05-25 13:30:00.038   MSFT   51.95       155   51.97   51.98
2 2016-05-25 13:30:00.048   GOOG  720.77       100     NaN     NaN
3 2016-05-25 13:30:00.048   GOOG  720.92       100     NaN     NaN
4 2016-05-25 13:30:00.048   AAPL   98.00       100     NaN     NaN

相關用法


注：本文由純淨天空篩選整理自dask.org大神的英文原創作品 dask.dataframe.multi.merge_asof。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。