Gibt es eine pythonische Möglichkeit zu überprüfen, ob eine Liste bereits in ASCoder sortiert ist?DESC

listtimestamps = [1, 2, 3, 5, 6, 7]

so etwas isttimestamps.isSorted()kehrt zurück Trueoder False.

Ich möchte eine Liste von Zeitstempeln für einige Nachrichten eingeben und prüfen, ob die Transaktionen in der richtigen Reihenfolge angezeigt wurden.

Eigentlich geben wir nicht die Antwort, nach der Anijhaw sucht. Hier ist der eine Liner:

all(l[i] <= l[i+1] for i in xrange(len(l)-1))

Für Python 3:

all(l[i] <= l[i+1] for i in range(len(l)-1))

Ich würde nur verwenden

if sorted(lst) == lst:
    # code here

Es sei denn, es handelt sich um eine sehr große Liste. In diesem Fall möchten Sie möglicherweise eine benutzerdefinierte Funktion erstellen.

Wenn Sie es nur sortieren möchten, wenn es nicht sortiert ist, vergessen Sie die Prüfung und sortieren Sie es.

lst.sort()

und denke nicht zu viel darüber nach.

Wenn Sie eine benutzerdefinierte Funktion wünschen, können Sie so etwas tun

def is_sorted(lst, key=lambda x: x):
    for i, el in enumerate(lst[1:]):
        if key(el) < key(lst[i]): # i is the index of the previous element
            return False
    return True

Dies ist O (n), wenn die Liste bereits sortiert ist (und O (n) in einer forSchleife! ). Wenn Sie also nicht erwarten, dass sie die meiste Zeit nicht sortiert (und ziemlich zufällig) ist, würde ich Wieder sortieren Sie einfach die Liste.

Diese Iteratorform ist 10-15% schneller als die Ganzzahlindizierung:

# python2 only
if str is bytes:
    from itertools import izip as zip

def is_sorted(l):
    return all(a <= b for a, b in zip(l, l[1:]))

Eine schöne Möglichkeit, dies zu implementieren, ist die Verwendung der imapFunktion von itertools:

from itertools import imap, tee
import operator

def is_sorted(iterable, compare=operator.le):
  a, b = tee(iterable)
  next(b, None)
  return all(imap(compare, a, b))

Diese Implementierung ist schnell und funktioniert mit allen Iterables.

Ich habe einen Benchmark durchgeführt und sorted(lst, reverse=True) == lstwar der schnellste für lange Listen und all(l[i] >= l[i+1] for i in xrange(len(l)-1))der schnellste für kurze Listen . Diese Benchmarks wurden auf einem MacBook Pro 2010 13 "(Core2 Duo 2,66 GHz, 4 GB 1067 MHz DDR3-RAM, Mac OS X 10.6.5) ausgeführt.

UPDATE: Ich habe das Skript überarbeitet, damit Sie es direkt auf Ihrem eigenen System ausführen können. Die vorherige Version hatte Fehler. Außerdem habe ich sowohl sortierte als auch unsortierte Eingaben hinzugefügt.

In den meisten Fällen gibt es also einen klaren Gewinner.

UPDATE: Die Antworten von aaronsterling (Nr. 6 und Nr. 7) sind in allen Fällen die schnellsten. # 7 ist am schnellsten, da es keine Indirektionsebene zum Nachschlagen des Schlüssels gibt.

#!/usr/bin/env python

import itertools
import time

def benchmark(f, *args):
    t1 = time.time()
    for i in xrange(1000000):
        f(*args)
    t2 = time.time()
    return t2-t1

L1 = range(4, 0, -1)
L2 = range(100, 0, -1)
L3 = range(0, 4)
L4 = range(0, 100)

