Esiste un modo pitonico per verificare se un elenco è già ordinato in ASCoDESC

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

qualcosa del genere isttimestamps.isSorted()ritorna Trueo False.

Voglio inserire un elenco di timestamp per alcuni messaggi e verificare se le transazioni sono apparse nell'ordine corretto.

In realtà non stiamo dando la risposta che Anijhaw sta cercando. Ecco la copertina:

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

Per Python 3:

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

Vorrei solo usare

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

a meno che non sia un elenco molto grande, nel qual caso potresti voler creare una funzione personalizzata.

se hai intenzione di ordinarlo se non è ordinato, allora dimentica il segno di spunta e ordinalo.

lst.sort()

e non ci pensare troppo.

se vuoi una funzione personalizzata, puoi fare qualcosa del genere

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

Questo sarà O (n) se la lista è già ordinata (e O (n) in un forciclo in quel!) Quindi, a meno che non ti aspetti che non sia ordinata (e abbastanza casuale) la maggior parte delle volte, vorrei, di nuovo, basta ordinare l'elenco.

Questo modulo iteratore è del 10-15% più veloce rispetto all'utilizzo dell'indicizzazione di numeri interi:

# 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:]))

Un bel modo per implementare questo è usare la imapfunzione da 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))

Questa implementazione è veloce e funziona su tutti gli iterabili.

Ho eseguito un benchmark ed è sorted(lst, reverse=True) == lststato il più veloce per le liste lunghe ed è all(l[i] >= l[i+1] for i in xrange(len(l)-1))stato il più veloce per le liste brevi . Questi benchmark sono stati eseguiti su un MacBook Pro 2010 13 "(Core2 Duo 2,66 GHz, RAM DDR3 da 10 GB a 1067 MHz, Mac OS X 10.6.5).

AGGIORNAMENTO: ho rivisto lo script in modo che tu possa eseguirlo direttamente sul tuo sistema. La versione precedente aveva dei bug. Inoltre, ho aggiunto input sia ordinati che non ordinati.

Quindi nella maggior parte dei casi c'è un chiaro vincitore.

AGGIORNAMENTO: le risposte di aaronsterling (# 6 e # 7) sono in realtà le più veloci in tutti i casi. # 7 è il più veloce perché non ha un livello di riferimento indiretto per cercare la chiave.

#!/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

Lo farei (rubando da molte risposte qui [Aaron Sterling, Wai Yip Tung, una specie di Paul McGuire] e principalmente 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))

Una cosa carina: non devi realizzare il secondo iterabile per la serie (a differenza di una fetta di elenco).

Uso questo one-liner basato su numpy.diff ():

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

Non l'ho davvero cronometrato con nessun altro metodo, ma presumo sia più veloce di qualsiasi metodo Python puro, specialmente per n grande, poiché il ciclo in numpy.diff (probabilmente) viene eseguito direttamente in C (sottrazioni n-1 seguite da n -1 confronti).

Tuttavia, è necessario fare attenzione se x è un int senza segno, che potrebbe causare un underflow intero silenzioso in numpy.diff (), risultando in un falso positivo. Ecco una versione modificata:

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()

È simile alla risposta principale, ma mi piace di più perché evita l'indicizzazione esplicita. Supponendo che il tuo elenco abbia il nome lst, puoi generare
(item, next_item)tuple dal tuo elenco con zip:

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

In Python 3, ziprestituisce già un generatore, in Python 2 è possibile utilizzareitertools.izip per una migliore efficienza della memoria.

Piccola 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

L'ultimo fallisce quando la tupla (3, 2) viene valutata .

Bonus: controllo di generatori finiti (!) Che non possono essere indicizzati:

>>> 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

Assicurati di usare itertools.izipqui se stai usando Python 2, altrimenti annulleresti lo scopo di non dover creare liste dai generatori.

SapphireSun ha ragione. Puoi semplicemente usare lst.sort(). L'implementazione dell'ordinamento di Python (TimSort) controlla se l'elenco è già ordinato. In tal caso, sort () verrà completato in tempo lineare. Sembra un modo Pythonic per assicurarsi che un elenco sia ordinato;)

