Определить интервалы с определенными значениями

Question

Я новичок в Python и я застрял, пытаясь определить «интервалы», где у-значение = < 70. У меня есть упорядоченная запись словаря:

d = {0: '92', 11: '70', 43: '77', 44: '76', 61: '77', 64: '69', 
        68: '67', 84: '68', 93: '87', 108: '81', 141: '74'} 

Я хочу написать функция, которая позволяет мне идентифицировать «интервалы» (a, b) на основе ключей (x-значений) d на основе y-значений = < N. Мои конечные точки (a, b) должны быть там, где значения начинают спускаться и возрастать в и из этого значения N, поэтому фактические значения конечной точки будут «выше» N, но записи между ними должны быть ниже.

(a,b): {above, below, below, below, above} 

К примеру, я заинтересован в промежутках как словарь, здесь N = 70:

{(0,43):{92,70,77}, (61,93): {77, 69, 67, 68, 87}} <-- includes the values at endpoints 

Но, может игнорировать эти другие «интервалы», где значения никогда не ниже 70 поэтому в этом случае нам не нужны: (43,51), (93,180)

Есть ли простой способ сделать это? До сих пор я мог идентифицировать точки, где происходит переход от «выше» к «ниже» 70 или наоборот, но не уверен, как действовать при создании интервалов и значений (например, в словаре). Кажется, я слишком долго смотрел на это.

Answer 1

Следующий код должен дать вам выход вы просили:

oninterval = False 
dd = {} 
keys = d.keys() 
keys.sort() 
start_key, first_val = keys[0], d[keys[0]] 

for k in keys: 
    v = float(d[k]) 
    if oninterval: 
     cur_list.append(v) 
     if not int(v) <= 70: # interval ends 
      oninterval = False 
      dd[(start_key,k)] = cur_list 
    else: 
     if int(v) <= 70: 
      cur_list = [first_val, v] 
      oninterval = True 
     else: 
      start_key, first_val = k, v 

if oninterval: dd[(start_key, keys[-1])] = cur_list 

Edit:

Расширенная код фракции принять первый или последний элемент, чтобы иметь у-значение < = 70 и для лечения у -значения как плавающие

Answer 2

d = {0: '92', 11: '70', 43: '77', 44: '76', 61: '77', 64: '69', 
     68: '67', 84: '68', 93: '87', 108: '81', 141: '74'} 

r = [] 
k = None 
v = None 

for i in sorted(d.keys()): 
    if not k is None: 
     v.append(d[i]) 

    if int(d[i]) > 70: 
     if k is None: 
      k = [i] 
      v = [d[i]]; 
     else: 
      k.append(i) 
      r.append((tuple(k), v)) 
      k = None 
      v = None 

print r 

Answer 3

Вот несколько многословным решение:

import collections 

values = [(0, '92'), (11, '70'), (43, '77'), (44, '76'), (61, '77'), (64, '69'), 
    (68, '67'), (84, '68'), (93, '87'), (108, '81'), (141, '74')] 
d = collections.OrderedDict(values) 

def intervals(d, n): 
    result = collections.OrderedDict() 
    interval = list() 
    lastk, lastv, startk = None, None, None 
    for k, v in d.iteritems(): 
     if int(v) > n: 
      if startk is not None: 
       interval.append(int(d[k])) 
       result[(startk, k)] = interval 
       interval = list() 
       startk = None 
     else: 
      if lastv: 
       interval.append(int(d[lastk])) 
       startk = lastk 
      interval.append(int(d[k])) 
     lastk, lastv = k, int(v) > n 
    return result 


if __name__ == '__main__': 
    print intervals(d, 70) 

При запуске этого он печатает:

OrderedDict([((0, 43), [92, 70, 77]), ((61, 93), [77, 69, 67, 68, 87])]) 

, который является желаемым результатом.

Answer 4

sidenote: Ваш словарь имеет строковые значения, а не значения int. И вы можете указать < = вместо <, в вашем примере.

Таким образом, чтобы пересчитать вашу проблему более четко, вам:

• Есть упорядоченный список точек (x,y)
• имеют порог значения Т
• желание найти все последовательные прогоны точек р _я, ..., p _j такой, что конечные точки> T, но другие точки не являются; т. е. все участки, где точки «опускаются и выходят» из пороговой линии. (Обратите внимание, что такие прогоны могут перекрываться, например.[71,70,{71],70,71})

Алгоритм будет выглядеть следующим образом:

from itertools import * 

def dippingIntervals(points, threshold=70): 
    yBelowThreshold = lambda i: points[i][1]<=threshold 

    for below,g in groupby(range(len(points)), yBelowThreshold): 
     if below: 
      interval = list(g) 
      start,end = interval[0],interval[-1] 
      if start>0 and end<len(points)-2:  #modify if "open" intervals also desired 
       yield points[start-1 : end+2] 

