अजगर में पाश के लिए पहली प्रविष्टि छोड़ें?

Question

अजगर में, मैं कुछ कैसे करूँ:

for car in cars:
   # Skip first and last, do work for rest

Comments

मैं एक नौसिखिया हूँ, लेकिन मैं उपयोग कर रहा हूँ for n, i in enumerate(cars): if n!= 0: do something to i। तर्क यह है कि यह प्रत्येक मान के लिए एक 'काउंटर' जोड़ता है जिसे आप बाद में जैसे लक्ष्य कर सकते हैं if n == some_value। इस उदाहरण में यह i के प्रत्येक उदाहरण के लिए कुछ करेगा, सिवाय पहले वाले के।

— user1063287

Answer 1

अन्य उत्तर केवल एक अनुक्रम के लिए काम करते हैं।

किसी भी चलने योग्य के लिए, पहला आइटम छोड़ने के लिए:

itercars = iter(cars)
next(itercars)
for car in itercars:
    # do work

यदि आप अंतिम को छोड़ना चाहते हैं, तो आप ऐसा कर सकते हैं:

itercars = iter(cars)
# add 'next(itercars)' here if you also want to skip the first
prev = next(itercars)
for car in itercars:
    # do work on 'prev' not 'car'
    # at end of loop:
    prev = car
# now you can do whatever you want to do to the last one on 'prev'

Comments

इसके अलावा स्वेन मार्नाच का जवाब देखें

— agf

मैंने पाया कि Cars.pop (0) और Cars.pop () करना अच्छा काम करता है।

— ड्रीमवर्क 801

@ dreamwork801 मेरा जवाब और स्वेन, जो मैं पहली टिप्पणी में लिंक करता हूं, किसी भी चलने योग्य, यहां तक ​​कि अनंत लोगों के लिए काम करता हूं, क्योंकि उन्हें पुनरावृत्ति शुरू होने से पहले डेटा पर ओ (एन) ऑपरेशन की आवश्यकता नहीं है। आपका सुझाव, और अभिजीत, दोनों ही केवल दृश्यों के लिए काम करते हैं, किसी भी चलने योग्य नहीं।

— एएफएफ

Answer 2

पायथन में पहले तत्व को छोड़ने के लिए आप बस लिख सकते हैं

for car in cars[1:]:
    # Do What Ever you want

या अंतिम चुनाव को छोड़ना

for car in cars[:-1]:
    # Do What Ever you want

आप किसी भी अनुक्रम के लिए इस अवधारणा का उपयोग कर सकते हैं।

Comments

सभी पुनरावृत्तियों के लिए नहीं , बल्कि सभी दृश्यों के लिए ।

— स्वेन मार्नाच

स्मृति उपयोग के बारे में कैसे? क्या स्लाइस उप-अनुक्रम की एक नई प्रतिलिपि बनाता है?

— मल्लाह

@ वायेजर हां, यह नई प्रति बनाता है।

— श्रीनिवास रेड्डी थिप्पर्थी

Answer 3

पहला आइटम छोड़ने का सबसे अच्छा तरीका है:

from itertools import islice
for car in islice(cars, 1, None):
    # do something

इस मामले में islice को 1 के स्टार्ट-पॉइंट और किसी के एंड पॉइंट से जोड़ा जाता है, जो इटरेटर के अंत को दर्शाता है।

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

Comments

स्वेन के (अल्पविकसित) उत्तर पर एक नज़र डालें। वह किसी भी isliceतरह की शुरुआत और / या अंत में बहुत अच्छी तरह से उपयोग करने पर वस्तुओं की एक मनमानी संख्या को लंघन करता है , बिना किसी लंबाई के या पूरी तरह से आवश्यक वस्तुओं को स्मृति में अधिक आइटम संग्रहीत करने के बिना।

— agf

