Bir listenin önceden sıralanıp sıralanmadığını kontrol etmenin pythonic bir yolu var mı ASCveyaDESC

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

böyle bir şey isttimestamps.isSorted()geri döner Trueveya False.

Bazı mesajlar için zaman damgalarının bir listesini girmek ve işlemlerin doğru sırada görünüp görünmediğini kontrol etmek istiyorum.

Aslında anijhaw'un aradığı cevabı vermiyoruz. İşte bir astar:

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

Python 3 için:

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

Sadece kullanırdım

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

çok büyük bir liste değilse, bu durumda özel bir işlev oluşturmak isteyebilirsiniz.

eğer sıralanmamışsa sıralayacaksanız, çekleri unutun ve sıralayın.

lst.sort()

ve fazla düşünmeyin.

özel bir işlev istiyorsanız, böyle bir şey yapabilirsiniz

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

Liste zaten sıralanmışsa (ve O (n) bir fordöngüde!) O (n) olacaktır , bu yüzden çoğu zaman sıralanmamasını (ve oldukça rastgele) beklemediğiniz sürece, tekrar listeyi sıralayın.

Bu yineleyici formu, tamsayı dizine eklemekten% 10-15 daha hızlıdır:

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

Bunu uygulamanın güzel bir yolu, imapişlevi şu yöntemlerden kullanmaktır 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))

Bu uygulama hızlıdır ve tüm yinelenebilirler üzerinde çalışır.

Ben bir kriter koştu ve sorted(lst, reverse=True) == lstuzun listeler all(l[i] >= l[i+1] for i in xrange(len(l)-1))için en hızlı ve kısa listeler için en hızlı oldu . Bu kriterler bir MacBook Pro 2010 13 "(Core2 Duo 2.66GHz, 4GB 1067MHz DDR3 RAM, Mac OS X 10.6.5) üzerinde çalıştırıldı.

GÜNCELLEME: Komut dosyasını doğrudan kendi sisteminizde çalıştırabilmeniz için revize ettim. Önceki sürümde hatalar vardı. Ayrıca, hem sıralı hem de sıralanmamış girdileri ekledim.

Yani çoğu durumda açık bir kazanan var.

GÜNCELLEME: aaronsterling'in cevapları (# 6 ve # 7) aslında her durumda en hızlısıdır. # 7 en hızlısıdır çünkü anahtarı aramak için dolaylı bir katmanı yoktur.

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

Bunu yapardım (burada birçok cevaptan çalmak [Aaron Sterling, Wai Yip Tung, Paul McGuire'dan sorta] ve çoğunlukla 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))

Güzel bir şey: dizi için ikinci yinelenebilir (bir liste dilimi aksine) fark etmek zorunda değilsiniz.

Bu tek astar numpy.diff () dayalı kullanın:

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

Başka bir yönteme karşı gerçekten zamanlamadım, ancak numpy.diff (muhtemelen) içindeki döngü doğrudan C (n-1 çıkarma ve ardından n ile çalışır) -1 karşılaştırmaları).

Ancak, x işaretsiz bir int ise dikkatli olmanız gerekir; bu da numpy.diff () öğesinde sessiz tamsayı taşmasına neden olarak yanlış pozitif oluşturur. İşte değiştirilmiş bir sürüm:

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

Bu üst cevaba benzer, ancak daha iyi seviyorum çünkü açık indeksleme önlemek. Listenizde adın olduğu varsayılarak, listenizden tuples lstoluşturabilirsiniz :
(item, next_item)zip

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

Python 3'te, zipzaten bir jeneratör döndürür, Python 2'de itertools.izipdaha iyi bellek verimliliği için kullanabilirsiniz .

Küçük 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

Sonuncusu, demet (3, 2)değerlendirildiğinde başarısız olur .

Bonus: endekslenemeyen sonlu (!) Jeneratörleri kontrol etmek:

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

itertools.izipPython 2 kullanıyorsanız burada kullandığınızdan emin olun , aksi takdirde jeneratörlerden liste oluşturmak zorunda kalmazsınız.

SapphireSun oldukça haklı. Sadece kullanabilirsiniz lst.sort(). Python'un sıralama uygulaması (TimSort) listenin önceden sıralanıp sıralanmadığını kontrol eder. Öyleyse sort () doğrusal zamanda tamamlanacaktır. Bir listenin sıralandığından emin olmak için Pythonic bir yol gibi geliyor;)

Her ne kadar sortedyerleşik cmp işlevini çağırır için bir garanti olduğunu düşünmese de, i+1, iCPython için böyle görünüyor.

Böylece şöyle bir şey yapabilirsiniz:

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

Veya bu şekilde (if ifadeleri olmadan -> EAFP yanlış mı gitti? ;-)):

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

