Python-リストの単調性をチェックする方法

リストの単調性をチェックするための効率的でPythonの方法は何でしょうか？
つまり、値が単調に増加または減少しているということですか？

例：

[0, 1, 2, 3, 3, 4]   # This is a monotonically increasing list
[4.3, 4.2, 4.2, -2]  # This is a monotonically decreasing list
[2, 3, 1]            # This is neither

平等が受け入れられるかどうかが明確でないため、「増加する」や「減少する」などのあいまいな用語は避けることをお勧めします。たとえば、「増加しない」（明らかに平等が受け入れられる）または「厳密に減少する」（明らかに平等が受け入れられない）のいずれかを常に使用する必要があります。

def strictly_increasing(L):
    return all(x<y for x, y in zip(L, L[1:]))

def strictly_decreasing(L):
    return all(x>y for x, y in zip(L, L[1:]))

def non_increasing(L):
    return all(x>=y for x, y in zip(L, L[1:]))

def non_decreasing(L):
    return all(x<=y for x, y in zip(L, L[1:]))

def monotonic(L):
    return non_increasing(L) or non_decreasing(L)

数字のリストが大きい場合は、numpyを使用するのが最適な場合があります。

import numpy as np

def monotonic(x):
    dx = np.diff(x)
    return np.all(dx <= 0) or np.all(dx >= 0)

トリックを行う必要があります。

import itertools
import operator

def monotone_increasing(lst):
    pairs = zip(lst, lst[1:])
    return all(itertools.starmap(operator.le, pairs))

def monotone_decreasing(lst):
    pairs = zip(lst, lst[1:])
    return all(itertools.starmap(operator.ge, pairs))

def monotone(lst):
    return monotone_increasing(lst) or monotone_decreasing(lst)

このアプローチはO(N)リストの長さにあります。

@ 6502にはリストに最適なコードがあります。すべてのシーケンスで機能する一般的なバージョンを追加したいだけです。

def pairwise(seq):
    items = iter(seq)
    last = next(items)
    for item in items:
        yield last, item
        last = item

def strictly_increasing(L):
    return all(x<y for x, y in pairwise(L))

def strictly_decreasing(L):
    return all(x>y for x, y in pairwise(L))

def non_increasing(L):
    return all(x>=y for x, y in pairwise(L))

def non_decreasing(L):
    return all(x<=y for x, y in pairwise(L))

パンダのパッケージには、これは便利です。

import pandas as pd

次のコマンドは、整数または浮動小数点数のリストを処理します。

単調に増加する（≥）：

pd.Series(mylist).is_monotonic_increasing

厳密に単調に増加する（>）：

myseries = pd.Series(mylist)
myseries.is_unique and myseries.is_monotonic_increasing

文書化されていないプライベートメソッドを使用する代替方法：

pd.Index(mylist)._is_strictly_monotonic_increasing

単調に減少する（≤）：

pd.Series(mylist).is_monotonic_decreasing

厳密に単調に減少する（<）：

myseries = pd.Series(mylist)
myseries.is_unique and myseries.is_monotonic_decreasing

文書化されていないプライベートメソッドを使用する代替方法：

pd.Index(mylist)._is_strictly_monotonic_decreasing

import operator, itertools

def is_monotone(lst):
    op = operator.le            # pick 'op' based upon trend between
    if not op(lst[0], lst[-1]): # first and last element in the 'lst'
        op = operator.ge
    return all(op(x,y) for x, y in itertools.izip(lst, lst[1:]))

reduce複雑さを使用した機能的なソリューションはO(n)次のとおりです。

is_increasing = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999

is_decreasing = lambda L: reduce(lambda a,b: b if a > b else -9999 , L)!=-9999

9999値の上限と下限に置き換えます-9999。あなたは数字の一覧をテストしている場合たとえば、あなたは使用することができる10と-1。

私は@ 6502の答えとそのより速いものに対してその性能をテストしました。

ケースTrue： [1,2,3,4,5,6,7,8,9]

# my solution .. 
$ python -m timeit "inc = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999; inc([1,2,3,4,5,6,7,8,9])"
1000000 loops, best of 3: 1.9 usec per loop

