Probably a very naive question:
I have a list:
color = ["red","blue","red","green","blue"]
Now, I want to iterate through the list
for c in color:
# color is "red"
get the rest of the colors except this red
so rest = ["blue","red","green",blue"]
in next iteration:
c = blue
rest = ["red","red","green","blue"]
Eh. why do i have a feeling that this is pretty trivial to do..and there is probably a one line command which can solve this out? Thanks
The easiest way to think of this is that you want to iterate through every combination with a length one less than the list. To do this, we can use itertools.combinations():
import itertools
color = ["red","blue","red","green","blue"]
for rest in itertools.combinations(color, len(color)-1):
print(rest)
Which gives us:
('red', 'blue', 'red', 'green')
('red', 'blue', 'red', 'blue')
('red', 'blue', 'green', 'blue')
('red', 'red', 'green', 'blue')
('blue', 'red', 'green', 'blue')
This is a good solution as it works on iterables as well as sequences, is very readable, and should be nice and fast.
If you also need the current value, you can also get that easily, as combinations() gives you a predictable order, so we just iterate through both at the same time with zip() (naturally, if you want the best performance, use itertools.izip() under Python 2.x, as zip() creates a list, not a generator as in 3.x).
import itertools
color = ["red","blue","red","green","blue"]
for c, rest in zip(color, itertools.combinations(reversed(color), len(color)-1)):
print(c, rest)
red ('blue', 'green', 'red', 'blue')
blue ('blue', 'green', 'red', 'red')
red ('blue', 'green', 'blue', 'red')
green ('blue', 'red', 'blue', 'red')
blue ('green', 'red', 'blue', 'red')
Here I reverse the input for comibinations() so it works from left to right - you can reverse color in the zip() instead to get right to left.
So yes, in short, it's a one line solution (two if you count the import).
combinations() might give a predictable order, but I wouldn't rely on it to remain the same in future implementations.
Slicing and enumerate make easy work of this task:
>>> colors = ["red", "blue", "red", "green", "blue"]
>>> for i, color in enumerate(colors):
rest = colors[:i] + colors[i+1:]
print color, '-->', rest
red --> ['blue', 'red', 'green', 'blue']
blue --> ['red', 'red', 'green', 'blue']
red --> ['red', 'blue', 'green', 'blue']
green --> ['red', 'blue', 'red', 'blue']
blue --> ['red', 'blue', 'red', 'green']
The enumerate tracks the position of each color and the slices extract the parts of the list before and after the color.
This should also work
for i in range(len(yourlist)):
newlist = yourlist[:i] + yourlist[i:]
This Python code will create a new output list without the duplicates.
done = []
for c in color:
if c in done:
continue
done.append(c)
print c
The following example will return a list with duplicates removed. It starts with an empty return list, checks the color list, and, if a color, in this case red, is already in the output, it is ignored.
#!/usr/bin/env python
color = ["red","blue","red","green","blue"]
def rem_dup(dup_list):
corrected_list = []
for color in dup_list:
if color in corrected_list:
continue
else:
corrected_list.append(color)
return corrected_list
You would probably be better off using something like
>>> set(color)
set(['blue', 'green', 'red'])
>>>
or
>>> import collections
>>> color = ["red","blue","red","green","blue"]
>>> collections.OrderedDict.fromkeys(color)
OrderedDict([('red', None), ('blue', None), ('green', None)])
>>>
to remove duplicates. Both are more efficient than the for loop.
for idx, item in enumerate(color):
print 'I am %s' % item
rest = color[:idx] + color[idx+1:]
print 'Rest is %s' % ','.join(rest)
'+', I've timed it using timeit module, check my solution.