Uso correcto de list.append en Python

Me gustaría saber por qué el método 1 es correcto y el método 2 es incorrecto.

Método 1:

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

Método 2:

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

No entiendo por qué el segundo método devuelve la respuesta incorrecta.

El método list.append devuelve None . Entonces y = y.append(n) establece y en None .

Si esto sucede en la última iteración del for-loop , entonces se devuelve None .

Si sucede antes de la última iteración, la próxima vez a través del bucle,

 if n not in y 

planteará un

 TypeError: argument of type 'NoneType' is not iterable 

Nota: En la mayoría de los casos, hay formas más rápidas de eliminar duplicados que el Método 1, pero cómo hacerlo depende de si desea conservar el orden, si los elementos son ordenables y si los elementos en x son hashables.

 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's 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 

Y esto puede ser el más rápido si tiene NumPy y los elementos en seq son ordenables:

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