पायथन - सूची नीरसता की जांच कैसे करें

Question 1

सूची एकरसता की जाँच करने के लिए एक कुशल और पाइथोनिक तरीका क्या होगा ?
इसका मतलब यह है कि इसमें मूल्यों में वृद्धि या कमी आई है?

उदाहरण:

[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

Question 2

"बढ़ती" या "घटती" जैसी अस्पष्ट शर्तों से बचना बेहतर है क्योंकि यह स्पष्ट नहीं है कि समानता स्वीकार्य है या नहीं। आपको हमेशा या तो "गैर-बढ़ती" (स्पष्ट रूप से समानता को स्वीकार किया जाता है) या "सख्ती से घटने" (स्पष्ट रूप से समानता को स्वीकार नहीं किया जाता है) के लिए उपयोग करना चाहिए।

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)

Question 3

यदि आपके पास संख्याओं की बड़ी सूची है, तो यह संख्या का उपयोग करने के लिए सबसे अच्छा हो सकता है, और यदि आप हैं:

import numpy as np

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

चाल चलनी चाहिए।

Question 4

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)सूची की लंबाई में है।

Question 5

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

Question 6

पांडा पैकेज इस सुविधाजनक बनाता है।

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

नीरस रूप से कम (reasing):

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

Question 7

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

Question 8

यहाँ 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 के उत्तर और इसके तेज के खिलाफ इसके प्रदर्शन का परीक्षण किया ।

मामला सच: [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 तत्व से मामला गलत[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

Question 9

मैंने इस प्रश्न के सभी उत्तर अलग-अलग परिस्थितियों में दिए, और पाया कि:

सॉर्टिंग एक लंबे शॉट द्वारा सबसे तेज़ थी यदि सूची पहले से ही मोनोटोनिक रूप से बढ़ रही थी
सॉर्टिंग एक लंबे शॉट द्वारा सबसे धीमी थी यदि सूची को फेरबदल / यादृच्छिक किया गया था या यदि आदेश से बाहर तत्वों की संख्या ~ 1 से अधिक थी। पाठ्यक्रम की सूची के बाहर अधिक धीमी गति के परिणाम से मेल खाती है।
माइकल जे। नाइयों पद्धति सबसे तेज़ थी यदि सूची ज्यादातर नीरस रूप से बढ़ रही थी, या पूरी तरह से यादृच्छिक थी।

यहाँ इसे आज़माने का कोड है:

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), सबसे तेज़ सबसे धीमी थी:

क्रमबद्ध
स्टार्मप
साधारण
ज़िप

यदि सूची ज्यादातर नीरस रूप से बढ़ रही थी ( list_method == 2), सबसे तेज़ सबसे धीमी थी:

स्टार्मप
ज़िप
साधारण
क्रमबद्ध

(स्टैरमैप या जिप तेजी से निष्पादन पर निर्भर था या नहीं और मैं एक पैटर्न की पहचान नहीं कर सका। स्ट्रैपैप आमतौर पर दिखाई देता है)

यदि सूची पूरी तरह से यादृच्छिक थी ( list_method == 3), सबसे तेज़ सबसे धीमी थी:

स्टार्मप
ज़िप
साधारण
क्रमबद्ध (अत्यंत खराब)

Question 10

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

L == sorted(L, reverse=True)

Question 11

@ 6502 में इसके लिए सुरुचिपूर्ण अजगर कोड है। यहां सरल पुनरावृत्तियों के साथ एक वैकल्पिक समाधान है और संभावित रूप से महंगी अस्थायी स्लाइस नहीं हैं:

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)

Question 12

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

Question 13

यहां एक ऐसा संस्करण है जो भौतिक और गैर-भौतिक दोनों अनुक्रमों को स्वीकार करता है । यह स्वचालित रूप से निर्धारित करता है कि क्या है या नहीं 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एप्रोच नियोजित करता है : जैसे एज-सीक्वेंस (जैसे खाली या एक-आइटम सीक्वेंस; या सभी समान वस्तुओं के साथ अनुक्रम); एकरसता, सख्ती और इसी तरह बढ़ती या घटती पहचान। मुझे उम्मीद है यह मदद करेगा।