किसी सूची के अंतिम आइटम के माध्यम से लूप कैसे करें?

Question

मैं एक सूची के माध्यम से लूप करना चाहूंगा जो प्रत्येक आइटम की जांच कर रहा हो।

वहाँ एक तरीका है मैं सभी के माध्यम से पाश कर सकते हैं, लेकिन अंतिम आइटम के लिए x में y का उपयोग कर रहा है? यदि मैं कर सकता हूं तो मैं अनुक्रमित का उपयोग किए बिना इसे करना पसंद करूंगा।

ध्यान दें

फ्रीस्पैस ने मेरे वास्तविक प्रश्न का उत्तर दिया, जिसके कारण मैंने उत्तर स्वीकार कर लिया, लेकिन साइलेंटगॉस्ट ने मेरे द्वारा पूछे गए प्रश्न का उत्तर दिया।

भ्रम के लिए क्षमा याचना।

Answer 1

for x in y[:-1]

यदि yजनरेटर है, तो ऊपर काम नहीं करेगा।

Comments

यह मेरे प्रश्न का उत्तर देता है, धन्यवाद, लेकिन मैं यह पूछना भूल गया कि मुझे x के बाद आइटम कैसे मिलेगा। क्या यह संभव है?

— डेविड साइक्स

- 1 मुझे नहीं लगता कि इस सवाल का जवाब है। यह अगले एक के साथ प्रत्येक आइटम की तुलना नहीं कर रहा है। - odwl 0 सेकंड पहले

— odwl

मुझे लगता है मैंने किया था। लेखक ने कहा कि वह एक्स करना चाहता है, फिर पूछा कि वह वाई कैसे कर सकता है। मैंने उत्तर दिया कि वह वाई कैसे कर सकता है। उसने स्वीकार किया कि वह मेरे उत्तर को इंगित करेगा, मैंने उससे पूछे गए प्रश्न का उत्तर दिया, यदि वह प्रश्न नहीं जो वह वास्तव में पूछना चाहता था। यह उत्तर देने के लिए प्रश्नकर्ता का स्वागत है।

— freespace

सिर्फ इसलिए कि ओपी को पहले एक और सवाल पूछना चाहिए था, इसका मतलब यह नहीं है कि उसका सवाल और यह जवाब दूसरों के लिए बहुत उपयोगी नहीं है। +1

— प्रो। फॉकन

आप उल्लेख करते हैं कि यह जनरेटर के लिए काम नहीं करता है। जब yजनरेटर होता है तो विकल्प क्या है ?

— Joost

Answer 2

निम्नलिखित के साथ अनुक्रम आइटम की तुलना करने का सबसे आसान तरीका:

for i, j in zip(a, a[1:]):
     # compare i (the current) to j (the following)

Comments

यह मेरे द्वारा पूछे गए प्रश्न का उत्तर देता है। धन्यवाद

— डेविड सैक्स २

वास्तव में, आप पहली स्लाइस को छोड़ सकते हैं, क्योंकि ज़िप लंबी सूची को छोटी की लंबाई तक काट देता है। यह आपको एक सूची निर्माण से बचाएगा। (यदि आप बहुत बड़ी सूचियों के साथ काम कर रहे हैं, लेकिन उस मामले में, आपको चींटियों के प्लाज्मा के दृष्टिकोण का पालन करना चाहिए, जो कुछ भी कॉपी नहीं करता है।)

— बायर २

Answer 3

यदि आप अनुक्रम जोड़ी में सभी तत्वों को प्राप्त करना चाहते हैं, तो इस दृष्टिकोण का उपयोग करें (जोड़ीवेट फ़ंक्शन इटर्सेट मॉड्यूल में उदाहरणों से है)।

from itertools import tee, izip, chain

def pairwise(seq):
    a,b = tee(seq)
    b.next()
    return izip(a,b)

for current_item, next_item in pairwise(y):
    if compare(current_item, next_item):
        # do what you have to do

यदि आपको अंतिम मान की तुलना कुछ विशेष मूल्य से करने की आवश्यकता है, तो उस मूल्य को अंत तक श्रृंखला दें

for current, next_item in pairwise(chain(y, [None])):

Comments

कृपया ध्यान दें, चर नाम छाया के लिए अगले का उपयोग बिल्ट-इन

— साइलेंटगॉस्ट

जब चर का दायरा छोटा होता है और पठनीयता के लिए नाम अच्छा होता है, तो मैं व्यक्तिगत रूप से कम उपयोग किए गए बिल्डिंग्स को छायांकित करने में कोई आपत्ति नहीं करता। फिर भी अच्छी कोडिंग प्रथाओं को बनाए रखने के लिए चर नामों को संपादित किया गया।

— चींटियां प्लाज्मा

Answer 4

यदि आपका मतलब उस सूची में n + 1 वें आइटम के साथ nth आइटम की तुलना करना है जो आप भी कर सकते हैं

>>> for i in range(len(list[:-1])):
...     print list[i]>list[i+1]

ध्यान दें कि वहां कोई हार्ड कोडिंग नहीं चल रही है। यह तब तक ठीक होना चाहिए जब तक आप अन्यथा महसूस न करें।

Comments

आप सूची की प्रतिलिपि से बचने के लिए लेन (सूची [: - 1]) को लेन (सूची) - 1 से बदल सकते हैं। और सूची नामक चर का उपयोग करने से बचें ...

— रेमी ब्लैंक

Answer 5

प्रत्येक आइटम की तुलना एक सूची में अगले एक पुनरावृत्ति के बिना एक पुनरावृत्ति के साथ:

import itertools
it = (x for x in range(10))
data1, data2 = itertools.tee(it)
data2.next()
for a, b in itertools.izip(data1, data2):
  print a, b

Comments

ठीक यही बात Ants Aasma stackoverflow.com/questions/914715/…

— साइलेंटगॉस्ट

Answer 6

यह वह उत्तर देता है जो ओपी को पूछा जाना चाहिए , यानी लगातार तत्वों (उत्कृष्ट साइलेंटगॉस्ट उत्तर) की तुलना करते हुए एक सूची का पारगमन , फिर भी किसी भी समूह ( एन-ग्राम ) के लिए सामान्यीकृत : 2, 3, ... n:

zip(*(l[start:] for start in range(0, n)))

उदाहरण:

l = range(0, 4)  # [0, 1, 2, 3]

list(zip(*(l[start:] for start in range(0, 2)))) # == [(0, 1), (1, 2), (2, 3)]
list(zip(*(l[start:] for start in range(0, 3)))) # == [(0, 1, 2), (1, 2, 3)]
list(zip(*(l[start:] for start in range(0, 4)))) # == [(0, 1, 2, 3)]
list(zip(*(l[start:] for start in range(0, 5)))) # == []

स्पष्टीकरण:

• l[start:] सूचकांक से शुरू होने वाली एक सूची / जनरेटर उत्पन्न करता है start
• *listया *generator: एनक्लोजिंग फ़ंक्शन के सभी तत्वों को पास करता है zipजैसे कि यह लिखा गया थाzip(elem1, elem2, ...)

ध्यान दें:

AFAIK, यह कोड उतना ही आलसी है जितना कि यह हो सकता है। टेस्ट नहीं हुआ।