Question

我将订单中的值作为这样的列表获取：

list1 = [...,'ethbtc', '0.077666', '10', '0.077680', '15',...]
------------------------ ^符号----- ^值----- ^数量 -

此列表中有大约100个符号，每个符号有40个值。它们总是处于相同的顺序如果我支付100％的余额，我想知道我的系统在这个时刻购买的最高价格。

因此，如果我想以0.077666购买11个ETH，那么实际价格将为0.077680，因为第一个价格只有10个ETH。我不想得到平均值，因为那将是目前很多

我的代码有一个嵌套的for循环并循环遍历2个列表：

coinlist =其中列出了所有100个符号，如symbollist = [ethbtc, eoseth,...]
名为a的索引列表，因为值和数量始终位于同一位置 a = ['1', '3', '5', ...]

我的代码：

for symbolnow in symbollist:
sumlist = []
    for i in a:
        quantity = float(list1[list1.index(symbolnow) + (i+1)] if symbolnow in list1 else 0)
        sumlist.append(quantity)
        if sum(sumlist) > mycurrentbalance:
            maxvalue = float(list1[list1.index(symbolnow) + i] if symbolnow in list1 else -1)
            break
        else:
            maxvalue = -1

那么这段代码是做什么的：
1）循环遍历符号列表中的每个符号
2）对于每个找到的符号，我查找可用的数量
3）如果我的余额（即10 ETH）小于数量，则循环中断 4）如果没有继续搜索和总结总和列表中的每个数量，直到有足够的。

代码按预期工作，但速度不快。正如预期list1.index需要很长时间才能执行..

问题
如何更快的代码工作。在这种情况甚至正则表达式中，列表理解能更好吗？我的代码非常难看吗？

提前谢谢！

修改
澄清输入和所需的输出，样本：

list1 = [...,'ethbtc', '0.077666', '1', '0.077680', '1.5', '0.077710', '3', '0.078200', '4',...]
mycurrentbalance = 5.5＆lt; - 余额在ETH中 list1中的每三个条目都是ETH中的数量，因此在列表中['1', '1.5', '3', '4']

所以，如果我想卖掉我所有的ETH（在这种情况下为5.5），最大值将是'0.077710'

list1包含100个符号，因此在'ethbtc'之前和之后还有其他值数量和符号

Answer 1

预处理list1并将其存储在dict中。这意味着您只需迭代list1一次，而不是每次内循环运行。

price_dict = {'ethbtc': ['0.077666', '10', '0.077680', '15'], 'btceth': [...], ...}

而不是遍历a，迭代range（Python 3）或xrange（Python 2）。这将使用迭代器而不是列表，并使您的代码更灵活。

range(0, len(price_dict[symbol]), 2)

Answer 2

在你的情况下，我认为使用切片对象有助于你的＆＃39; a＆＃39;循环，如果有固定的间隔。您可以将列表切片保存到对象，如下所示（另外，1或2个其他提示）。我同意上面的用户，如果你有机会预处理输入数据，那么你真的必须这样做。我建议使用pandas库，因为它非常快，但字典也允许散列值。

input_data = ['ethbtc', '0.0776666', '10', '0.077680', '15']  # Give your variables meaningful names

length = 20 # a variable to store how long a list of values is for a particular symbol.

for symbol in symbollist: # Use meaningful names if loops too
    start = input_data.index(symbol)  # break up longer lines
    # Some exception handling here
    indxs = slice(start: start+length:2) # python lets you create slice objects
    quantities = [float(number) for number in input_data[indxs]]

    if sum(quantities) > mycurrentbalance:
        # Whatever code here
        ....

Answer 3

除了user3080953的答案之外，您还必须预处理数据，不仅因为它更有效，而且因为它可以帮助您处理复杂性。在这里，您一次做两件事：解码列表并使用数据。首先解码，然后使用。

在我看来，目标格式应该是：

prices_and_quantities_by_symbol = {
    'ethbtc': {
        'prices':[0.077666, 0.077680, 0.077710, 0.078200], 
        'quantities':[1, 1.5, 3, 4]
    }, 
    'btceth': {
        ...
    }, 
...}

现在，你必须这样做：

for symbol, prices_and_quantities in prices_and_quantities_by_symbol.items(): # O(len(symbol_list))
    total = 0
    for p, q in zip(prices_and_quantities["prices"], prices_and_quantities["quantities"]): # O(len(quantities))
        total += q # the running sum
        if total >= my_current_balance:
            yield symbol, p # this will yield the symbol and the associated max_value
            break

如何以目标格式获取数据？只需迭代列表，如果找到符号，就开始存储值和数量，直到下一个符号：

prices_and_quantities_by_symbol = {}
symbol_set = (symbol_list) # O(len(symbol_list))
for i, v in enumerate(list1): # O(len(list1))
    if v in symbol_set:  # amortized O(1) lookup
        current_prices = []
        current_quantities = []
        current_start = i+1
        prices_and_quantities_by_symbol[v] = {
            'prices':current_prices, 
            'quantities':current_quantities
        }
    else: # a value or a quantity
        (current_prices if (i-current_start)%2==0 else current_quantities).append(float(v))

您有一个轻微但有趣的优化，特别是如果您的数量/值列表很长。不要存储数量，而是存储数量的总和：

prices_and_running_total_by_symbol = {
    'ethbtc': {
        'prices':[0.077666, 0.077680, 0.077710, 0.078200], 
        'running_total':[1, 2.5, 5.5, 9.5]
    }, 
    'btceth': {
        ...
    }, 
...}

现在，您可以使用bisect快速找到您的max_value。代码变得更容易理解，因为bisect.bisect_left(rts, my_current_balance)将返回第一个运行总计>= my_current_balance的索引：

for symbol, prices_and_running_totals in prices_and_running_totals_by_symbol.items(): # O(len(symbol_list))
    ps = prices_and_running_totals["prices"]
    rts = prices_and_running_totals["running_total"]
    i = bisect.bisect_left(rts, my_current_balance) # O(log(len(rts)))
    yield symbol, ps[i] # this will yield the symbol and the associated max_value

要构建运行总计，您必须以不同的方式处理价格和数量：

# O(len(list1))
...
if v in symbol_set:  # amortized O(1) lookup*
    ...
elif (i-current_start)%2==0:
    current_prices.append(float(v))
else:
    current_running_totals.append((current_running_totals[-1] if current_running_totals else 0.0) + float(v))

将所有内容放入函数中（或者更好，类的方法）：

prices_and_running_totals_by_symbol = process_data(list1)
for symbol, max_value in symbols_max_values(prices_and_running_totals_by_symbol, my_current_balance):
    print(symbol, max_value)

你可以看到，通过将问题分成两部分（解码和使用），代码变得更快，并且（在我看来）更容易理解（我没有把评论，但它们应该在那里）。

如何使用索引搜索加速嵌套for循环PYTHON

3 个答案: