Wie finde ich Bereich überlappen in Python?

Was ist der beste Weg in Python zu bestimmen, welche Werte in zwei Bereichen überlappen?

Beispielsweise:

  • Sogar Zahlen in Python
  • Subtrahieren Sie Überlappungen zwischen zwei Rängen ohne Sets
  • Die verschachtelte Python-Klasse muss auf die Variable in der umschließenden Klasse zugreifen
  • Neu bei der Programmierung und ich habe einen konzeptionellen Block mit der Bereichsfunktion (explizite Werte gegen Iterationen)
  • Reichweite ist zu groß Python
  • Warum ist das Range (Start, Ende) nicht Ende?
  • x = range(1,10) y = range(8,20) (The answer I am looking for would be the integers 8 and 9.) 

    Gibt es einen Bereich, x, was ist der beste Weg, um durch einen anderen Bereich zu iterieren, y und alle Werte ausgeben, die von beiden Bereichen geteilt werden? Vielen Dank im Voraus für die Hilfe.

    BEARBEITEN:

    Als Follow-up, erkannte ich, dass ich auch wissen müssen, ob x tut oder nicht überlappen y. Ich suche einen Weg, um durch eine Liste von Bereichen zu iterieren und und eine Reihe von zusätzlichen Sachen mit Reichweite, die sich überschneiden. Gibt es eine einfache True / False-Anweisung, um dies zu erreichen?

  • Summiere jeden Wert in einer Liste von Tupeln
  • Pandas DataFrame extrapolieren
  • Wann soll ich ein Singleton in Python verwenden?
  • Wie bekomme ich IDLE, um Einfügen von Unicode-Zeichen zu akzeptieren?
  • Drucknummer im Engineering-Format
  • Wörterbuchelemente, die nicht funktionieren, wenn sie über den Befehl powershell übergeben werden
  • 7 Solutions collect form web for “Wie finde ich Bereich überlappen in Python?”

    Versuchen Sie mit Satz Kreuzung:

     >>> x = range(1,10) >>> y = range(8,20) >>> xs = set(x) >>> xs.intersection(y) set([8, 9]) 

    Beachten Sie, dass die intersection eine beliebige als Argumentation akzeptiert ( y ist nicht erforderlich, um in einen Satz für die Operation umgewandelt zu werden). Es gibt einen Operator, der der intersection äquivalent ist: & in diesem Fall müssen beide Argumente gesetzt werden .

    Wenn der Schritt immer +1 ist (was der Standard für den Bereich ist), sollte das folgende effizienter sein als das Umwandeln jeder Liste in einen Satz oder eine Iteration über jede Liste:

     range(max(x[0], y[0]), min(x[-1], y[-1])+1) 

    Sie können set s für das verwenden, aber bewusst sein, dass set(list) alle doppelten Einträge aus der list :

     >>> x = range(1,10) >>> y = range(8,20) >>> list(set(x) & set(y)) [8, 9] 

    Eine Möglichkeit ist, nur das Listenverständnis zu benutzen wie:

     x = range(1,10) y = range(8,20) z = [i for i in x if i in y] print z 

    Für "wenn x tut oder nicht überlappt"

     for a,b,c,d in ((1,10,10,14), (1,10,9,14), (1,10,4,14), (1,10,4,10), (1,10,4,9), (1,10,4,7), (1,10,1,7), (1,10,-3,7), (1,10,-3,2), (1,10,-3,1), (1,10,-11,-5)): x = range(a,b) y = range(c,d) print 'x==',x print 'y==',y b = not ((x[-1]<y[0]) or (y[-1]<x[0])) print ' x %sy' % ("does not overlap"," OVERLAPS ")[b] print 

    Ergebnis

     x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [10, 11, 12, 13] x does not overlap y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [9, 10, 11, 12, 13] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [4, 5, 6, 7, 8, 9, 10, 11, 12, 13] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [4, 5, 6, 7, 8, 9] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [4, 5, 6, 7, 8] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [4, 5, 6] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [1, 2, 3, 4, 5, 6] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [-3, -2, -1, 0, 1] x OVERLAPS y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [-3, -2, -1, 0] x does not overlap y x== [1, 2, 3, 4, 5, 6, 7, 8, 9] y== [-11, -10, -9, -8, -7, -6] x does not overlap y 

    Bearbeiten 1

    Geschwindigkeitsvergleich:

     from time import clock x = range(-12,15) y = range(-5,3) te = clock() for i in xrange(100000): w = set(x).intersection(y) print ' set(x).intersection(y)',clock()-te te = clock() for i in xrange(100000): w = range(max(x[0], y[0]), min(x[-1], y[-1])+1) print 'range(max(x[0], y[0]), min(x[-1], y[-1])+1)',clock()-te 

    Ergebnis

      set(x).intersection(y) 0.951059981087 range(max(x[0], y[0]), min(x[-1], y[-1])+1) 0.377761978129 

    Das Verhältnis dieser Ausführungszeiten beträgt 2,5

    Angenommen, Sie arbeiten ausschließlich mit Reichweiten, mit einem Schritt von 1 , können Sie es schnell mit Mathe machen.

     def range_intersect(range_x,range_y): if len(range_x) == 0 or len(range_y) == 0: return [] # find the endpoints x = (range_x[0], range_x[-1]) # from the first element to the last, inclusive y = (range_y[0], range_y[-1]) # ensure min is before max # this can be excluded if the ranges must always be increasing x = tuple(sorted(x)) y = tuple(sorted(y)) # the range of the intersection is guaranteed to be from the maximum of the min values to the minimum of the max values, inclusive z = (max(x[0],y[0]),min(x[1],y[1])) if z[0] < z[1]: return range(z[0], z[1] + 1) # to make this an inclusive range else: return [] # no intersection 

    Auf einem Paar von Rängen mit jeweils über 10 ^ 7 Elementen, das unter einer Sekunde, unabhängig davon, wie viele Elemente überlappten. Ich versuchte mit 10 ^ 8 oder so Elemente, aber mein Computer fror für eine Weile. Ich bezweifle, dass du lange mit Listen arbeiten würdest.

    Wenn du die Überschneidungen von Bereichen mit beliebigen Schritten finden möchtest, kannst du mein Paket https://github.com/avnr/rangeplus verwenden , das eine Range () – Klasse bietet, die mit Python range () kompatibel ist, sowie einige Goodies inklusive Kreuzungen:

     >>> from rangeplus import Range >>> Range(1, 100, 3) & Range(2, 100, 4) Range(10, 100, 12) >>> Range(200, -200, -7) & range(5, 80, 2) # can intersect with Python range() too Range(67, 4, -14) 

    Range () kann auch ungebunden sein (bei Stop ist None der Bereich auf +/- unendlich):

     >>> Range(1, None, 3) & Range(3, None, 4) Range(7, None, 12) >>> Range(253, None, -3) & Range(208, 310, 5) Range(253, 207, -15) 

    Die Kreuzung wird berechnet, nicht iteriert, was die Effizienz der Implementierung unabhängig von der Länge des Bereichs () macht.

    Python ist die beste Programmiersprache der Welt.