วิธีการ pythonic ในการตรวจสอบองค์ประกอบสุดท้ายในวง 'for' คืออะไร?

ฉันต้องการทราบวิธีที่ดีที่สุด (ขนาดกะทัดรัดและวิธี "pythonic") เพื่อทำการดูแลเป็นพิเศษสำหรับองค์ประกอบสุดท้ายในการวนรอบ มีชิ้นส่วนของรหัสที่ควรเรียกระหว่างองค์ประกอบเท่านั้นถูกระงับในสุดท้าย

นี่คือวิธีที่ฉันทำในปัจจุบัน:

for i, data in enumerate(data_list):
    code_that_is_done_for_every_element
    if i != len(data_list) - 1:
        code_that_is_done_between_elements

มีวิธีที่ดีกว่านี้ไหม?

หมายเหตุ: ฉันไม่ต้องการที่จะทำให้มันมี hacks reduceเช่นการใช้;)

เวลาส่วนใหญ่จะง่ายกว่า (และถูกกว่า) เพื่อให้การทำซ้ำครั้งแรกเป็นกรณีพิเศษแทนที่จะเป็นครั้งสุดท้าย:

first = True
for data in data_list:
    if first:
        first = False
    else:
        between_items()

    item()

นี้จะทำงาน iterable ใด ๆ แม้สำหรับผู้ที่ไม่มีlen():

file = open('/path/to/file')
for line in file:
    process_line(line)

    # No way of telling if this is the last line!

นอกจากนั้นฉันไม่คิดว่าจะมีวิธีแก้ปัญหาที่ดีกว่าโดยทั่วไปขึ้นอยู่กับสิ่งที่คุณพยายามทำ ตัวอย่างเช่นหากคุณกำลังสร้างสตริงจากรายการมันจะดีกว่าที่จะใช้ตามธรรมชาติstr.join()มากกว่าการใช้forลูป "พร้อมตัวพิมพ์เล็ก"

ใช้หลักการเดียวกัน แต่กะทัดรัดกว่า:

for i, line in enumerate(data_list):
    if i > 0:
        between_items()
    item()

ดูคุ้น ๆ ใช่มั้ย :)

สำหรับ @ofko และคนอื่น ๆ ที่ต้องการตรวจสอบว่ามูลค่าปัจจุบันของ iterable ที่ไม่มีโดยlen()เป็นค่าสุดท้ายคุณจะต้องมองไปข้างหน้า:

def lookahead(iterable):
    """Pass through all values from the given iterable, augmented by the
    information if there are more values to come after the current one
    (True), or if it is the last value (False).
    """
    # Get an iterator and pull the first value.
    it = iter(iterable)
    last = next(it)
    # Run the iterator to exhaustion (starting from the second value).
    for val in it:
        # Report the *previous* value (more to come).
        yield last, True
        last = val
    # Report the last value.
    yield last, False

จากนั้นคุณสามารถใช้สิ่งนี้:

>>> for i, has_more in lookahead(range(3)):
...     print(i, has_more)
0 True
1 True
2 False

แม้ว่าคำถามนั้นค่อนข้างเก่า แต่ฉันมาที่นี่ผ่าน Google และฉันพบวิธีที่ง่ายมาก: การแบ่งส่วนรายการ สมมติว่าคุณต้องการใส่ '&' ระหว่างรายการทั้งหมด

s = ""
l = [1, 2, 3]
for i in l[:-1]:
    s = s + str(i) + ' & '
s = s + str(l[-1])

ส่งคืน '1 & 2 & 3'

'รหัสระหว่าง' เป็นตัวอย่างของรูปแบบHead-Tail

คุณมีรายการซึ่งจะตามลำดับคู่ (ระหว่าง, รายการ) นอกจากนี้คุณยังสามารถดูสิ่งนี้เป็นลำดับของคู่ (รายการระหว่าง) ตามด้วยรายการ โดยทั่วไปแล้วจะง่ายกว่าที่จะนำองค์ประกอบแรกมาเป็นพิเศษและองค์ประกอบอื่น ๆ ทั้งหมดเป็นเคส "มาตรฐาน"

นอกจากนี้เพื่อหลีกเลี่ยงการทำซ้ำรหัสคุณต้องให้ฟังก์ชั่นหรือวัตถุอื่น ๆ เพื่อให้มีรหัสที่คุณไม่ต้องการทำซ้ำ การฝังคำสั่งifในลูปซึ่งเป็นเท็จเสมอยกเว้นครั้งเดียวนั้นโง่

def item_processing( item ):
    # *the common processing*

head_tail_iter = iter( someSequence )
head = head_tail_iter.next()
item_processing( head )
for item in head_tail_iter:
    # *the between processing*
    item_processing( item )