स्वेन का जवाब वास्तव में मेमोरी में पूरे इटरेटर को संग्रहित करेगा - संग्रह। डॉटर के माध्यम से चलेगा। कुछ संग्रह की तरह करने की कोशिश करें ।deque (xrange (10000000))। यदि आप पहली वस्तु को छोड़ना चाहते हैं, तो सभी

— चींटियों

एक isliceवह है जो dequeपूरे इट्रेटर को नहीं, बल्कि पास किया जाता है, और यह केवल अंत में छोड़ देने के लिए मदों की संख्या की लंबाई है। यह मेमोरी में पूरे पुनरावृत्ति स्टोर नहीं करता है।

— एजी

Answer 4

यहां एक अधिक सामान्य जनरेटर फ़ंक्शन है जो किसी भी आइटम्स की शुरुआत और अंत से किसी भी संख्या को छोड़ता है:

def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    for x in itertools.islice(it, at_start):
        pass
    queue = collections.deque(itertools.islice(it, at_end))
    for x in it:
        queue.append(x)
        yield queue.popleft()

उदाहरण उपयोग:

>>> list(skip(range(10), at_start=2, at_end=2))
[2, 3, 4, 5, 6, 7]

Comments

के लिए एक तेज़ पथ जोड़ना चाह सकते हैं at_end == 0।

— एएफएफ

collection.deque (...) तुरंत इट्रेटर के माध्यम से जाएगा। इसका मतलब है कि स्किप (xrange (10000000), 1) मेमोरी को बहुत ऊपर ले जाएगा भले ही यह वास्तव में नहीं होना चाहिए।

— रोई शेनबर्ग 11

@ReeeeShenberg: skip(xrange(10000000), 1)का उपयोग करेगा at_end=0, इसलिए ऐसा पैरामीटर deque()होगा islice(it, 0), जो केवल शून्य तत्वों का उपभोग करेगा it। यह बहुत सारी मेमोरी नहीं लेगा।

— स्वेन मार्नाच

Answer 5

for item in do_not_use_list_as_a_name[1:-1]:
    #...do whatever

Comments

listएक चर नाम के रूप में उपयोग न करें

— अभिजीत

ओपी केवल पहले तत्व को छोड़ना चाहता है। क्यों: -1?

— luke14free

यह वास्तव में आरक्षित नहीं है ; नाम listको फिर से बाध्य किया जा सकता है। इसलिए आपको इसका उपयोग नहीं करना चाहिए , बल्कि इसका उपयोग नहीं करना चाहिए ।

— jscs

@ luke14free, सवाल कहता है कि पहले तत्व को छोड़ें, लेकिन उसकी कोड टिप्पणी से तात्पर्य है कि वह वास्तव में पहले और अंतिम को छोड़ना चाहता है।

— जर्सीमाइक

@ luke14free यह है कि शीर्षक क्या कहता है, न कि उसने कोड के अंदर जो लिखा है: "स्किप

— इफ यू फर्स्ट एंड

Answer 6

@SvenMarnach के उत्तर के आधार पर, लेकिन थोड़ा सरल और बिना deque का उपयोग किए

>>> def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    it = itertools.islice(it, at_start, None)
    it, it1 = itertools.tee(it)
    it1 = itertools.islice(it1, at_end, None)
    return (next(it) for _ in it1)

>>> list(skip(range(10), at_start=2, at_end=2))
[2, 3, 4, 5, 6, 7]
>>> list(skip(range(10), at_start=2, at_end=5))
[2, 3, 4]

यह भी ध्यान दें, मेरे timeitपरिणाम के आधार पर , यह deque समाधान की तुलना में थोड़ा तेज है

>>> iterable=xrange(1000)
>>> stmt1="""
def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    it = itertools.islice(it, at_start, None)
    it, it1 = itertools.tee(it)
    it1 = itertools.islice(it1, at_end, None)
    return (next(it) for _ in it1)
list(skip(iterable,2,2))
    """
