significa - simbolos en python

La suma condicional en Python se basa en la entrada de fila

Question

Estoy tratando de hacer un producto de suma condicional en Python. La idea simplificada es la siguiente:

A = [1 1 2 3 3 3]
B = [0.50 0.25 0.99 0.80 0.70 0.20]

Me gustaría tener como salida

Total1 = 0.50*1 + 0.25*1
Total2 = 0.99*2
Total3 = 0.80*3 + 0.70*3 + 0.20*3

Estaba pensando en usar una estructura FOR ... IF ... para especificar que para un valor dado en A deben sumar todos los valores correspondientes en B

En realidad, es un gran conjunto de datos, ¿así que tendré que hacer que el script sea capaz de recorrer todas las categorías?

En este momento estoy luchando para que la idea se traduzca a una secuencia de comandos de Python adecuada. ¿Puede alguien señalarme la dirección correcta?

Answer 1

Parece un ajuste excelente para itertools.groupby (suponiendo que los valores en A estén ordenados , probablemente no funcionaría correctamente para A=[1,1,2,2,1] ):

from itertools import groupby
A = [1, 1, 2, 3, 3, 3]
B = [0.50, 0.25, 0.99, 0.80, 0.70, 0.20]

for key, grp in groupby(zip(A, B), key=lambda x: x[0]):
    grp = [i[1] for i in grp]
    print(key, key * sum(grp))

que imprime:

1 0.75
2 1.98
3 5.1

También puede almacenarlo en una lista en lugar de imprimir los valores:

res = []
for key, grp in groupby(zip(A, B), key=lambda x: x[0]):
    grp = [i[1] for i in grp]
    res.append(key*sum(grp))
print(res)
# [0.75, 1.98, 5.1]

En caso de que un paquete de terceros sea una opción para ti, también puedes usar iteration_utilities.groupedby :

>>> from iteration_utilities import groupedby
>>> from operator import itemgetter, add

>>> {key: key*sum(value) for key, value in groupedby(zip(A, B), key=itemgetter(0), keep=itemgetter(1)).items()}
{1: 0.75, 2: 1.98, 3: 5.1}

o usando el parámetro de groupedby de groupedby directamente:

>>> groupedby(zip(A, B), key=itemgetter(0), keep=lambda x: x[0]*x[1], reduce=add)
{1: 0.75, 2: 1.98, 3: 5.1}

Descargo de responsabilidad: soy el autor del paquete iteration_utilities .

Answer 2

Creo que puedes resolver esto usando itertools.groupby :

import itertools
from operator import itemgetter

results = [group * sum(v[1] for v in values)
           for group, values in itertools.groupby(zip(A, B), itemgetter(0))]

Esto supone que todos los números iguales en A son adyacentes entre sí. Si no lo son, deberías ordenarlos o usar un algoritmo diferente.

Answer 3

He venido con algo como esto. No tengo idea de qué hacer con el borde y que con suerte podría eliminarse:

In [1]: sums = {}
In [2]: A = [1, 1, 2, 3, 3, 3]
   ...: B = [0.50, 0.25, 0.99, 0.80, 0.70, 0.20]
In [3]: for count, item in zip(A, B):
    ...:     try:
    ...:         sums[count] += item * count
    ...:     except KeyError:
    ...:         sums[count] = item * count
    ...:         

In [4]: sums
Out[5]: {1: 0.75, 2: 1.98, 3: 5.1}

Editar:

Como se sugiere en los comentarios, deafultdict podría usarse para deshacerse de este feo bloque try-except :

In [2]: from collections import defaultdict

In [3]: sum = defaultdict(lambda: 0)

In [4]: sum[1]
Out[4]: 0

In [5]: sum
Out[5]: defaultdict(<function __main__.<lambda>>, {1: 0})

EDIT2:

Bueno, he aprendido algo hoy. Después de más comentarios:

In [6]: sums = defaultdict(int)

In [7]: A = [1, 1, 2, 3, 3, 3]
   ...: B = [0.50, 0.25, 0.99, 0.80, 0.70, 0.20]

In [8]: for count, item in zip(A, B):
   ...:     sums[count] += count * item
   ...:     

In [9]: sums
Out[9]: defaultdict(int, {1: 0.75, 2: 1.98, 3: 5.1})

Answer 4

Si no te importa utilizar numpy para esto y suponiendo que los grupos están ordenados, puedes hacerlo de la siguiente manera:

A = [1, 1, 2, 3, 3, 3]
B = [0.50, 0.25, 0.99, 0.80, 0.70, 0.20]
A = np.asarray([1, 1, 2, 3, 3, 3])
B = np.asarray([0.50, 0.25, 0.99, 0.80, 0.70, 0.20])
index = np.full(len(A),True)
index[:-1] = A[1:] != A[:-1]
prods = A*B

#result
res = np.add.reduceat(prods, np.append([0], (np.where(index)[0]+1)[:-1]))

Además, dado que tiene grandes listas, esto realmente podría acelerar las operaciones