Anche se non credo che ci sia una garanzia per cui il sortedbuilt-in chiama la sua funzione cmp i+1, i, sembra farlo per CPython.

Quindi potresti fare qualcosa del tipo:

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])

O in questo modo (senza se le dichiarazioni -> EAFP sono andate male? ;-)):

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

Non molto Pythonic, ma abbiamo bisogno di almeno una reduce()risposta, giusto?

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')

La variabile accumulatore memorizza semplicemente l'ultimo valore verificato e, se un valore è inferiore al valore precedente, l'accumulatore viene impostato su infinito (e quindi sarà comunque infinito alla fine, poiché il "valore precedente" sarà sempre maggiore di quello attuale).

Come notato da @aaronsterling, la seguente soluzione è la più breve e sembra più veloce quando l'array è ordinato e non troppo piccolo: def is_sorted (lst): return (ordinato (lst) == lst)

Se la maggior parte delle volte l'array non viene ordinato, sarebbe preferibile utilizzare una soluzione che non analizzi l'intero array e restituisca False non appena viene scoperto un prefisso non ordinato. Di seguito è la soluzione più veloce che ho trovato, non è particolarmente elegante:

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

Utilizzando il benchmark di Nathan Farrington, si ottiene un runtime migliore rispetto all'utilizzo dell'ordinamento (lst) in tutti i casi, tranne quando si esegue su un grande elenco ordinato.

Ecco i risultati del benchmark sul mio computer.

ordinata (prima) == prima soluzione

• L1: 1.23838591576
• L2: 4.19063091278
• L3: 1.17996287346
• L4: 4.68399500847

Seconda soluzione:

• L1: 0,81095790863
• L2: 0.802397012711
• L3: 1.06135106087
• L4: 8.82761001587

Se vuoi il modo più veloce per gli array intorpiditi, usa numba , che se usi conda dovrebbe essere già installato

Il codice sarà veloce perché sarà compilato da numba

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

e poi:

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

Solo per aggiungere un altro modo (anche se richiede un modulo aggiuntivo) 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

Per verificare l'ordine DESC:

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

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

C'è anche un strictparametro se è necessario controllare le sequenze monotoniche rigorosamente (se gli elementi successivi non devono essere uguali).

Non è un problema nel tuo caso, ma se le tue sequenze contengono nanvalori, alcuni metodi falliranno, ad esempio con ordinati:

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

Si noti che offre iteration_utilities.all_monotoneprestazioni più veloci rispetto alle altre soluzioni menzionate qui, in particolare per input non ordinati (vedere benchmark ).

Pigro

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

Il modo più semplice:

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]

Il valore di riduzione derivato è una tupla in 3 parti di ( SortSoFarFlag , firstTimeFlag , lastElementValue ). Inizialmente inizia con ( True, True, None), che viene usato anche come risultato un elenco vuoto (considerata stati scelti perché non ci sono elementi out-of-ordine). Man mano che elabora ciascun elemento, calcola i nuovi valori per la tupla (utilizzando i valori di tupla precedenti con l'elemento successivo Valore):

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

Il risultato finale della riduzione è una tupla di:

[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

Il primo valore è quello a cui siamo interessati, quindi usiamo [0]per afferrarlo dal risultato di riduzione.

Poiché non vedo questa opzione sopra, la aggiungerò a tutte le risposte. Lasciate denotare l'elenco per l, quindi:

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:])

Una soluzione che utilizza espressioni di assegnazione (aggiunta 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))

dà:

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

Questo è in effetti il ​​modo più breve per farlo usando la ricorsione:

se è Ordinato stamperà True else stamperà False

 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)

Che ne dici di questo? Semplice e diretto

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

Funziona sicuramente in Python 3 e versioni successive per numeri interi o stringhe:

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.')

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

Un altro modo per scoprire se l'elenco dato è ordinato o meno

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