我如何使用 python 中的 def 函数和条件语句打印 2 个连续的红色或绿色蜡烛

Question

I want the python conditional statements to only execute / print "PLEASE SELL" IF there are 2 consecutive RED CANDLES in a row, followed by 2 consecutive GREEN CANDLES in a row

and for ELIF, IF there are 2 consecutive GREEN CANDLES in a row, followed by 2 consecutive RED CANDLES in a row.

The below code of mine prints and executes on only 1 RED candle and 1 GREEN candle. Kindly let me know how to improve the code to give my anticipated result

def data_color(open,close):
    color = []
    if open > close:
        color.append("RED")
    elif open < close:
        color.append("GREEN")
    else:
        color.append("DOJI")

    return color


while True:
    time_iq = API.get_server_timestamp()
    if int(dt.fromtimestamp(time_iq).second) == 59 or 1 > 0:
        data_candle = API.get_candles(pair,timeframe,10,time_iq)
        colors = data_color(data_candle[-2]["open"], data_candle[-2]["close"])
        if colors[0] == "RED":
            print(" PLEASE SELL")

        elif colors[0] == "GREEN":
            print("PLEASE BUY")

Answer 1

for i in range (1,len(colors)):
    if colors[i-1] and colors[i] == "RED":
        print(" PLEASE SELL")

    elif colors[i-1] and colors[i] == "GREEN":
        print("PLEASE BUY")
    
    else:
         pass

You should try this

Answer 2

There are a number of ways to approach this, but here are two that might do what you need:

It depends on how you want to evaluate and find the patterns you're looking for. From your question, it is unclear whether the data you have comes in pre-formatted "packets" of 4 entries, within which you're looking for the recognized pattern of "2 green 2 red" or "2 red 2 green", so I'm going to assume this is not the case for the first example. In the second example, I will illustrate how to approach things if that assumption is true.

Example 1: iterate over the list of colors and find the pattern you're looking for in the last 4 entries, including the current iteration.

def evaluate_by_iteration(_colors):
    # -- skip the first three entries
    for i in range(4, len(_colors)):
        # -- get the preceding three elements and the current one.
        # -- note the "i+1" here, this is how list slicing works
        first, second, third, fourth = _colors[i-3: i+1]
        if (first == second == 'GREEN') and (third == fourth == 'RED'):
            print('[iterator] PLEASE SELL')

        elif (first == second == 'RED') and (third == fourth == 'GREEN'):
            print('[iterator] PLEASE BUY')

Example 2: chunk the list into packets of size 4, and check on each packet if they conform to the pattern. Do this only if the data is expected to be chunked this way! (again, not clear from your question)

from itertools import izip_longest
def evaluate_by_chunks(_colors):
    chunked_colors = izip_longest(*[iter(_colors)] * 4, fillvalue=None)

    for chunk in list(chunked_colors):
        first, second, third, fourth = chunk
        if (first == second == 'GREEN') and (third == fourth == 'RED'):
            print('[chunker] PLEASE SELL')

        if (first == second == 'RED') and (third == fourth == 'GREEN'):
            print('[chunker] PLEASE BUY')

Why would you use the second approach over the first one?

It depends on how you want to evaluate your data. Take the following data set:

colors = ['RED', 'GREEN', 'RED', 'RED', 'GREEN', 'GREEN', 'RED', 'RED']
print('-------------')
print('EVALUATE BY ITERATION')
evaluate_by_iteration(colors)
print(' ')

print('-------------')
print('EVALUATE BY CHUNKS')
evaluate_by_chunks(colors)
print(' ')

This will print:

-------------
EVALUATE BY ITERATION
[iterator] PLEASE BUY
[iterator] PLEASE SELL
 
-------------
EVALUATE BY CHUNKS
[chunker] PLEASE SELL

Note how "evaluate by iteration" has two matches, as we only increment the search index by one each time.

Now, depending on your needs, either one of these may be correct; with the iterator-based approach, you will find every instance of the pattern you look for, including patterns that overlap, where you have a "GREEN GREEN RED RED GREEN GREEN" pattern for example.

With the chunk-based approach, you ensure that you will never evaluate patterns that overlap, but that comes with the assumption that your data is nicely organized in packets of size 4.

There is one final approach that takes the iterator approach, but ensures no item is evaluated twice; in this example, we rewrite the iteration-based evaluator method, but instead of looking back, we look forward. This allows us, when we find a pattern match, to manually increment the "index" variable, ensuring we skip over the pattern when it matches.

This allows for the data to be relatively unstructured, while ensuring you do not evaluate overlapping patterns.

def evaluate_by_iteration_looking_forward(_colors):
    # -- skip the first three entries
    counter = 0
    for i in range(0, len(_colors) - 3):
        if counter > len(_colors) - 3:
            break
        
        first, second, third, fourth = _colors[counter: counter + 4]

        if (first == second == 'GREEN') and (third == fourth == 'RED'):
            print('[iterator] PLEASE SELL')
            counter += 4
            continue

        elif (first == second == 'RED') and (third == fourth == 'GREEN'):
            print('[iterator] PLEASE BUY')
            counter += 4
            continue

        counter += 1

To test this, we run this code:

print('-------------')
print('EVALUATE BY ITERATION')
evaluate_by_iteration(colors)
print(' ')

print('-------------')
print('EVALUATE BY CHUNKS')
evaluate_by_chunks(colors)
print(' ')

print('-------------')
print('EVALUATE BY ITERATION LOOKING FORWARD')
evaluate_by_iteration_looking_forward(colors)

Which prints:

-------------
EVALUATE BY ITERATION
[iterator] PLEASE BUY
[iterator] PLEASE SELL
 
-------------
EVALUATE BY CHUNKS
[chunker] PLEASE SELL
 
-------------
EVALUATE BY ITERATION LOOKING FORWARD
[iterator] PLEASE BUY

As you can see, our forward-looking evaluator only matches the first pattern, and then skips head, ensuring it does not match a second time with elements that were previously already evaluated.