สิ่งนี้มีความน่าเชื่อถือมากกว่าเพราะง่ายต่อการพิสูจน์เล็กน้อยมันไม่ได้สร้างโครงสร้างข้อมูลเพิ่มเติม (เช่นสำเนาของรายการ) และไม่ต้องการการประมวลผลif หากเสียซึ่งเป็นเท็จเสมอยกเว้นเพียงครั้งเดียว

หากคุณเพียงแค่ต้องการปรับเปลี่ยนองค์ประกอบสุดท้ายdata_listคุณก็สามารถใช้สัญกรณ์:

L[-1]

อย่างไรก็ตามดูเหมือนว่าคุณกำลังทำมากกว่านั้น ไม่มีอะไรผิดปกติกับวิธีการของคุณ ฉันได้ดูโค้ด Djangoบางส่วนสำหรับแท็กแม่แบบของพวกเขาและพวกเขาก็ทำสิ่งที่คุณทำอยู่โดยทั่วไป

หากรายการไม่ซ้ำกัน:

for x in list:
    #code
    if x == list[-1]:
        #code

ตัวเลือกอื่น:

pos = -1
for x in list:
    pos += 1
    #code
    if pos == len(list) - 1:
        #code


for x in list:
    #code
#code - e.g. print x


if len(list) > 0:
    for x in list[:-1]
        #code
    for x in list[-1]:
        #code

สิ่งนี้คล้ายกับแนวทางของ Ants Aasma แต่ไม่ต้องใช้โมดูล itertools นอกจากนี้ยังเป็นตัววนซ้ำที่มองไปข้างหน้าองค์ประกอบเดียวในกระแสตัววนซ้ำ:

def last_iter(it):
    # Ensure it's an iterator and get the first field
    it = iter(it)
    prev = next(it)
    for item in it:
        # Lag by one item so I know I'm not at the end
        yield 0, prev
        prev = item
    # Last item
    yield 1, prev

def test(data):
    result = list(last_iter(data))
    if not result:
        return
    if len(result) > 1:
        assert set(x[0] for x in result[:-1]) == set([0]), result
    assert result[-1][0] == 1

test([])
test([1])
test([1, 2])
test(range(5))
test(xrange(4))

for is_last, item in last_iter("Hi!"):
    print is_last, item

คุณสามารถใช้หน้าต่างเลื่อนบนข้อมูลอินพุตเพื่อดูค่าถัดไปและใช้ Sentinel เพื่อตรวจจับค่าสุดท้าย วิธีนี้ใช้ได้กับทุก iterable ดังนั้นคุณไม่จำเป็นต้องทราบความยาวไว้ก่อน การดำเนินการคู่จากสูตร itertools

from itertools import tee, izip, chain

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

def annotated_last(seq):
    """Returns an iterable of pairs of input item and a boolean that show if
    the current item is the last item in the sequence."""
    MISSING = object()
    for current_item, next_item in pairwise(chain(seq, [MISSING])):
        yield current_item, next_item is MISSING:

for item, is_last_item in annotated_last(data_list):
    if is_last_item:
        # current item is the last item

ไม่มีความเป็นไปได้ที่จะวนซ้ำไปตลอด - แต่องค์ประกอบสุดท้ายและปฏิบัติกับสิ่งสุดท้ายนอกวง? ท้ายที่สุดแล้วลูปจะถูกสร้างขึ้นเพื่อทำสิ่งที่คล้ายกับองค์ประกอบทั้งหมดที่คุณวนซ้ำ หากองค์ประกอบหนึ่งต้องการบางสิ่งที่พิเศษไม่ควรอยู่ในลูป

(ดูเพิ่มเติมที่คำถามนี้: การรักษาแบบองค์รวมในรูปแบบการรักษาแบบแยก )

แก้ไข: เนื่องจากคำถามเกี่ยวกับ "ในระหว่าง" ทั้งองค์ประกอบแรกคือองค์ประกอบพิเศษที่ไม่มีบรรพบุรุษหรือองค์ประกอบสุดท้ายเป็นพิเศษในการที่ไม่มีผู้สืบทอด

ฉันชอบวิธีการของ @ ethan-t แต่while Trueอันตรายจากมุมมองของฉัน

data_list = [1, 2, 3, 2, 1]  # sample data
L = list(data_list)  # destroy L instead of data_list
while L:
    e = L.pop(0)
    if L:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')
del L

นี่data_listคือเพื่อให้องค์ประกอบสุดท้ายมีค่าเท่ากันโดยหนึ่งในรายการแรก L สามารถแลกเปลี่ยนได้data_listแต่ในกรณีนี้ผลลัพธ์จะว่างหลังจากลูป while Trueเป็นไปได้ที่จะใช้หากคุณตรวจสอบว่ารายการไม่ว่างเปล่าก่อนการประมวลผลหรือไม่จำเป็นต้องใช้การตรวจสอบ (ouch!)

