如何使用Python和Pandas在三角套利中寻找最佳机会

我有一个这样的熊猫数据框架（这是一个三角套利问题）

我需要知道正值的行名和列名 （从最高值到最低值排序）

在我的例子中，我想

1.680672 b d
0.833333 a d
0        b a
0        c d

是我干的

lst_arbitrage_opportunities = list(df_diff_rel[df_diff_rel>0])
lst_arbitrage_opportunities.sort(reverse=True)

但现在我不知道如何获取给定值的行和列名

以下是获取我的示例的完整代码：

import pandas as pd
import numpy as np


class Ticker:
  def __init__(self, ask=None, bid=None):
    self.ask = ask
    self.bid = bid

  def spread(self):
    return(self.ask-self.bid)

  def __repr__(self):
    str = """ask: {ask}
bid: {bid}""".format(ask=self.ask, bid=self.bid)

    if self.ask!=None and self.bid!=None:
      str = str + """
spread: {spread}""".format(spread=self.spread())

    return(str)

markets = ['a', 'b', 'c', 'd']

markets_tickers = dict()
markets_tickers['a'] = Ticker(1.20, 1.19)
markets_tickers['b'] = Ticker(1.19, 1.18)
markets_tickers['c'] = Ticker(1.21, 1.17)
markets_tickers['d'] = Ticker(1.22, 1.21)

df_ask = pd.DataFrame(index=markets, columns=markets)
df_bid = pd.DataFrame(index=markets, columns=markets)

size = 1.0

for mk in markets:
  print("="*5+mk+"="*5)
  print(markets_tickers[mk])
  df_ask.ix[mk]=markets_tickers[mk].ask
  df_bid[mk]=markets_tickers[mk].bid

df_diff_abs = (df_bid - df_ask)*size
df_diff_rel = (df_bid - df_ask)/df_ask*100.0

df_arbitrage_opportunities = df_diff_rel>0

lst_arbitrage_opportunities = list(df_diff_rel[df_diff_rel>0])
lst_arbitrage_opportunities.sort(reverse=True)

print("Ask")
print(df_ask)
print("Bid")
print(df_bid)
print("Diff abs")
print(df_diff_abs)
print("Diff rel")
print(df_diff_rel)
print("Arbitrage opportunities")
print(df_arbitrage_opportunities)
print("List of opportunities (from the best to the worst)")
print(lst_arbitrage_opportunities)

---

以下是一个简单的单线解决方案：

要获取所需形状的数据，可以使用“取消堆叠”方法：

In [2]: df.unstack()
Out[2]:
a  a   -0.833333
   b    0.000000
   c   -1.652893
   d   -2.459016
b  a   -1.666667
   b   -0.840336
   c   -2.479339
...

然后，您可以像这样筛选此列表以查找>=0的值：

In [3]: df.unstack()[df.unstack() >= 0]
Out[3]:
a  b    0.000000
d  a    0.833333
   b    1.680672
   c    0.000000

最后，您可以访问上述对象的索引以返回标签列表：

In [1]: df.unstack()[df.unstack() >= 0].index.tolist()
Out[1]: [('a', 'b'), ('d', 'a'), ('d', 'b'), ('d', 'c')]

更新：

要按降序排序，请使用

系列.order

方法而不是

排序

：

In [1]: tmp = df.unstack()[df.unstack() >= 0]

In [2]: tmp = tmp.order(ascending=False)

In [3]: tmp
Out[3]:
d  b    1.680672
   a    0.833333
   c    0.000000
a  b    0.000000

In [4]: tmp.index.tolist()
Out[4]: [('d', 'b'), ('d', 'a'), ('d', 'c'), ('a', 'b')]

---

以下是一个简单的单线解决方案：

要获取所需形状的数据，可以使用“取消堆叠”方法：

In [2]: df.unstack()
Out[2]:
a  a   -0.833333
   b    0.000000
   c   -1.652893
   d   -2.459016
b  a   -1.666667
   b   -0.840336
   c   -2.479339
...

然后，您可以像这样筛选此列表以查找>=0的值：

In [3]: df.unstack()[df.unstack() >= 0]
Out[3]:
a  b    0.000000
d  a    0.833333
   b    1.680672
   c    0.000000

最后，您可以访问上述对象的索引以返回标签列表：

In [1]: df.unstack()[df.unstack() >= 0].index.tolist()
Out[1]: [('a', 'b'), ('d', 'a'), ('d', 'b'), ('d', 'c')]

更新：

要按降序排序，请使用

系列.order

方法而不是

排序

：

In [1]: tmp = df.unstack()[df.unstack() >= 0]

In [2]: tmp = tmp.order(ascending=False)

In [3]: tmp
Out[3]:
d  b    1.680672
   a    0.833333
   c    0.000000
a  b    0.000000

In [4]: tmp.index.tolist()
Out[4]: [('d', 'b'), ('d', 'a'), ('d', 'c'), ('a', 'b')]

---

我做了这个

df\u套利机会=df\u diff\u rel.unstack（）df\u套利机会=df\u套利机会[df\u套利机会>0]df\u套利机会。sort（）打印（df\u套利机会）打印（df\u套利机会.index.tolist（））

但它是升序排序的，你可以通过

数据[：-1]将其反转

要使用降序排序，您可能会认为

排序

可以满足您的要求，但熊猫使用

顺序

。我更新了我的答案。我做了这个

df\u套利机会=df\u diff\u rel.unstack（）df\u套利机会=df\u套利机会[df\u套利机会>0]df\u套利机会。排序（）打印（df\u套利机会）打印（df\u套利机会。索引。tolist（））

但它是升序排序的。您可以通过

数据[：：-1]

将其反转为降序。您可能认为

排序

可以执行您想要的操作，但熊猫使用

顺序

。我已经更新了我的答案。