How to discard from the middle of a list using list comprehensions?

Question

I could do this using an index but I thought there must be a cleaner way using list comprehensions. I'm a beginner. I hope it's not embarrassingly obvious. Thanks

for x in firstList:
    firstFunc(x)
    secondFunc(x)
    x = process(x)
    if x.discard == True:
        (get rid of x)
secondList.append(firstList)

Answer 1

You know, your best solution is really to just initialize secondList how you like, and do all three functions in a regular loop, since they're all dependent and contain logic that is not just filtering (you say process sets attributes... I'm assuming you mean other than discard):

# If secondList not initialized...
secondList = []
for x in firstList:
    firstFunc(x)
    secondFunc(x)
    process(x)
    if not x.discard:
        secondList.append(x)

List comprehensions don't help too much here since you're doing processing in each function (they take a line or two off though; depends on what you're looking for in "clean" code). If all process() did was return True if the item should be in the new list, and False if the item should not be in the new list, then the below would really be better, IMO.

---

If firstFunc(x) and secondFunc(x) do change the result of x.discard after process(), and the result of process(x) is just x, I would do the following in your situation:

for x in firstList:
    firstFunc(x)
    secondFunc(x)
secondList = [ x for x in firstList if not process(x).discard ]

If the result of process(x) is different from x though, as your sample appears to indicate, you could also change that last line to the following:

interimList = [ process(x) for x in firstList ]
secondList = [ x for x in interimList if not x.discard ]

Note that if you wanted to append these results to secondList, use secondList.extend([...]).

Edit: I realized I erroneously wrote "do not" change, but I meant if they do change the result of process().

Edit 2: Cleanup description / code.

Answer 2

Edit: process(x) is necessary for x.discard, meaning that the answer is:

No there is no cleaner way. And the way you are doing it is already clean.

Old answer:

Not really, no. You can make this:

def process_item(x):
    firstFunc(x)
    secondFunc(x)
    x = process(x)

def test_item(x):
    return x.discard == False

list = [process_item(x) for x in firstList if test_item(x)]

But that is not cleaner, and also it requires x.discard to be set before you process it, which it doesn't seem to be from your code.

List comprehensions are not "cleaner". They are shorter ways of writing simple list processing. You list processing involves three steps. That's not really "simple". :)

Answer 3

a few things:

• you cannot append a list, you need to use extend.
• no need for == True bit, use just if x.discard:
• you'd rather create a new list with values that you don't want to discard and don't pollute your loop with removal.

so you'd have something along the lines:

tmp = []
for x in first_list:
    x = process(x)
    if not x.discard:
        tmp.append(x)
second_list.extend(tmp)

list comprehension would obviously more pythonic, though:

[i for i in first_list if not process(i).discard]

Answer 4

Sounds like

def allProcessing(x)
  firstFunc(x)
  secondFunc(x)
  return !(process(x).discard)

newList = filter(allProcessing, oldList)

Answer 5

Write this as two list comprehensions, one which assembles the data that might need filtering, and another which does the filtering. Make firstFunc and secondFunc return x (as process does), and then you can write it like so:

unfilteredList = [secondFunc(firstFunc(x)) for x in firstList]
secondList = [x for x in unfilteredList if not x.discard]

Answer 6

Just a thought, and it does little for documentation, but why not try:

def masterFunc(x):
    firstFunc(x)
    secondFunc(x)
    process(x)
    return x.discard

secondList = [ x for x in firstList if masterFunc(x) ]

Good news: does what you asked, strictly speaking. Bad news: it hides firstFunc, secondFunc, and process

It sounds like you already have trouble with side-effects and command/query separation in the example, so I'm thinking that this hack is not as noble as cleaning up the code a bit. You might find that some methods need inverted (x.firstFunc() instead of firstFunc(x)) and others need broken up. There may even be a nicer way than 'x.discard' to deal with filtering.