# while the other solution:
$ python -m timeit "inc = lambda L: all(x<y for x, y in zip(L, L[1:]));inc([1,2,3,4,5,6,7,8,9])"
100000 loops, best of 3: 2.77 usec per loop

2番目の要素からのケースFalse[4,2,3,4,5,6,7,8,7] ::

# my solution .. 
$ python -m timeit "inc = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999; inc([4,2,3,4,5,6,7,8,7])"
1000000 loops, best of 3: 1.87 usec per loop

# while the other solution:
$ python -m timeit "inc = lambda L: all(x<y for x, y in zip(L, L[1:]));inc([4,2,3,4,5,6,7,8,7])"
100000 loops, best of 3: 2.15 usec per loop

私はこの質問のすべての回答をさまざまな条件下で計時し、次のことを発見しました。

• リストがすでに単調に増加している場合、ソートはロングショットで最速でした
• リストがシャッフル/ランダムである場合、または順序が狂っている要素の数が約1より大きい場合、ソートはロングショットで最も遅くなりました。もちろん、リストの順序が狂っているほど、結果は遅くなります。
• リストがほとんど単調に増加するか、完全にランダムである場合、Michael J.Barbersメソッドが最速でした。

これを試すためのコードは次のとおりです。

import timeit

setup = '''
import random
from itertools import izip, starmap, islice
import operator

def is_increasing_normal(lst):
    for i in range(0, len(lst) - 1):
        if lst[i] >= lst[i + 1]:
            return False
    return True

def is_increasing_zip(lst):
    return all(x < y for x, y in izip(lst, islice(lst, 1, None)))

def is_increasing_sorted(lst):
    return lst == sorted(lst)

def is_increasing_starmap(lst):
    pairs = izip(lst, islice(lst, 1, None))
    return all(starmap(operator.le, pairs))

if {list_method} in (1, 2):
    lst = list(range({n}))
if {list_method} == 2:
    for _ in range(int({n} * 0.0001)):
        lst.insert(random.randrange(0, len(lst)), -random.randrange(1,100))
if {list_method} == 3:
    lst = [int(1000*random.random()) for i in xrange({n})]
'''

n = 100000
iterations = 10000
list_method = 1