# 1.
def isNonIncreasing(l, key=lambda x,y: x >= y): 
    return all(key(l[i],l[i+1]) for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 2.47253704071
print benchmark(isNonIncreasing, L2) # 34.5398209095
print benchmark(isNonIncreasing, L3) # 2.1916718483
print benchmark(isNonIncreasing, L4) # 2.19576501846

# 2.
def isNonIncreasing(l):
    return all(l[i] >= l[i+1] for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 1.86919999123
print benchmark(isNonIncreasing, L2) # 21.8603689671
print benchmark(isNonIncreasing, L3) # 1.95684289932
print benchmark(isNonIncreasing, L4) # 1.95272517204

# 3.
def isNonIncreasing(l, key=lambda x,y: x >= y): 
    return all(key(a,b) for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.65468883514
print benchmark(isNonIncreasing, L2) # 29.7504849434
print benchmark(isNonIncreasing, L3) # 2.78062295914
print benchmark(isNonIncreasing, L4) # 3.73436689377

# 4.
def isNonIncreasing(l):
    return all(a >= b for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.06947803497
print benchmark(isNonIncreasing, L2) # 15.6351969242
print benchmark(isNonIncreasing, L3) # 2.45671010017
print benchmark(isNonIncreasing, L4) # 3.48461818695

# 5.
def isNonIncreasing(l):
    return sorted(l, reverse=True) == l
print benchmark(isNonIncreasing, L1) # 2.01579380035
print benchmark(isNonIncreasing, L2) # 5.44593787193
print benchmark(isNonIncreasing, L3) # 2.01813793182
print benchmark(isNonIncreasing, L4) # 4.97615599632

# 6.
def isNonIncreasing(l, key=lambda x, y: x >= y): 
    for i, el in enumerate(l[1:]):
        if key(el, l[i-1]):
            return False
    return True
print benchmark(isNonIncreasing, L1) # 1.06842684746
print benchmark(isNonIncreasing, L2) # 1.67291283607
print benchmark(isNonIncreasing, L3) # 1.39491200447
print benchmark(isNonIncreasing, L4) # 1.80557894707

# 7.
def isNonIncreasing(l):
    for i, el in enumerate(l[1:]):
        if el >= l[i-1]:
            return False
    return True
print benchmark(isNonIncreasing, L1) # 0.883186101913
print benchmark(isNonIncreasing, L2) # 1.42852401733
print benchmark(isNonIncreasing, L3) # 1.09229516983
print benchmark(isNonIncreasing, L4) # 1.59502696991

Ich würde dies tun (viele Antworten hier stehlen [Aaron Sterling, Wai Yip Tung, sorta von Paul McGuire] und hauptsächlich Armin Ronacher ):

from itertools import tee, izip

def pairwise(iterable):
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)

def is_sorted(iterable, key=lambda a, b: a <= b):
    return all(key(a, b) for a, b in pairwise(iterable))

Eine schöne Sache: Sie müssen die zweite Iteration für die Serie nicht realisieren (im Gegensatz zu einem Listen-Slice).

Ich benutze diesen Einzeiler basierend auf numpy.diff ():

def issorted(x):
    """Check if x is sorted"""
    return (numpy.diff(x) >= 0).all() # is diff between all consecutive entries >= 0?

Ich habe es nicht wirklich mit einer anderen Methode verglichen, aber ich gehe davon aus, dass es schneller ist als jede reine Python-Methode, insbesondere für große n, da die Schleife in numpy.diff (wahrscheinlich) direkt in C ausgeführt wird (n-1-Subtraktionen gefolgt von n) -1 Vergleiche).

Sie müssen jedoch vorsichtig sein, wenn x ein int ohne Vorzeichen ist, was zu einem stillen Ganzzahlunterlauf in numpy.diff () führen kann, was zu einem falsch positiven Ergebnis führt. Hier ist eine modifizierte Version:

def issorted(x):
    """Check if x is sorted"""
    try:
        if x.dtype.kind == 'u':
            # x is unsigned int array, risk of int underflow in np.diff
            x = numpy.int64(x)
    except AttributeError:
        pass # no dtype, not an array
    return (numpy.diff(x) >= 0).all()

Dies ähnelt der Top-Antwort, gefällt mir aber besser, da dadurch eine explizite Indizierung vermieden wird. Angenommen, Ihre Liste hat den Namen lst, können Sie
(item, next_item)Tupel aus Ihrer Liste generieren mit zip:

all(x <= y for x,y in zip(lst, lst[1:]))

In Python 3 wird zipbereits ein Generator zurückgegeben, in Python 2 können Sie itertools.izipfür eine bessere Speichereffizienz verwenden.

Kleine Demo:

>>> lst = [1, 2, 3, 4]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 4)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
True
>>> 
>>> lst = [1, 2, 3, 2]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 2)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
False

