suma Python, ¿por qué no las cadenas?

Question

Python ha construido en función de sum, que es efectivamente equivalente a:

def sum2(iterable, start=0): 
    return start + reduce(operator.add, iterable) 

para todo tipo de parámetros, excepto cuerdas. Funciona para números y listas, por ejemplo:

sum([1,2,3], 0) = sum2([1,2,3],0) = 6 #Note: 0 is the default value for start, but I include it for clarity 
sum({888:1}, 0) = sum2({888:1},0) = 888 

¿Por qué las cadenas se omitieron especialmente?

sum(['foo','bar'], '') # TypeError: sum() can't sum strings [use ''.join(seq) instead] 
sum2(['foo','bar'], '') = 'foobar' 

Creo recordar las discusiones en la lista de Python por la razón, por lo que una explicación o un enlace a un tema explicando que estaría bien.

Editar: Soy consciente de que la forma estándar es hacer "".join. Mi pregunta es por qué la opción de usar sum para cadenas fue prohibida, y no hubo prohibición para, por ejemplo, listas.

Editar 2: Aunque creo que esto no es necesario dado todas las buenas respuestas que obtuve, la pregunta es: ¿Por qué funciona suma en una iterable que contenga números o un iterable que contiene las listas, pero no un iterables que contiene cadenas?

Answer 1

Python intenta desanimarlo para que no "agregue" cadenas. Se supone que debes unirte a ellos:

"".join(list_of_strings) 

Es mucho más rápido y usa mucha menos memoria.

Un punto de referencia rápida:

$ python -m timeit -s 'import operator; strings = ["a"]*10000' 'r = reduce(operator.add, strings)' 
100 loops, best of 3: 8.46 msec per loop 
$ python -m timeit -s 'import operator; strings = ["a"]*10000' 'r = "".join(strings)' 
1000 loops, best of 3: 296 usec per loop 

Editar (para responder edición de OP): En cuanto a por qué las cadenas fueron aparentemente "señalados", creo que es simplemente una cuestión de optimización para un caso común, así como de aplicar las mejores prácticas: puede unir cadenas mucho más rápido con '' .unirse, por lo que prohibir explícitamente las cadenas en sum indicará esto a los novatos.

BTW, esta restricción ha sido en el lugar "siempre", es decir, desde la sum se añadió como una función incorporada (rev. 32347)

Answer 2

De the docs:

la forma preferida, rápido para concatenar una secuencia de cadenas es llamando al '' .join (secuencia).

Al hacer que sum se nieguen a operar en cadenas, Python lo ha alentado a utilizar el método correcto.

Answer 3

Edit: Cambié las partes acerca de la inmutabilidad a la historia.

Básicamente, es una cuestión de preasignación.Cuando se utiliza una sentencia como

sum(["a", "b", "c", ..., ]) 

y esperar que funcione similar a una declaración reduce, el código generado se ve algo así como

v1 = "" + "a" # must allocate v1 and set its size to len("") + len("a") 
v2 = v1 + "b" # must allocate v2 and set its size to len("a") + len("b") 
... 
res = v10000 + "$" # must allocate res and set its size to len(v9999) + len("$") 

En cada uno de estos pasos se crea una nueva cadena, que para uno podría dar un poco de sobrecarga de copia ya que las cadenas son cada vez más largas. Pero ese no es el punto aquí. Lo que es más importante, es que cada cadena nueva en cada línea debe ser asignada a su tamaño específico (que. No lo sé debe asignar en cada iteración de la declaración reduce, puede haber heurística obvia para usar y Python podría asignar un poco más aquí y allá para su reutilización, pero en varios puntos la nueva cadena será lo suficientemente grande para que esto no sirva más y Python debe asignar nuevamente, que es bastante caro.

Un método dedicado como join Sin embargo, el trabajo consiste en determinar el tamaño real de la cadena antes de que comience y, por lo tanto, en teoría solo asignar una vez, al principio y luego simplemente llenar esa nueva cadena, que es mucho más económica que la otra solución.

Answer 4

¡De hecho puede usar sum(..) para concatenar cadenas, si usa el objeto de inicio apropiado! Por supuesto, si usted va tan lejos que ya han entendido lo suficiente para usar "".join(..) todos modos ..

>>> class ZeroObject(object): 
... def __add__(self, other): 
... return other 
... 
>>> sum(["hi", "there"], ZeroObject()) 
'hithere' 

Answer 5

respuesta corta: Eficiencia.

Respuesta larga: La función sum tiene que crear un objeto para cada suma parcial.

Supongamos que la cantidad de tiempo necesaria para crear un objeto es directamente proporcional al tamaño de sus datos. Deje N denotar el número de elementos en la secuencia para sumar.

double s son siempre del mismo tamaño, lo que hace correr O (1) x tiempo sum 's N = O (N).

int (anteriormente conocido como long) es arbitary-length. Deje que M denote el valor absoluto del elemento de secuencia más grande. Entonces, el peor tiempo de ejecución de sum es lg (M) + lg (2M) + lg (3M) + ... + lg (NM) = N × lg (M) + lg (N!) = O (N registro N).

Para str (donde M = la longitud de la cadena más larga), el peor tiempo de ejecución es M + 2M + 3M + ... + NM = M × (1 + 2 + ... + N) = O (N²).

Por lo tanto, sum cadenas ming sería mucho más lento que sum números de ming.

str.join no asigna ningún objeto intermedio. Preasigna un búfer lo suficientemente grande como para contener las cadenas unidas y copia los datos de cadena. Se ejecuta en O (N) vez, mucho más rápido que sum.

Answer 6

Aquí está la fuente: http://svn.python.org/view/python/trunk/Python/bltinmodule.c?revision=81029&view=markup

En la función builtin_sum tenemos este trozo de código:

 /* reject string values for 'start' parameter */ 
     if (PyObject_TypeCheck(result, &PyBaseString_Type)) { 
      PyErr_SetString(PyExc_TypeError, 
       "sum() can't sum strings [use ''.join(seq) instead]"); 
      Py_DECREF(iter); 
      return NULL; 
     } 
     Py_INCREF(result); 
    } 

Así que .. Esa es tu respuesta.

Se ha verificado explícitamente en el código y se ha rechazado.

Answer 7

la razón por la

@ dan04 tiene una excelente explicación de los costos de utilizar sum en grandes listas de cadenas.

La pieza que falta en cuanto a porqué str no está permitido para sum es que muchas, muchas personas estaban tratando de utilizar sum para cuerdas, y no muchos utilizan sum para las listas y tuplas y otros ** O (n 2) estructuras de datos . La trampa es que sum funciona bien para listas cortas de cadenas, pero luego se pone en producción donde las listas pueden ser enormes y el rendimiento se ralentiza. Esta fue una trampa tan común que se tomó la decisión de ignorar el tipado de patos en esta instancia, y no permitir que las cadenas se usen con sum.

Answer 8

No sé por qué, pero esto funciona!

import operator 
def sum_of_strings(list_of_strings): 
    return reduce(operator.add, list_of_strings)