Jestem nowy w Pythonie i to jest to, co próbuję zrobić, przypuśćmy, że mam tablicę

array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

Próbuję porównać ostatni element z [1.03, 1.1] tj. '1.1' i pierwszy element z [1.12, 1.25] czyli '1.12' i jeśli różnica jest mniejsza niż 0.5, to zdefiniuj nową tablicę biorąc pierwszy element [1.03, 1.1] tj. „1.03” i ostatni element [1.12, 1.25] czyli „1.12”, to po tej nowej tablicy powinny znajdować się inne elementy zdefiniowanej tablicy. Więc w zasadzie grupuję tablice na podstawie różnicy ostatniego elementu i pierwszego elementu kolejnych tablic, starałem się podsumować moje pytanie w najlepszy możliwy sposób. Jak to zrobić w Pythonie, próbuję to zrobić za pomocą pętli, ale kończy się to marnie.

0
coolname11 2 kwiecień 2020, 16:08

3 odpowiedzi

Najlepsza odpowiedź

Powinno to dać pożądany rezultat, po prostu scalając interwały:

def group_intervals(a):
    ans = []

    curr = None
    for x in a:
        # no previous interval under consideration
        if curr == None:
            curr = x
        else:
            # check if we can merge the intervals
            if x[0]-curr[1] < 0.5:
                curr[1] = x[1]
            else:
            # if we cannot merge, push the current element to ans
                ans.append(curr)
                curr = x
    # making sure, the last interval is pushed into final answer
    if curr is not None:
        ans.append(curr)

    return ans
0
Abhishek Jaisingh 2 kwiecień 2020, 13:55

Mam nadzieję, że to pomoże

import numpy as np
arr = np.array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

def process(list_):
    for index in range(len(list_)-1):
        if list_[index+1][0] - list_[index][1] < 0.5: #perform comparison
            element_new = [list_[index][0], list_[index+1][1]] #new list element
            list_[index] = element_new #replace two old elements by the new elements
            list_.remove(list_[index+1])
            process(list_) #recursion
            break
    return list_

list1 = arr.tolist() #it is a good practice to perform remove/append action on list rather than numpy array
list2 = process(list1)
arr2 = np.array(list2)
print(arr2)
0
Will 2 kwiecień 2020, 14:12

Można to zrobić bez żadnych pętli:

import numpy as np
arr = np.array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

toMerge = (arr[1:,0]-arr[:-1,1])<0.5          # flag neighbours to merged
breaks  = np.insert(toMerge==False,0,False)   # lines not merged with previous
starts  = np.insert(np.argwhere(breaks),0,0)  # indexes of start lines
ends    = np.append(starts[1:],breaks.size)-1 # indexes of end lines for merges 
result  = arr[starts]                         # keep only start lines
result[:,1] = arr[ends,1]                     # assign merged end values 

Wynik:

print(result)

[[1.03 1.25]
 [2.02 3.79]
 [4.73 5.91]
 [6.5  9.1 ]]

uwaga: to rozwiązuje problemy z moją poprzednią odpowiedzią

Jeśli nie używasz numpy, do uzyskania wyniku można użyć prostej pętli:

result,prevEnd = arr[:1],arr[0][1]
for line in arr[1:]:
    start,end = line
    if start-prevEnd<0.5: result[-1][1] = end
    else:                 result.append(line)
    prevEnd = end

To działałoby dobrze na listach Pythona, ale byłoby bardzo nieefektywne w przypadku tablic numpy

0
Alain T. 4 kwiecień 2020, 13:50