Der letzte schlägt fehl, wenn das Tupel (3, 2)ausgewertet wird.

Bonus: Überprüfung endlicher (!) Generatoren, die nicht indiziert werden können:

>>> def gen1():
...     yield 1
...     yield 2
...     yield 3
...     yield 4
...     
>>> def gen2():
...     yield 1
...     yield 2
...     yield 4
...     yield 3
... 
>>> g1_1 = gen1()
>>> g1_2 = gen1()
>>> next(g1_2)
1
>>> all(x <= y for x,y in zip(g1_1, g1_2))
True
>>>
>>> g2_1 = gen2()
>>> g2_2 = gen2()
>>> next(g2_2)
1
>>> all(x <= y for x,y in zip(g2_1, g2_2))
False

Stellen Sie sicher, dass Sie itertools.iziphier verwenden, wenn Sie Python 2 verwenden, da Sie sonst den Zweck umgehen würden, keine Listen von den Generatoren erstellen zu müssen.

SapphireSun ist ganz richtig. Sie können einfach verwenden lst.sort(). Die Sortierimplementierung (TimSort) von Python prüft, ob die Liste bereits sortiert ist. In diesem Fall wird sort () in linearer Zeit abgeschlossen. Klingt nach einer pythonischen Methode, um sicherzustellen, dass eine Liste sortiert ist;)

Obwohl ich nicht glaube, dass es eine Garantie dafür gibt, dass das sortedintegrierte System seine CMP-Funktion aufruft i+1, i, scheint dies für CPython der Fall zu sein.

Sie könnten also so etwas tun:

def my_cmp(x, y):
   cmpval = cmp(x, y)
   if cmpval < 0:
      raise ValueError
   return cmpval

def is_sorted(lst):
   try:
      sorted(lst, cmp=my_cmp)
      return True
   except ValueError:
      return False

print is_sorted([1,2,3,5,6,7])
print is_sorted([1,2,5,3,6,7])

Oder so (ohne wenn Aussagen -> EAFP schief gelaufen sind? ;-)):

def my_cmp(x, y):
   assert(x >= y)
   return -1

def is_sorted(lst):
   try:
      sorted(lst, cmp=my_cmp)
      return True
   except AssertionError:
      return False

Überhaupt nicht sehr pythonisch, aber wir brauchen mindestens eine reduce()Antwort, oder?

def is_sorted(iterable):
    prev_or_inf = lambda prev, i: i if prev <= i else float('inf')
    return reduce(prev_or_inf, iterable, float('-inf')) < float('inf')

Die Akkumulatorvariable speichert einfach diesen zuletzt überprüften Wert. Wenn ein Wert kleiner als der vorherige Wert ist, wird der Akkumulator auf unendlich gesetzt (und ist daher am Ende immer noch unendlich, da der 'vorherige Wert' immer größer als ist der aktuelle).

Wie von @aaronsterling festgestellt, ist die folgende Lösung die kürzeste und scheint am schnellsten zu sein, wenn das Array sortiert und nicht zu klein ist: def is_sorted (lst): return (sortiert (lst) == lst)