timeit.timeit('is_increasing_normal(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)

timeit.timeit('is_increasing_zip(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)

timeit.timeit('is_increasing_sorted(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)

timeit.timeit('is_increasing_starmap(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)

リストがすでに単調に増加している場合（list_method == 1）、最も速いものから最も遅いものは次のとおりです。

1. ソート済み
2. 星図
3. 正常
4. zip

リストがほぼ単調に増加している場合（list_method == 2）、最も速いものから最も遅いものは次のとおりです。

1. 星図
2. zip
3. 正常
4. ソート済み

（スターマップまたはzipが最速であるかどうかは実行に依存し、パターンを識別できませんでした。スターマップは通常、より高速であるように見えました）

リストが完全にランダムである場合（list_method == 3）、最も速いものから最も遅いものは次のとおりです。

1. 星図
2. zip
3. 正常
4. ソート済み（非常に悪い）

L = [1,2,3]
L == sorted(L)

L == sorted(L, reverse=True)

@ 6502にはこのためのエレガントなPythonコードがあります。これは、より単純なイテレータを使用し、潜在的に高価な一時スライスを使用しない代替ソリューションです。

def strictly_increasing(L):
    return all(L[i] < L[i+1] for i in range(len(L)-1))

def strictly_decreasing(L):
    return all(L[i] > L[i+1] for i in range(len(L)-1))

def non_increasing(L):
    return all(L[i] >= L[i+1] for i in range(len(L)-1))

def non_decreasing(L):
    return all(L[i] <= L[i+1] for i in range(len(L)-1))

def monotonic(L):
    return non_increasing(L) or non_decreasing(L)

>>> l = [0,1,2,3,3,4]
>>> l == sorted(l) or l == sorted(l, reverse=True)

ここで両者が受け入れ変種だマテリアライズドおよび非実体化シーケンスが。それがそうであるかどうかmonotonic、もしそうなら、その方向（すなわちincreasingまたはdecreasing）とstrict性質を自動的に決定します。インラインコメントは、読者を助けるために提供されています。最後に提供されるテストケースについても同様です。

    def isMonotonic(seq):
    """
    seq.............: - A Python sequence, materialized or not.
    Returns.........:
       (True,0,True):   - Mono Const, Strict: Seq empty or 1-item.
       (True,0,False):  - Mono Const, Not-Strict: All 2+ Seq items same.
       (True,+1,True):  - Mono Incr, Strict.
       (True,+1,False): - Mono Incr, Not-Strict.
       (True,-1,True):  - Mono Decr, Strict.
       (True,-1,False): - Mono Decr, Not-Strict.
       (False,None,None) - Not Monotonic.
    """    
    items = iter(seq) # Ensure iterator (i.e. that next(...) works).
    prev_value = next(items, None) # Fetch 1st item, or None if empty.
    if prev_value == None: return (True,0,True) # seq was empty.

    # ============================================================
    # The next for/loop scans until it finds first value-change.
    # ============================================================
    # Ex: [3,3,3,78,...] --or- [-5,-5,-5,-102,...]
    # ============================================================
    # -- If that 'change-value' represents an Increase or Decrease,
    #    then we know to look for Monotonically Increasing or
    #    Decreasing, respectively.
    # -- If no value-change is found end-to-end (e.g. [3,3,3,...3]),
    #    then it's Monotonically Constant, Non-Strict.
    # -- Finally, if the sequence was exhausted above, which means
    #    it had exactly one-element, then it Monotonically Constant,
    #    Strict.
    # ============================================================
    isSequenceExhausted = True
    curr_value = prev_value
    for item in items:
        isSequenceExhausted = False # Tiny inefficiency.
        if item == prev_value: continue
        curr_value = item
        break
    else:
        return (True,0,True) if isSequenceExhausted else (True,0,False)
    # ============================================================

    # ============================================================
    # If we tricked down to here, then none of the above
    # checked-cases applied (i.e. didn't short-circuit and
    # 'return'); so we continue with the final step of
    # iterating through the remaining sequence items to
    # determine Monotonicity, direction and strictness.
    # ============================================================
    strict = True
    if curr_value > prev_value: # Scan for Increasing Monotonicity.
        for item in items:
            if item < curr_value: return (False,None,None)
            if item == curr_value: strict = False # Tiny inefficiency.
            curr_value = item
        return (True,+1,strict)
    else:                       # Scan for Decreasing Monotonicity.
        for item in items: 
            if item > curr_value: return (False,None,None)
            if item == curr_value: strict = False # Tiny inefficiency.
            curr_value = item
        return (True,-1,strict)
    # ============================================================


# Test cases ...
assert isMonotonic([1,2,3,4])     == (True,+1,True)
assert isMonotonic([4,3,2,1])     == (True,-1,True)
assert isMonotonic([-1,-2,-3,-4]) == (True,-1,True)
assert isMonotonic([])            == (True,0,True)
assert isMonotonic([20])          == (True,0,True)
assert isMonotonic([-20])         == (True,0,True)
assert isMonotonic([1,1])         == (True,0,False)
assert isMonotonic([1,-1])        == (True,-1,True)
assert isMonotonic([1,-1,-1])     == (True,-1,False)
assert isMonotonic([1,3,3])       == (True,+1,False)
assert isMonotonic([1,2,1])       == (False,None,None)
assert isMonotonic([0,0,0,0])     == (True,0,False)

私は、これは、より可能性と仮定しPythonic、それは（例えば、中間コレクションを作成回避するので、それはトリッキーだlist、genexpsなど）。また、fall/trickle-throughとshort-circuitアプローチを使用して、さまざまなケースをフィルタリングします。たとえば、エッジシーケンス（空のシーケンスや1つのアイテムのシーケンス、またはすべて同じアイテムのシーケンスなど）。単調性、厳密性などの増加または減少を識別します。お役に立てば幸いです。