¿Por qué no puedo agregar una tupla a una lista con el operador ‘+’ en Python?

Python no admite la adición de una tupla a una lista:

>>> [1,2,3] + (4,5,6) Traceback (most recent call last): File "", line 1, in  TypeError: can only concatenate list (not "tuple") to list 

¿Cuáles son las desventajas de proporcionar tal apoyo en el idioma? Tenga en cuenta que esperaría que esto fuera simétrico: [1, 2] + (3, 4) y (1, 2) + [3, 4] ambos se evaluarían para una lista completamente nueva [1, 2, 3, 4] . Mi razonamiento es que una vez que alguien aplicó el operador + a una mezcla de tuplas y listas, es probable que lo hagan nuevamente (muy posiblemente en la misma expresión), por lo que también podemos proporcionar la lista para evitar conversiones adicionales.

Aquí está mi motivación para esta pregunta.

Sucede con bastante frecuencia que tengo pequeñas colecciones que prefiero almacenar como tuplas para evitar modificaciones accidentales y para ayudar al rendimiento. Entonces necesito combinar tales tuplas con listas, y tener que convertir cada una de ellas en listas para obtener un código muy feo.

Tenga en cuenta que += o extend puede funcionar en casos simples. Pero en general, cuando tengo una expresión.

     columns = default_columns + columns_from_user + calculated_columns 

    No sé cuáles de estos son tuplas y cuáles son listas. Así que o tengo que convertir todo a listas:

     columns = list(default_columns) + list(columns_from_user) + list(calculated_columns) 

    O use itertools:

     columns = list(itertools.chain(default_columns, columns_from_user, calculated_columns)) 

    Ambas soluciones son más feas que una simple sum; y la chain también puede ser más lenta (ya que debe iterar a través de las entradas un elemento a la vez).

    Esto no es compatible porque el operador + se supone que es simétrico. ¿Qué tipo de retorno esperarías? El Python Zen incluye la regla.

     In the face of ambiguity, refuse the temptation to guess. 

    Los siguientes trabajos, sin embargo:

     a = [1, 2, 3] a += (4, 5, 6) 

    No hay ambigüedad de qué tipo usar aquí.

    ¿Por qué Python no admite agregar diferentes tipos? La respuesta simple es que son de diferentes tipos. ¿Qué sucede si intentas agregar un iterable y esperas una lista? Yo mismo quisiera devolver otro iterable. También considere ['a','b']+'cd' ¿cuál debería ser la salida? considerando explícito es mejor que implícito, todas las conversiones implícitas son rechazadas.

    Para superar esta limitación, use extend método de lista extend para agregar cualquier iterable, por ejemplo,

     l = [1,2,3] l.extend((4,5,6)) 

    Si tiene que agregar muchas listas / tuplas, escriba una función

     def adder(*iterables): l = [] for i in iterables: l.extend(i) return l print adder([1,2,3], (3,4,5), range(6,10)) 

    salida:

     [1, 2, 3, 3, 4, 5, 6, 7, 8, 9] 

    Puedes usar el operador += , si eso ayuda:

     >>> x = [1,2,3] >>> x += (1,2,3) >>> x [1, 2, 3, 1, 2, 3] 

    También puede usar el constructor de listas explícitamente, pero como mencionó, la legibilidad podría sufrir:

     >>> list((1,2,3)) + list((1,2,3)) [1, 2, 3, 1, 2, 3]