Có cách nào để kiểm tra xem danh sách đã được sắp xếp trong ASChay khôngDESC

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

một cái gì đó như thế isttimestamps.isSorted()trở lại Truehoặc False.

Tôi muốn nhập danh sách dấu thời gian cho một số tin nhắn và kiểm tra xem các giao dịch có xuất hiện theo đúng thứ tự không.

Thật ra chúng tôi không đưa ra câu trả lời mà anijhaw đang tìm kiếm. Đây là một lót:

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

Đối với Python 3:

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

Tôi sẽ chỉ sử dụng

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

trừ khi đó là một danh sách rất lớn trong trường hợp bạn có thể muốn tạo một chức năng tùy chỉnh.

nếu bạn chỉ sắp xếp nó nếu nó không được sắp xếp, thì hãy quên kiểm tra và sắp xếp nó.

lst.sort()

và đừng nghĩ về nó quá nhiều

nếu bạn muốn một chức năng tùy chỉnh, bạn có thể làm một cái gì đó như

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

Đây sẽ là O (n) nếu danh sách đã được sắp xếp mặc dù (và O (n) trong một forvòng lặp ở đó!) Vì vậy, trừ khi bạn dự kiến ​​nó sẽ không được sắp xếp (và khá ngẫu nhiên), tôi sẽ, một lần nữa, chỉ cần sắp xếp danh sách.

Hình thức lặp này nhanh hơn 10-15% so với sử dụng lập chỉ mục số nguyên:

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

Một cách hay để thực hiện điều này là sử dụng imaphàm từ 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))

Việc thực hiện này là nhanh chóng và hoạt động trên bất kỳ iterables nào.

Tôi đã chạy một điểm chuẩn và sorted(lst, reverse=True) == lstlà nhanh nhất cho danh sách dài, và all(l[i] >= l[i+1] for i in xrange(len(l)-1))là nhanh nhất cho danh sách ngắn . Các điểm chuẩn này được chạy trên MacBook Pro 2010 13 "(Core2 Duo 2.66GHz, RAM DDR3 4GB 1067 MHz, Mac OS X 10.6.5).

CẬP NHẬT: Tôi đã sửa đổi tập lệnh để bạn có thể chạy nó trực tiếp trên hệ thống của riêng bạn. Phiên bản trước có lỗi. Ngoài ra, tôi đã thêm cả đầu vào được sắp xếp và chưa sắp xếp.

Vì vậy, trong hầu hết các trường hợp có một người chiến thắng rõ ràng.

CẬP NHẬT: câu trả lời của aaronsterling (# 6 và # 7) thực sự là nhanh nhất trong mọi trường hợp. # 7 là nhanh nhất vì nó không có lớp cảm ứng để tra cứu khóa.

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

Tôi sẽ làm điều này (đánh cắp từ rất nhiều câu trả lời ở đây [Aaron Sterling, Wai Yip Tung, sorta từ Paul McGuire] và chủ yếu là 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))

Một điều tuyệt vời: bạn không cần phải nhận ra lần lặp thứ hai cho loạt bài (không giống như một lát danh sách).

Tôi sử dụng một lớp lót này dựa trên numpy.diff ():

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

Tôi chưa thực sự hẹn giờ với bất kỳ phương thức nào khác, nhưng tôi cho rằng nó nhanh hơn bất kỳ phương thức Python thuần túy nào, đặc biệt là đối với n lớn, vì vòng lặp trong numpy.diff (có thể) chạy trực tiếp trong C (phép trừ n-1 theo sau n -1 so sánh).

Tuy nhiên, bạn cần cẩn thận nếu x là một số nguyên không dấu, điều này có thể gây ra dòng số nguyên im lặng trong numpy.diff (), dẫn đến kết quả dương tính giả. Đây là phiên bản sửa đổi:

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

Điều này tương tự như câu trả lời hàng đầu, nhưng tôi thích nó hơn vì nó tránh được việc lập chỉ mục rõ ràng. Giả sử danh sách của bạn có tên lst, bạn có thể tạo
(item, next_item)bộ dữ liệu từ danh sách của mình bằng zip:

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

Trong Python 3, zipđã trả về một trình tạo, trong Python 2 bạn có thể sử dụng itertools.izipđể có hiệu quả bộ nhớ tốt hơn.

Bản demo nhỏ:

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

Cái cuối cùng thất bại khi bộ dữ liệu (3, 2)được đánh giá.

Phần thưởng: kiểm tra các trình tạo hữu hạn (!) Không thể lập chỉ mục:

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

Đảm bảo sử dụng itertools.izipở đây nếu bạn đang sử dụng Python 2, nếu không bạn sẽ đánh bại mục đích không phải tạo danh sách từ các trình tạo.