Çok Pythonic değil, ama en az bir reduce()cevaba ihtiyacımız var , değil mi?

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

Akümülatör değişkeni, son kontrol edilen değeri basitçe depolar ve herhangi bir değer önceki değerden daha küçükse, akümülatör sonsuza ayarlanır (ve böylece yine de sonunda sonsuz olacaktır), çünkü 'önceki değer' her zamankinden daha büyük olacaktır mevcut).

@Aaronsterling tarafından belirtildiği gibi, aşağıdaki çözüm en kısa olanıdır ve dizi sıralandığında ve çok küçük olmadığında en hızlı görünür: def is_sorted (lst): return (sıralanmış (lst) == lst)

Dizinin çoğu zaman sıralanmazsa, dizinin tamamını taramayan ve sıralanmamış bir önek bulunur keşfedilmez False değerini döndüren bir çözüm kullanılması istenir. Aşağıda bulabildiğim en hızlı çözüm, özellikle zarif değil:

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

Nathan Farrington'un karşılaştırmalı değerlendirmesini kullanarak, bu, büyük sıralı listede çalışmak dışında tüm durumlarda sıralı (lst) kullanmaktan daha iyi çalışma zamanı sağlar.

İşte bilgisayarımdaki karşılaştırma sonuçları.

sıralanmış (lst) == lst çözümü

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

İkinci çözüm:

• L1: 0.81095790863
• L2: 0.802397012711
• L3: 1.06135106087
• L4: 8.82761001587

Numpy dizileri için en hızlı yolu istiyorsanız, conda kullanıyorsanız zaten kurulmuş olması gereken numba kullanın

Kod hızlı olacak çünkü numba tarafından derlenecek

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

ve sonra:

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

Başka bir yol eklemek için (ek bir modül gerektirse bile) 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

DESC siparişini kontrol etmek için:

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

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

Ayrıca, strictmonotonik dizileri kesinlikle (ardışık elemanlar eşit değilse) kontrol etmeniz gerekiyorsa bir parametre de vardır .

Bu sizin durumda bir sorun değil ama eğer senin dizileri içeren nandeğerleri sıralanmış ile sonra bazı yöntemler örneğin, başarısız olur:

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

Not, iteration_utilities.all_monotonediğer çözümlerle karşılaştırıldığında gerçekleştirir hızlı (bakınız özellikle sıralanmamış girişler için burada sözü edilen kriter ).

Tembel

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

En basit yol:

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]

Türetilmiş azaltma değeri 3'lü bir demettir ( sortSoFarFlag , firstTimeFlag , lastElementValue ). Başlangıçta (başlar True, True, None), aynı zamanda, boş bir listesi için sonuç olarak kullanılan (bir dışı amacıyla elemanları vardır, çünkü kriteri olarak). Her öğeyi işlerken grup için yeni değerler hesaplar (sonraki elementValue ile önceki grup değerlerini kullanarak):

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

İndirgemenin nihai sonucu aşağıdakilerin bir demetidir:

[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

İlk değer, ilgilendiğimiz değerdir, bu yüzden bunu [0]indirgeme sonucundan almak için kullanırız.

Yukarıda bu seçeneği görmediğim için tüm cevaplara ekleyeceğim. Listeyi şu şekilde gösterelim l:

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

Ödev ifadelerini kullanan bir çözüm (Python 3.8'de eklenmiştir):

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

verir:

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

Aslında bu özyineleme kullanarak yapmanın en kısa yoludur:

Sorted ise yazdırılacak Doğru başka yazdırılacak Yanlış

 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)

Buna ne dersin ? Basit ve anlaşılır.

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

Tamsayılar veya dizgiler için kesinlikle Python 3 ve üzeri sürümlerde çalışır:

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

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

Verilen listenin sıralanıp sıralanmadığını bulmanın başka bir yolu

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