web-dev-qa-db-ja.com

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

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

例：

[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
pythonlistperformance
58
Jonathan
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)
134
6502

数の大きなリストがある場合は、numpyを使用するのが最善かもしれません。

import numpy as np

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

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

33
Autoplectic
_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)です。

25
Michael J. Barber

@ 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))
15
Jochen Ritzel
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:]))
4
akira

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

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's answer およびその高速に対してパフォーマンスをテストしました。

ケース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
2
BigOther

さまざまな条件下でこの質問のすべての答えを時間を計ったところ、次のことがわかりました。

  • リストがすでに単調に増加している場合、ソートはロングショットで最速でした
  • リストがシャッフル/ランダムである場合、または要素の数が順不同の場合、ソートはロングショットで最も遅くなりました。コースのリストが乱れているほど、結果は遅くなります。
  • リストがほとんど単調に増加している場合、または完全にランダムな場合、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. 郵便番号

リストがほとんど単調に増加している場合（list_method == 2）、最速から最速まで：

  1. スターマップ
  2. 郵便番号
  3. 正常
  4. ソート済み

（スターマップまたはZipが実行に最も速く依存していたかどうかにかかわらず、パターンを特定できませんでした。通常、スターマップはより高速に見えました）

リストが完全にランダムな場合（list_method == 3）、最速から最速まで：

  1. スターマップ
  2. 郵便番号
  3. 正常
  4. ソート済み（非常に悪い）
1
Matthew Moisen
L = [1,2,3]
L == sorted(L)

L == sorted(L, reverse=True)
1
Asterisk

これは、pip install pandasを介してインストールできる Pandas を使用して可能です。

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