SapphireSun hoàn toàn đúng. Bạn chỉ có thể sử dụng lst.sort(). Việc thực hiện sắp xếp của Python (TimSort) kiểm tra xem danh sách đã được sắp xếp chưa. Nếu vậy sort () sẽ hoàn thành trong thời gian tuyến tính. Âm thanh giống như một cách Pythonic để đảm bảo danh sách được sắp xếp;)

Mặc dù tôi không nghĩ có một sự đảm bảo nào cho việc tích sortedhợp gọi hàm cmp của nó với i+1, i, nhưng dường như nó làm như vậy đối với CPython.

Vì vậy, bạn có thể làm một cái gì đó như:

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

Hoặc theo cách này (không có câu lệnh if -> EAFP bị sai? ;-)):

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

Không phải là rất Pythonic, nhưng chúng ta cần ít nhất một reduce()câu trả lời, phải không?

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

Biến tích lũy chỉ đơn giản là lưu trữ giá trị được kiểm tra lần cuối đó và nếu bất kỳ giá trị nào nhỏ hơn giá trị trước đó, thì bộ tích lũy được đặt thành vô cùng (và do đó sẽ vẫn là vô cùng ở cuối, vì 'giá trị trước' sẽ luôn lớn hơn cái hiện tại).

Như đã lưu ý bởi @aaronsterling, giải pháp sau đây là ngắn nhất và dường như nhanh nhất khi mảng được sắp xếp và không quá nhỏ: def is_sort (lst): return (sort (lst) == lst)

Nếu hầu hết thời gian mảng không được sắp xếp, bạn nên sử dụng giải pháp không quét toàn bộ mảng và trả về Sai ngay khi phát hiện ra tiền tố chưa được sắp xếp. Sau đây là giải pháp nhanh nhất tôi có thể tìm thấy, nó không đặc biệt thanh lịch:

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

Sử dụng điểm chuẩn của Nathan Farrington, điều này đạt được thời gian chạy tốt hơn so với sử dụng sắp xếp (lst) trong mọi trường hợp ngoại trừ khi chạy trên danh sách được sắp xếp lớn.

Dưới đây là kết quả điểm chuẩn trên máy tính của tôi.

đã sắp xếp (lst) == giải pháp lst

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

Giải pháp thứ hai:

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

Nếu bạn muốn cách nhanh nhất cho mảng numpy, hãy sử dụng numba , nếu bạn sử dụng conda thì đã được cài đặt

Mã sẽ nhanh bởi vì nó sẽ được biên dịch bởi 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

và sau đó:

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

Chỉ cần thêm một cách khác (ngay cả khi nó yêu cầu một mô-đun bổ sung) 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

Để kiểm tra thứ tự DESC:

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

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

Ngoài ra còn có một stricttham số nếu bạn cần kiểm tra nghiêm ngặt (nếu các yếu tố kế tiếp không nên bằng nhau) các chuỗi đơn điệu.

Đây không phải là vấn đề trong trường hợp của bạn nhưng nếu chuỗi của bạn chứa nancác giá trị thì một số phương thức sẽ thất bại, ví dụ như được sắp xếp:

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

Lưu ý rằng iteration_utilities.all_monotonethực hiện nhanh hơn so với các giải pháp khác được đề cập ở đây, đặc biệt là đối với các đầu vào chưa được sắp xếp (xem điểm chuẩn ).

Lười biếng

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

Cách đơn giản nhất:

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]

Giá trị giảm có nguồn gốc là một bộ gồm 3 phần ( sortSoFarFlag , firstTimeFlag , lastEuityValue ). Nó ban đầu bắt đầu với ( True, True, None), mà còn được sử dụng như là kết quả cho một danh sách rỗng (coi như được sắp xếp bởi vì không có out-of-trật tự các yếu tố). Khi nó xử lý từng phần tử, nó sẽ tính toán các giá trị mới cho bộ dữ liệu (sử dụng các giá trị bộ dữ liệu trước đó với phần tửValue tiếp theo):

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

Kết quả cuối cùng của việc giảm là một tuple của:

[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

Giá trị đầu tiên là giá trị chúng tôi quan tâm, vì vậy chúng tôi sử dụng [0]để lấy giá trị đó từ kết quả giảm.

Vì tôi không thấy tùy chọn này ở trên nên tôi sẽ thêm nó vào tất cả các câu trả lời. Hãy biểu thị danh sách theo l, sau đó:

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

Một giải pháp sử dụng biểu thức gán (được thêm vào 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))

Cung cấp:

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

Trên thực tế đây là cách ngắn nhất để thực hiện bằng cách sử dụng đệ quy:

nếu nó được sắp xếp sẽ in đúng, người khác sẽ in sai

 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)

Cái này thì sao? Đơn giản và dễ hiểu.

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

Chắc chắn hoạt động trong Python 3 trở lên cho số nguyên hoặc chuỗi:

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

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

Một cách khác để tìm xem danh sách đã cho có được sắp xếp hay không

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