Демо:

>>> d = [(0, 92), (11, 70), (43, 77), (44, 76), (61, 77), (64, 69), (68, 67), (84, 68), (93, 87), (108, 81), (141, 74)] 
>>> pprint(list(dippingIntervals(d))) 
[((0, 92), (11, 70), (43, 77)), 
((61, 77), (64, 69), (68, 67), (84, 68), (93, 87))] 

Вы можете постобработку данных без особых хлопот, например, чтобы получить его в формат, который вы хотели, изменить вышеуказанную функцию следующим образом:

... yield (start,end), {xy[1] for xy in points[start-1 : end+2]} 

Недостатком этого метода является то, что он не работает на итераторах; следующий будет работать на итераторы, и более «классический» способ сделать это:

def getY(point): 
    return point[1] 

def dippingIntervals(points, threshold=70, key=getY): 
    """ 
     Returns runs of points whose y-values dip below intervals 
     >>> list(dippingIntervals([71,70,74,64,64,70,71], key=lambda x:x)) 
     [(71, [70], 74), 
     (74, [64, 64, 70], 71)] 
    """ 
    def match(point): 
     return key(point)<=threshold 

    lastP = None 
    for p in points: 
     if lastP==None: 
      lastP = p 
      continue 

     if not match(lastP) and match(p): 
      start = lastP 
      R = [p] 
     elif match(lastP) and match(p): 
      R += [p] 
     elif match(lastP) and not match(p): 
      end = p 
      yield start,R,end 

     lastP = p 

Answer 5

По причинам, я не могу полностью объяснить, эта проблема загипнотизированы меня. Но я думаю, что, наконец, я получил его из своей системы. Во-первых, основной, чистый и простое решение:

intervals = [[]] 
prev = None 
sorted_items = sorted(d.iteritems()) 
for k, v in sorted_items: 
    if v <= 70: 
     ext = (k,) if (intervals[-1] or prev is None) else (prev, k) 
     intervals[-1].extend(ext) 
    elif intervals[-1]: 
     intervals[-1].append(k) 
     intervals.append([]) 
    prev = k 

if not intervals[-1]: 
    intervals.pop() 

print dict(((iv[0], iv[-1]), [d[k] for k in iv]) for iv in intervals) 

Это достаточно легко абстрагироваться выше, чтобы создать итератор:

def iter_intervals(vals, filter_f, _nil=object()): 
    prev = _nil 
    interval = [] 
    for x in vals: 
     if filter_f(x): 
      ext = (x,) if (interval or prev is _nil) else (prev, x) 
      interval.extend(ext) 
     elif interval: 
      interval.append(x) 
      yield interval 
      interval = [] 
     prev = x 
    if interval: 
     yield interval 

intervals = iter_intervals(d.iteritems(), lambda x: x[1] <= 70) 
print dict(((iv[0][0], iv[-1][0]), [v for k, v in iv]) for iv in intervals) 

Но что должен хранить много состояния. Интересно, есть ли способ сделать меньше, что ...

def iter_intervals(vals, filter_f, _nil=object()): 
    iters = itertools.tee(itertools.chain((_nil,), vals, (_nil,)), 3) 
    next(iters[1]); next(iters[2]); next(iters[2]) 
    triplets = itertools.izip(*iters) 
    interval = set() 
    for p, curr, n in triplets: 
     if filter_f(curr): 
      interval.update((p, curr, n)) 
     elif interval: 
      interval.discard(_nil) 
      yield sorted(interval) 
      interval = set() 
    if interval: 
     interval.discard(_nil) 
     yield sorted(interval) 

intervals = iter_intervals(d.iteritems(), lambda x: x[1] <= 70) 
print dict(((iv[0][0], iv[-1][0]), [v for k, v in iv]) for iv in intervals) 

Сделав это, теперь это более очевидным, как адаптировать ninjagecko «s решение, чтобы избежать предпросмотр/просмотра назад проблема, которая заставила его хранить список :

def framed_intervals(points, filter_f, _nil=object()): 
    iters = itertools.tee(itertools.chain((_nil,), points, (_nil,)), 3) 
    next(iters[1]); next(iters[2]); next(iters[2]) 
    triplets = itertools.izip(*iters) 
    for below, group in itertools.groupby(triplets, lambda x: filter_f(x[1])): 
     if below: 
      interval = set(itertools.chain.from_iterable(group)) 
      interval.discard(_nil) # or continue if None in interval to 
      yield sorted(interval) # drop incomplete intervals 

intervals = framed_intervals(d.iteritems(), lambda x: x[1] <= 70) 
print dict(((iv[0][0], iv[-1][0]), [v for k, v in iv]) for iv in intervals)