Zahlen in einer Liste, finden Durchschnitt der Umgebung

Frage:

Angesichts einer Liste listA von Zahlen, schreiben Sie ein Programm, das eine neue listB mit der gleichen Anzahl von Elementen wie listA , so dass jedes Element in der neuen Liste der Durchschnitt seiner Nachbarn und sich selbst in der ursprünglichen Liste ist.

  • Sortierung eines Django QuerySet durch eine Eigenschaft (kein Feld) des Modells
  • Python pyodbc Verbindungen zu IBM Netezza Erroring
  • Analysieren eines komplexen logischen Ausdrucks im Pyparsing in einer binären Baumart
  • Pandas und Numpy Thread Sicherheit
  • Unicode re.sub () funktioniert nicht mit \ g <0> (Gruppe 0)
  • Suche Patterns Ersatz mit Lambda
  • Zum Beispiel, wenn listA = [5, 1, 3, 8, 4] , listB = [3.0, 3.0, 4.0, 5.0, 6.0] , wobei:

     (5 + 1)/2 = 3.0 (5 + 1 + 3)/3 = 3.0 (1 + 3 + 8)/3 = 4.0 (3 + 8 + 4)/3 = 5.0 (8 + 4)/2 = 6.0 

    So kann ich den ersten Teil bekommen, und der letzte Teil, da sie nur mit 2 Zahlen umgehen, aber für den Mittelteil kann ich es nicht bekommen. Meine Schleife ist falsch, aber ich weiß nicht genau. Das habe ich so weit.

     listA= [5,1,3,8,4] N=len(listA) print(listA) listB=[] listB.append((listA[0]+listA[1])/2) y=0 x=1 while x in listA: y=((listA[x-1] + list[x] + list[x+1])/3) listB.append(y) y=y+1 listB.append((listA[-1]+listA[-2])/2) print(listB) 

    5 Solutions collect form web for “Zahlen in einer Liste, finden Durchschnitt der Umgebung”

    Sie können dies mit Iteratoren tun, ohne auf Looping durch Indizes zurückgreifen zu müssen:

     import itertools def neighbours(items, fill=None): before = itertools.chain([fill], items) after = itertools.chain(items, [fill]) #You could use itertools.zip_longest() later instead. next(after) for a, b, c in zip(before, items, after): yield [value for value in (a, b, c) if value is not fill] 

    Gebraucht wie folgt:

     >>> items = [5, 1, 3, 8, 4] >>> [sum(values)/len(values) for values in neighbours(items)] [3.0, 3.0, 4.0, 5.0, 6.0] 

    Also, wie funktioniert das? Wir schaffen einige Extra-Iteratoren – für die Vor- und Nach-Werte. Wir verwenden itertools.chain , um dem Anfang und dem Ende einen zusätzlichen Wert hinzuzufügen, damit wir die richtigen Werte zur richtigen Zeit erhalten können (und nicht aus den Gegenständen). Wir schlagen dann den späteren Gegenstand auf einen, um ihn in die richtige Position zu bringen, dann durchlaufen und die Werte zurückgeben, die nicht None . Das heißt, wir können einfach auf natürliche Weise durchlaufen.

    Beachten Sie, dass dies eine Liste erfordert, da ein Iterator erschöpft ist. Wenn Sie es brauchen, um faul auf einem Iterator zu arbeiten, verwendet das folgende Beispiel itertools.tee() , um den Job zu machen:

     def neighbours(items, fill=None): b, i, a = itertools.tee(items, 3) before = itertools.chain([fill], b) after = itertools.chain(a, [fill]) next(a) for a, b, c in zip(before, i, after): yield [value for value in (a, b, c) if value is not fill] 
     list_a = [5, 1, 3, 8, 4] # Start list_b with the special case first element list_b = [sum(list_a[:1]) / 2.0] # Iterate over each remaining index in the list for i in range(1, len(list_a - 1)): # Get the slice of the element and it's neighbors neighborhood = list_a[i-1:i+1] # Add the average of the element and it's neighbors # have to calculate the len of neighborhood to handle # last element special case list_b.append(sum(neighborhood) / float(len(neighborhood))) 

    Könnte arcpy.AverageNearestNeighbor_stats verwenden

    Ansonsten, wenn du Schleifen magst:

     import numpy as np listA= [5,1,3,8,4] b = [] for r in xrange(len(listA)): if r==0 or r==len(listA): b.append(np.mean(listA[r:r+2])) else: b.append(np.mean(listA[r-1:r+2])) 

    Es sieht so aus, als hättest du die richtige Idee. Ihr Code ist ein wenig schwer zu folgen, aber versuchen Sie es mit beschreibenden Variablennamen in der Zukunft 🙂 Es macht es einfacher für jeden.

    Hier ist meine schnelle und schmutzige Lösung:

     def calcAverages(listOfNums): outputList = [] for i in range(len(listOfNums)): if i == 0: outputList.append((listOfNums[0] + listOfNums[1]) / 2.) elif i == len(listOfNums)-1: outputList.append((listOfNums[i] + listOfNums[i-1]) / 2.) else: outputList.append((listOfNums[i-1] + listOfNums[i] + listOfNums[i+1]) / 3.) return outputList if __name__ == '__main__': listOne = [5, 1, 3, 8, 4, 7, 20, 12] print calcAverages(listOne) 

    Ich wählte für eine for Schleife statt einer while . Das macht keinen großen Unterschied, aber ich finde die Syntax ist einfacher zu folgen.

     for i in range(len(listOfNums)): 

    Wir erstellen eine Schleife, die über die Länge der Eingabeliste iterieren wird.

    Als nächstes behandeln wir die beiden "speziellen" Fälle: den Anfang und das Ende der Liste.

      if i == 0: outputList.append((listOfNums[0] + listOfNums[1]) / 2.) elif i == len(listOfNums)-1: outputList.append((listOfNums[i] + listOfNums[i-1]) / 2.) 

    Also, wenn unser Index 0 ist, sind wir am Anfang, und so addieren wir den Wert des Currect Index, 0 und der nächsthöhere 1 , durchschnittlich es und füge ihn an unsere Ausgabeliste an.

    Wenn unser Index gleich der Länge der Outliste ist – 1 (wir verwenden -1, weil Listen bei 0 angezählt werden, während Länge nicht ist. Ohne das -1 würde man einen IndexOutOfRange Fehler bekommen.) Wir wissen, dass wir an sind Das letzte Element. Und so nehmen wir den Wert an dieser Stelle, fügen Sie ihn dem Wert an der vorherigen Position in der Liste hinzu und fügen Sie schließlich den Durchschnitt dieser Zahlen zur Ausgabeliste hinzu.

      else: outputList.append((listOfNums[i-1] + listOfNums[i] + listOfNums[i+1]) / 3.) 

    Schließlich, für alle anderen Fälle, greifen wir einfach den Wert am aktuellen Index und jene unmittelbar über und darunter und dann das gemittelte Ergebnis an unsere Ausgabeliste anhängen.

     In [31]: lis=[5, 1, 3, 8, 4] In [32]: new_lis=[lis[:2]]+[lis[i:i+3] for i in range(len(lis)-1)] In [33]: new_lis Out[33]: [[5, 1], [5, 1, 3], [1, 3, 8], [3, 8, 4], [8, 4]] #now using sum() ans len() on above list and using a list comprehension In [35]: [sum(x)/float(len(x)) for x in new_lis] Out[35]: [3.0, 3.0, 4.0, 5.0, 6.0] 

    Oder mit zip() :

     In [36]: list1=[lis[:2]] + zip(lis,lis[1:],lis[2:]) + [lis[-2:]] In [37]: list1 Out[37]: [[5, 1], (5, 1, 3), (1, 3, 8), (3, 8, 4), [8, 4]] In [38]: [sum(x)/float(len(x)) for x in list1] Out[38]: [3.0, 3.0, 4.0, 5.0, 6.0] 
    Python ist die beste Programmiersprache der Welt.