Wenn das Array die meiste Zeit nicht sortiert ist, ist es wünschenswert, eine Lösung zu verwenden, die nicht das gesamte Array scannt und False zurückgibt, sobald ein unsortiertes Präfix entdeckt wird. Das Folgende ist die schnellste Lösung, die ich finden konnte, sie ist nicht besonders elegant:

def is_sorted(lst):
    it = iter(lst)
    try:
        prev = it.next()
    except StopIteration:
        return True
    for x in it:
        if prev > x:
            return False
        prev = x
    return True

Mit dem Benchmark von Nathan Farrington wird in allen Fällen eine bessere Laufzeit erzielt als mit sortiert (lst), außer wenn auf der großen sortierten Liste ausgeführt wird.

Hier sind die Benchmark-Ergebnisse auf meinem Computer.

sortiert (lst) == lst Lösung

• L1: 1,23838591576
• L2: 4.19063091278
• L3: 1.17996287346
• L4: 4.68399500847

Zweite Lösung:

• L1: 0,81095790863
• L2: 0,802397012711
• L3: 1,06135106087
• L4: 8,82761001587

Wenn Sie den schnellsten Weg für Numpy-Arrays suchen, verwenden Sie Numba . Wenn Sie Conda verwenden, sollte es bereits installiert sein

Der Code ist schnell, da er von numba kompiliert wird

import numba
@numba.jit
def issorted(vec, ascending=True):
    if len(vec) < 2:
        return True
    if ascending:
        for i in range(1, len(vec)):
            if vec[i-1] > vec[i]:
                return False
        return True
    else:
        for i in range(1, len(vec)):
            if vec[i-1] < vec[i]:
                return False
        return True

und dann:

>>> issorted(array([4,9,100]))
>>> True

Nur um einen anderen Weg hinzuzufügen (auch wenn ein zusätzliches Modul erforderlich ist) iteration_utilities.all_monotone::

>>> from iteration_utilities import all_monotone
>>> listtimestamps = [1, 2, 3, 5, 6, 7]
>>> all_monotone(listtimestamps)
True

>>> all_monotone([1,2,1])
False

So überprüfen Sie die DESC-Bestellung:

>>> all_monotone(listtimestamps, decreasing=True)
False

>>> all_monotone([3,2,1], decreasing=True)
True

Es gibt auch einen strictParameter, wenn Sie streng nach monotonen Sequenzen suchen müssen (wenn aufeinanderfolgende Elemente nicht gleich sein sollten).

In Ihrem Fall ist dies kein Problem, aber wenn Ihre Sequenzen nanWerte enthalten, schlagen einige Methoden fehl, z. B. mit sortiert:

def is_sorted_using_sorted(iterable):
    return sorted(iterable) == iterable

>>> is_sorted_using_sorted([3, float('nan'), 1])  # definetly False, right?
True

>>> all_monotone([3, float('nan'), 1])
False

Beachten Sie, dass iteration_utilities.all_monotonedie Leistung im Vergleich zu den anderen hier genannten Lösungen insbesondere bei unsortierten Eingaben schneller ist (siehe Benchmark ).

Faul

from itertools import tee

def is_sorted(l):
    l1, l2 = tee(l)
    next(l2, None)
    return all(a <= b for a, b in zip(l1, l2))

Python 3.6.8

from more_itertools import pairwise

class AssertionHelper:
    @classmethod
    def is_ascending(cls, data: iter) -> bool:
        for a, b in pairwise(data):
            if a > b:
                return False
        return True

    @classmethod
    def is_descending(cls, data: iter) -> bool:
        for a, b in pairwise(data):
            if a < b:
                return False
        return True

    @classmethod
    def is_sorted(cls, data: iter) -> bool:
        return cls.is_ascending(data) or cls.is_descending(data)

>>> AssertionHelper.is_descending((1, 2, 3, 4))
False
>>> AssertionHelper.is_ascending((1, 2, 3, 4))
True
>>> AssertionHelper.is_sorted((1, 2, 3, 4))
True

