I'd like to know the best way (more compact and "pythonic" way) to do a special treatment for the last element in a for loop. There is a piece of code that should be called only between elements, being suppressed in the last one.
Here is how I currently do it:
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
Is there any better way?
Note: I don't want to make it with hacks such as using
Most of the times it is easier (and cheaper) to make the first iteration the special case instead of the last one:
first = True for data in data_list: if first: first = False else: between_items() item()
This will work for any iterable, even for those that have no
file = open('/path/to/file') for line in file: process_line(line) # No way of telling if this is the last line!
Apart from that, I don't think there is a generally superior solution as it depends on what you are trying to do. For example, if you are building a string from a list, it's naturally better to use
str.join() than using a
for loop “with special case”.
Using the same principle but more compact:
for i, line in enumerate(data_list): if i > 0: between_items() item()
Looks familiar, doesn't it? :)
For @ofko, and others who really need to find out if the current value of an iterable without
len() is the last one, you will need to look ahead:
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
Then you can use it like this:
>>> for i, has_more in lookahead(range(3)): ... print(i, has_more) 0 True 1 True 2 False
The 'code between' is an example of the Head-Tail pattern.
You have an item, which is followed by a sequence of ( between, item ) pairs. You can also view this as a sequence of (item, between) pairs followed by an item. It's generally simpler to take the first element as special and all the others as the "standard" case.
Further, to avoid repeating code, you have to provide a function or other object to contain the code you don't want to repeat. Embedding an if statement in a loop which is always false except one time is kind of silly.
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 )
This is more reliable because it's slightly easier to prove, It doesn't create an extra data structure (i.e., a copy of a list) and doesn't require a lot of wasted execution of an if condition which is always false except once.