data_list = [1, 2, 3, 2, 1]
if data_list:
    while True:
        e = data_list.pop(0)
        if data_list:
            print(f'process element {e}')
        else:
            print(f'process last element {e}')
            break
else:
    print('list is empty')

ส่วนที่ดีคือมันรวดเร็ว เลว - มันเป็นสิ่งที่ทำลายได้ ( data_listกลายเป็นที่ว่างเปล่า)

โซลูชันที่ใช้งานง่ายที่สุด:

data_list = [1, 2, 3, 2, 1]  # sample data
for i, e in enumerate(data_list):
    if i != len(data_list) - 1:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')

โอ้ใช่คุณได้เสนอแล้ว!

ไม่มีอะไรผิดปกติกับวิธีการของคุณเว้นแต่ว่าคุณจะมีลูป 100 000 ลูปและต้องการบันทึกคำสั่ง "100,000" ถ้า "" ในกรณีนั้นคุณสามารถไปทางนั้นได้:

iterable = [1,2,3] # Your date
iterator = iter(iterable) # get the data iterator

try :   # wrap all in a try / except
    while 1 : 
        item = iterator.next() 
        print item # put the "for loop" code here
except StopIteration, e : # make the process on the last element here
    print item

เอาท์พุท:

1
2
3
3

แต่จริงๆแล้วในกรณีของคุณฉันรู้สึกว่ามันเกินความจริง

ไม่ว่าในกรณีใดคุณอาจจะโชคดีกว่าด้วยการแบ่งส่วน:

for item in iterable[:-1] :
    print item
print "last :", iterable[-1]

#outputs
1
2
last : 3

หรือเพียงแค่:

for item in iterable :
    print item
print iterable[-1]

#outputs
1
2
3
last : 3

ในที่สุดก็มีวิธี KISS ที่จะทำสิ่งต่าง ๆ ให้คุณและนั่นจะทำงานร่วมกับ iterable ใด ๆ รวมถึงสิ่งที่ไม่มี__len__:

item = ''
for item in iterable :
    print item
print item

เพื่อถ่ายทอด:

1
2
3
3

ถ้ารู้สึกว่าฉันจะทำอย่างนั้นดูเหมือนง่ายสำหรับฉัน

ใช้การแบ่งส่วนและisเพื่อตรวจสอบองค์ประกอบสุดท้าย:

for data in data_list:
    <code_that_is_done_for_every_element>
    if not data is data_list[-1]:
        <code_that_is_done_between_elements>

Caveat emptor : ใช้งานได้เฉพาะในกรณีที่องค์ประกอบทั้งหมดในรายการต่างกันจริง (มีตำแหน่งต่างกันในหน่วยความจำ) Python อาจตรวจจับองค์ประกอบที่เท่ากันและนำวัตถุเดียวกันกลับมาใช้ใหม่ ตัวอย่างเช่นสำหรับสตริงที่มีค่าเดียวกันและจำนวนเต็มทั่วไป

หากคุณกำลังจะผ่านรายการสำหรับฉันนี้ทำงานด้วย:

for j in range(0, len(Array)):
    if len(Array) - j > 1:
        notLast()

Google ได้นำคำถามเก่ามาให้ฉันและฉันคิดว่าฉันสามารถเพิ่มวิธีอื่นในการแก้ไขปัญหานี้ได้

คำตอบส่วนใหญ่ที่นี่จะจัดการกับการรักษาที่เหมาะสมสำหรับการควบคุมวนตามที่ถูกถาม แต่ถ้า data_list ถูกทำลายฉันขอแนะนำให้คุณป๊อปไอเท็มจากรายการจนกว่าคุณจะจบด้วยรายการที่ว่างเปล่า:

while True:
    element = element_list.pop(0)
    do_this_for_all_elements()
    if not element:
        do_this_only_for_last_element()
        break
    do_this_for_all_elements_but_last()

คุณสามารถใช้ในขณะที่ len (element_list)หากคุณไม่ต้องการทำอะไรกับองค์ประกอบสุดท้าย ฉันพบว่าโซลูชันนี้สวยงามกว่าและจัดการกับถัดไป ()

สำหรับฉันวิธีที่ง่ายที่สุดและ pythonic ในการจัดการกรณีพิเศษในตอนท้ายของรายการคือ:

for data in data_list[:-1]:
    handle_element(data)
handle_special_element(data_list[-1])