>>> stmt2="""
def skip(iterable, at_start=0, at_end=0):
    it = iter(iterable)
    for x in itertools.islice(it, at_start):
        pass
    queue = collections.deque(itertools.islice(it, at_end))
    for x in it:
        queue.append(x)
        yield queue.popleft()
list(skip(iterable,2,2))
        """
>>> timeit.timeit(stmt = stmt1, setup='from __main__ import iterable, skip, itertools', number = 10000)
2.0313770640908047
>>> timeit.timeit(stmt = stmt2, setup='from __main__ import iterable, skip, itertools, collections', number = 10000)
2.9903135454296716

Comments

उपयोग करके tee(), आप अभी भी जनरेटर के लिए मेमोरी में पूरी सूची बना रहे हैं, है ना? (अपने it1)

— Jabberwockey

Answer 7

उदाहरण:

mylist=['one'.'two','three'.'four'.'five']
for i in mylist[1:]:
   print(i)

अजगर सूचकांक में 0 से शुरू, हम पुनरावृत्ति में हेरफेर करने के लिए स्लिंगिंग ऑपरेटर का उपयोग कर सकते हैं।

for i in range(1,-1):

Answer 8

ठीक है, आपका सिंटैक्स वास्तव में शुरू करने के लिए पायथन नहीं है।

पाइथन में बदलाव कंटेनरों की सामग्री पर होते हैं (अच्छी तरह से, तकनीकी रूप से यह पुनरावृत्तियों पर), एक सिंटैक्स के साथ for item in container। इस मामले में, कंटेनर carsसूची है, लेकिन आप पहले और अंतिम तत्वों को छोड़ना चाहते हैं, तो इसका मतलब है कि cars[1:-1](पायथन सूची शून्य-आधारित हैं, नकारात्मक संख्याएं अंत से गिना जाती हैं, और :सिंटैक्स स्लाइसिंग है।

इसलिए आप यह चाहते हैं

for c in cars[1:-1]:
    do something with c

Comments

यह केवल एक अनुक्रम के साथ चलने (जैसे एक जनरेटर) के साथ काम नहीं करेगा।

— रोई शेनबर्ग 11

Answer 9

एक वैकल्पिक विधि:

for idx, car in enumerate(cars):
    # Skip first line.
    if not idx:
        continue
    # Skip last line.
    if idx + 1 == len(cars):
        continue
    # Real code here.
    print car

Answer 10

यहाँ मेरा पसंदीदा विकल्प है। यह लूप पर बहुत कुछ जोड़ने की आवश्यकता नहीं है, और कुछ भी नहीं बनाता है लेकिन उपकरण में बनाया गया है।

से जाओ:

for item in my_items:
  do_something(item)

सेवा:

for i, item in enumerate(my_items):
  if i == 0:
    continue
  do_something(item)

Answer 11

यदि carsएक अनुक्रम है तो आप बस कर सकते हैं

for car in cars[1:-1]:
    pass

Answer 12

more_itertoolsपरियोजना का विस्तार itertools.isliceनकारात्मक सूचकांक को संभालने के लिए।

उदाहरण

import more_itertools as mit

iterable = 'ABCDEFGH'
list(mit.islice_extended(iterable, 1, -1))
# Out: ['B', 'C', 'D', 'E', 'F', 'G']

इसलिए, आप इसे पुन: उपयोग करने योग्य तत्वों को पहले और अंतिम आइटम्स के बीच स्लाइस कर सकते हैं:

for car in mit.islice_extended(cars, 1, -1):
    # do something

Answer 13

मैं इसे इस तरह से करता हूं, भले ही यह हर बार काम करने वाले हैक की तरह दिखता है:

ls_of_things = ['apple', 'car', 'truck', 'bike', 'banana']
first = 0
last = len(ls_of_things)
for items in ls_of_things:
    if first == 0
        first = first + 1
        pass
    elif first == last - 1:
        break
    else:
        do_stuff
        first = first + 1
        pass