Python - Comment vérifier la monotonicité d'une liste ?

Question

Qu'est-ce qui serait un efficace et pythonique Comment vérifier la monotonicité d'une liste ?
c'est-à-dire qu'il a des valeurs monotones croissantes ou décroissantes ?

Exemples :

[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

Answer 1

Il est préférable d'éviter les termes ambigus comme "croissant" ou "décroissant", car on ne sait pas si l'égalité est acceptable ou non. Vous devez toujours utiliser, par exemple, "non croissant" (l'égalité est clairement acceptée) ou "strictement décroissant" (l'égalité n'est clairement PAS acceptée).

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)

Answer 2

Si vous avez de grandes listes de nombres, il peut être préférable d'utiliser numpy, et si c'est le cas :

import numpy as np

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

devrait faire l'affaire.

Answer 3

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)

Cette approche est O(N) dans la longueur de la liste.

Answer 4

@6502 a le code parfait pour les listes, je veux juste ajouter une version générale qui fonctionne pour toutes les séquences :

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

Answer 5

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