ของหลักสูตรนี้ยังสามารถใช้ในการรักษาองค์ประกอบแรกด้วยวิธีพิเศษ

แทนที่จะนับคุณสามารถนับถอยหลังได้:

  nrToProcess = len(list)
  for s in list:
    s.doStuff()
    nrToProcess -= 1
    if nrToProcess==0:  # this is the last one
      s.doSpecialStuff()

ชะลอการจัดการพิเศษของไอเท็มสุดท้ายจนกระทั่งหลังจากลูป

>>> for i in (1, 2, 3):
...     pass
...
>>> i
3

สามารถมีได้หลายวิธี การหั่นจะเร็วที่สุด เพิ่มอีกหนึ่งซึ่งใช้. index () วิธีการ:

>>> l1 = [1,5,2,3,5,1,7,43]                                                 
>>> [i for i in l1 if l1.index(i)+1==len(l1)]                               
[43]

สมมติว่าอินพุตเป็นตัววนซ้ำนี่เป็นวิธีใช้ tee และ izip จาก itertools:

from itertools import tee, izip
items, between = tee(input_iterator, 2)  # Input must be an iterator.
first = items.next()
do_to_every_item(first)  # All "do to every" operations done to first item go here.
for i, b in izip(items, between):
    do_between_items(b)  # All "between" operations go here.
    do_to_every_item(i)  # All "do to every" operations go here.

การสาธิต:

>>> def do_every(x): print "E", x
...
>>> def do_between(x): print "B", x
...
>>> test_input = iter(range(5))
>>>
>>> from itertools import tee, izip
>>>
>>> items, between = tee(test_input, 2)
>>> first = items.next()
>>> do_every(first)
E 0
>>> for i,b in izip(items, between):
...     do_between(b)
...     do_every(i)
...
B 0
E 1
B 1
E 2
B 2
E 3
B 3
E 4
>>>

ทางออกที่ง่ายที่สุดในใจของฉันคือ:

for item in data_list:
    try:
        print(new)
    except NameError: pass
    new = item
print('The last item: ' + str(new))

ดังนั้นเรามักจะมองไปข้างหน้าหนึ่งรายการโดยการชะลอการประมวลผลหนึ่งซ้ำ ในการข้ามการทำบางสิ่งในช่วงการทำซ้ำครั้งแรกฉันเพียงแค่จับข้อผิดพลาด

แน่นอนคุณต้องคิดอะไรเล็กน้อยเพื่อที่NameErrorจะได้รับการเลี้ยงดูเมื่อคุณต้องการ

เก็บของที่กำบังไว้

try:
    new
except NameError: pass
else:
    # continue here if no error was raised

สิ่งนี้ขึ้นอยู่กับว่าชื่อใหม่ไม่ได้ถูกกำหนดไว้ก่อนหน้านี้ หากคุณหวาดระแวงคุณสามารถมั่นใจได้ว่าnewไม่มีอยู่ใน:

try:
    del new
except NameError:
    pass

หรือคุณสามารถใช้คำสั่ง if ( if notfirst: print(new) else: notfirst = True) ได้เช่นกัน แต่เท่าที่ฉันรู้ค่าใช้จ่ายใหญ่กว่า

Using `timeit` yields:

    ...: try: new = 'test' 
    ...: except NameError: pass
    ...: 
100000000 loops, best of 3: 16.2 ns per loop

ดังนั้นฉันคาดว่าค่าโสหุ้ยจะไม่สามารถเลือกได้

นับรายการหนึ่งครั้งและติดตามจำนวนรายการที่เหลืออยู่:

remaining = len(data_list)
for data in data_list:
    code_that_is_done_for_every_element

    remaining -= 1
    if remaining:
        code_that_is_done_between_elements

วิธีนี้คุณประเมินความยาวของรายการเพียงครั้งเดียว การแก้ปัญหาหลายอย่างในหน้านี้ดูเหมือนว่าจะไม่สามารถใช้ความยาวได้ล่วงหน้า แต่นั่นไม่ใช่คำถามของคุณ หากคุณมีความยาวให้ใช้มัน

วิธีแก้ปัญหาง่ายๆที่นึกถึง:

for i in MyList:
    # Check if 'i' is the last element in the list
    if i == MyList[-1]:
        # Do something different for the last
    else:
        # Do something for all other elements

วิธีแก้ปัญหาอย่างง่าย ๆ อย่างที่สองทำได้โดยใช้ตัวนับ:

# Count the no. of elements in the list
ListLength = len(MyList)
# Initialize a counter
count = 0

for i in MyList:
    # increment counter
    count += 1
    # Check if 'i' is the last element in the list
    # by using the counter
    if count == ListLength:
        # Do something different for the last
    else:
        # Do something for all other elements