Einfachster Weg:

def isSorted(arr):
  i = 1
  while i < len(arr):
    if(result[i] < result[i - 1]):
      return False
    i += 1
  return True

from functools import reduce

# myiterable can be of any iterable type (including list)
isSorted = reduce(lambda r, e: (r[0] and (r[1] or r[2] <= e), False, e), myiterable, (True, True, None))[0]

Der abgeleitete Reduktionswert ist ein dreiteiliges Tupel von ( sortiertSoFarFlag , firstTimeFlag , lastElementValue ). Es beginnt zunächst mit ( True, True, None), das auch als das Ergebnis für eine leere Liste verwendet wird (gilt als sortiert , weil es keine Out-of-Order - Elemente). Während es jedes Element verarbeitet, berechnet es neue Werte für das Tupel (unter Verwendung vorheriger Tupelwerte mit dem nächsten elementValue):

[0] (sortedSoFarFlag) evaluates true if: prev_0 is true and (prev_1 is true or prev_2 <= elementValue)
[1] (firstTimeFlag): False
[2] (lastElementValue): elementValue

Das Endergebnis der Reduzierung ist ein Tupel von:

[0]: True/False depending on whether the entire list was in sorted order
[1]: True/False depending on whether the list was empty
[2]: the last element value

Der erste Wert ist derjenige, an dem wir interessiert sind, also verwenden wir ihn [0], um ihn aus dem Reduzierungsergebnis zu ziehen.

Da ich diese Option oben nicht sehe, werde ich sie allen Antworten hinzufügen. Bezeichne die Liste mit l, dann:

import numpy as np

# Trasform the list to a numpy array
x = np.array(l)

# check if ascendent sorted:
all(x[:-1] <= x[1:])

# check if descendent sorted:
all(x[:-1] >= x[1:])

Eine Lösung mit Zuweisungsausdrücken (hinzugefügt in Python 3.8):

def is_sorted(seq):
    seq_iter = iter(seq)
    cur = next(seq_iter, None)
    return all((prev := cur) <= (cur := nxt) for nxt in seq_iter)

z = list(range(10))
print(z)
print(is_sorted(z))

import random
random.shuffle(z)
print(z)
print(is_sorted(z))

z = []
print(z)
print(is_sorted(z))

Gibt:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
True
[1, 7, 5, 9, 4, 0, 8, 3, 2, 6]
False
[]
True

Dies ist in der Tat der kürzeste Weg, dies mithilfe der Rekursion zu tun:

Wenn es sortiert ist, wird True ausgegeben, andernfalls wird False gedruckt

 def is_Sorted(lst):
    if len(lst) == 1:
       return True
    return lst[0] <= lst[1] and is_Sorted(lst[1:])

 any_list = [1,2,3,4]
 print is_Sorted(any_list)

Wie wäre es mit diesem ? Einfach und unkompliziert.

def is_list_sorted(al):

    llength =len(al)


    for i in range (llength):
        if (al[i-1] > al[i]):
            print(al[i])
            print(al[i+1])
            print('Not sorted')
            return -1

    else :
        print('sorted')
        return  true

Funktioniert definitiv in Python 3 und höher für Ganzzahlen oder Zeichenfolgen:

def tail(t):
    return t[:]

letters = ['a', 'b', 'c', 'd', 'e']
rest = tail(letters)
rest.sort()
if letters == rest:
    print ('Given list is SORTED.')
else:
    print ('List NOT Sorted.')

================================================== ===================

Eine andere Möglichkeit festzustellen, ob die angegebene Liste sortiert ist oder nicht

trees1 = list ([1, 4, 5, 3, 2])
trees2 = list (trees1)
trees2.sort()
if trees1 == trees2:
    print ('trees1 is SORTED')
else:
    print ('Not sorted')