Proper use of list.append in Python

Question

Who knows why method 1 is correct and method 2 is incorrect.

Method1:

def remove_duplicates(x): y = [] for n in x: if n not in y: y.append(n) return y 

Method 2:

 def remove_duplicates(x): y = [] for n in x: if n not in y: y = y.append(n) return y 

I do not understand why the second method returns an incorrect answer?

Answer 1

The list.append method returns None . So y = y.append(n) sets y to None .

If this happens on the most recent iteration of the for-loop , None returned.

If this happens before the last iteration, then the next time through a loop

 if n not in y 

will raise

 TypeError: argument of type 'NoneType' is not iterable 

---

Note. In most cases, there are faster ways to remove duplicates than method 1, but how to do this depends on whether you want to maintain order if the elements are ordered, and if the elements in x are hashed.

 def unique_hashable(seq): # Not order preserving. Use this if the items in seq are hashable, # and you don't care about preserving order. return list(set(seq)) def unique_hashable_order_preserving(seq): # http://www.peterbe.com/plog/uniqifiers-benchmark (Dave Kirby) # Use this if the items in seq are hashable and you want to preserve the # order in which unique items in seq appear. seen = set() return [x for x in seq if x not in seen and not seen.add(x)] def unique_unhashable_orderable(seq): # Author: Tim Peters # http://code.activestate.com/recipes/52560-remove-duplicates-from-a-sequence/ # Use this if the items in seq are unhashable, but seq is sortable # (ie orderable). Note the result does not preserve order because of # the sort. # # We can't hash all the elements. Second fastest is to sort, # which brings the equal elements together; then duplicates are # easy to weed out in a single pass. # NOTE: Python list.sort() was designed to be efficient in the # presence of many duplicate elements. This isn't true of all # sort functions in all languages or libraries, so this approach # is more effective in Python than it may be elsewhere. try: t = list(seq) t.sort() except TypeError: del t else: last = t[0] lasti = i = 1 while i < len(seq): if t[i] != last: t[lasti] = last = t[i] lasti += 1 i += 1 return t[:lasti] def unique_unhashable_nonorderable(seq): # Use this (your Method1) if the items in seq are unhashable and unorderable. # This method is order preserving. u = [] for x in seq: if x not in u: u.append(x) return u 

And this may be the fastest if you have NumPy, and elements in seq can be ordered:

 import numpy as np def unique_order_preserving_numpy(seq): u, ind = np.unique(seq, return_index=True) return u[np.argsort(ind)]