Reduce

La función reduce()

reduce() es una función incorporada de Python 2, que toma como argumento un conjunto de valores (una lista, una tupla, o cualquier objeto iterable) y lo “reduce” a un único valor. Cómo se obtiene ese único valor a partir de la colección pasada como argumento dependerá de la función aplicada.

Por ejemplo, el siguiente código reduce la lista [1, 2, 3, 4] al número 10 aplicando la función accum(counter, item), que retorna la suma de sus argumentos.

<
def accum(counter, item):
	return counter + item

print(reduce(accum, [1, 2, 3, 4]))
> 

La función pasada como primer argumento debe tener dos parámetros. reduce() se encargará de llamarla de forma acumulativa (es decir, preservando el resultado de llamadas anteriores) de izquierda a derecha. De modo que el código anterior es similar a:

<
print(accum(accum(accum(1, 2), 3), 4))
> 

Es decir, la operación realizada es ((1 + 2) + 3) + 4, de la que resulta 10.

A partir de Python 3 la función fue movida al módulo estándar functools.

Reduce(fun, seq) tiene dos parametros:

1. Una función particular a aplicar a todos los elementos de una secuencia
2. Una secuencia de elementos.

Como funciona:

• Primero toma los dos primeros elementos de la secuencia y aplica la función particular.
• Toma el resultado anterior y a este valor mas el siguiente elemento de la secuencia le aplica la función particular.
• El proceso continua hasta que no tiene mas elementos.
• Retorna el resultado.

Me encanta este curso, el tiempo se pasa volando.

Reducí comida de la risa cuando vi el ejemplo jajaja

por si alguna persona quería saber como se sacaba el mayor valor de una lista (es que me quede pensativo cuando lo menciono)

import functools 
num = [8, 1, 2, 3, 4]
def mayor(counter, item):
    if counter <= item :
        return item
    else :
        return counter
result = functools.reduce(mayor, num) 
print (result)

Es Realmente muy mala esta clase.

Despues de tener la mente fria, analizar la funcionalidad de reduce.
pude entenderla un poco.
y creo que es un gran inicio por lo menos para saber en que casos podriamos necesitarla.

miren:
en esta linea de codigo tengo unos productos.

items = [
    {'name':'Mouse',
    'price':100,
    'id': 1},
    {'name':'Teclado',
    'price': 300,
    'id': 2},
    {'name':'Monitor',
    'price':200,
    'id': 3},
    {'name':'Celular',
    'price':150,
    'id':4},
    {'name':'Alcohol',
    'price':475,
    'id': 5},
    {'name':'Control',
    'price': 750,
    'id': 6},
    {'name':'Cuaderno',
    'price':45,
    'id': 7},
    {'name':'Tablero',
    'price':650,
    'id':8}
]

ahora, mi curiosidad me dice:
Como puedo conocer la suma de los precios de estos productos, si los vendo por unidad, todos en un mismo dia?

y hay dos maneras de hacerlo.
te lo explico:

1. crear una función lambda que devuelva la suma de los valores.

no sin antes extrar la informacion que necesitas del diccionario.
para eso usas map.
es importante map porque lo que hace esta belleza de funcion es que transforma una informacion y la devuelve segun tu conveniencia o tu caso.
osea, en este caso queremos una lista de los numeros verdad?
claro, porque podemos tener solo los numeros.
entonces, plash, usamos el codigo:

list_num = list(map(lambda x:x['price'],items))

jam, entonces, ahora.
tenemos de la lista de diccionarios, los precios.
luego entonces.
ahora si viene la magia de reduce.
la importamos usando

from functools import reduce

luego.
creamos la variable donde vamos a guardar el resultado que devuelve reduce.

conclus = reduce(lambda a,b:a + b,list_num)

entonces, aqui, lo que tenemos es una función anónima que lo que hace es recibir dos parámetros que posteriormente los vamos a sumar encadenamente para que nos de una suma de los precios. luego anexamos el iterador que nos devolvio nuestra amada map.
siendo entonces el resultado:2670

ahora. una cosa importante.jijijiji, es que, reduce da un paso adelante,atras y lo que hace es sumar el resultado de sus pasos, no es una funcion que en este caso va corrido.

es util entonces, cuando queremos sacar un solo valor de un iterador, teniendo en cuenta los valores que este iterador almacena.

1. creando una funcion que nosotros en este caso queremos saber como reduce se comporta:

def how_come(a,b):
    return a + b

ahora usamos nuestra amada reduce.

conclus = reduce(how_come,list_num)
print(conclus)

Me parece que el profesor esta equivocado. Si consultamos la documentación oficial de la funcion reduce obtenemos lo siguiente.

reduce(function, iterable[, initial]) -> value

Apply a function of two arguments cumulatively to the items of a sequence
or iterable, from left to right, so as to reduce the iterable to a single
value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the iterable in the calculation, and serves as a default when the
iterable is empty.

Lo cual nos dice… que la funcion reduce debe tener obligatoriamente 2 parametros.

1. Una función.
2. La secuencia o iterable.

La función que se le pasa debe a su vez tener 2 parametros de entrada.

Es donde viene el error del profesor… ya que filter invoca a la función pasada con los 2 primeros elementos del iterable… opera sobre ellos y despues hace una llamada recursiva a la misma funcion cuyo primer argumento será el resultado de la operación de la primer llamada a la función y el segundo argumento para ésta segunda llamada será el tercer elemento del iterable.

Entonces tenemos que la explicación del profesor… aunque funciona no es estrictamente correcta.

De hecho se puede ver como en la salida de su código dice:

counter =>1
item => 2
.
.
.

Lo cual nos indica que el “counter” en realidad es el primer item de la lista.

Un consejo para esta clase, estaria mejor que pudieran colocar un ejemplo un poco mas complicado despues del ejemplo principal y uno ya entiende la idea, asi se puede ver como seria en un uso cotidiano (siendo un programa sencillo)

Sigo sin encontrarle la utilidad a reduce si lo comparo con la función sum() en cuanto a números

Esta sección se me hizo un poco pesada por todos los temas que se vieron 😒 Entonces hice un pequeño compendio de las sintaxis de cada uno de los temas que se revisaron para entenderle yo personalmente, pero espero les sirva.
’
- Sets

# Sintaxis
mi_set = {elemento1, elemento2, elemento3}

# Ejemplo
frutas = {"manzana", "banana", "naranja"}

- Comprehensions
Se usan para iterar listas en una sola linea de código.

# Sintaxis
nueva_lista = [expresion for elemento in coleccion]

# Ejemplo
numeros_pares = [x for x in range(10) if x % 2 == 0]

- Higher Order Function:
Son funciones que pueden recibir otra función como parámetro.

# Sintaxis
def mi_funcion(funcion, coleccion):
    return funcion(coleccion)

# Ejemplo
def cuadrado(x):
    return x ** 2

resultado = mi_funcion(cuadrado, 5)

- Lambda
Funciones que ejecutan una sola expresión, que puede reducirse a una sola línea.

# Sintaxis
mi_lambda = lambda parametros: expresion

# Ejemplo
suma = lambda x, y: x + y
resultado = suma(3, 5)

- Map():
Map transforma listas a otra lista con diferentes elementos al aplicar una función.

# Sintaxis
nueva_coleccion = map(funcion, coleccion)

# Ejemplo
numeros = [1, 2, 3, 4]
cuadrados = map(lambda x: x ** 2, numeros)

- Filter():
Reduce una lista a otra aplicando alguna condición que tu le des.

# Sintaxis
nueva_coleccion = filter(funcion, coleccion)

# Ejemplo
numeros = [1, 2, 3, 4, 5, 6]
pares = filter(lambda x: x % 2 == 0, numeros)

- Reduce():
Reduce una lista a UN solo elemento.

# Sintaxis
from functools import reduce
resultado = reduce(funcion, coleccion, valor_inicial)

# Ejemplo
from functools import reduce
numeros = [1, 2, 3, 4]
suma_total = reduce(lambda x, y: x + y, numeros, 0)

Para los que se pueden perder en el esquema del funcionamiento del Reduce

https://www.youtube.com/watch?v=1FeEvxqOhZs

La funcion reduce() toma los dos primeros elementos de la secuencia y los pasa como argumentos a la función dada (en este caso, una función lambda), obteniendo un resultado. Luego, toma ese resultado y lo utiliza junto con el siguiente elemento de la secuencia como argumentos para la función, y así sucesivamente hasta llegar al último elemento de la secuencia.

Este modulo fue una invitación a estudiar Backend con Python

import functools

numbers = [1, 2, 3, 4]

def accum(counter, item):
  print(f'Counter: {counter}')
  print(f'item: {item}')
  return counter + item

'''
iteration counter item return
   1         0      1    1
   2         1      2    3
   3         3      3    6
   4         6      4    10
'''

result = functools.reduce(lambda counter, item: counter + item, numbers)
#result = functools.reduce(accum, numbers)

print(result)

Fuente: GPT
Pregunta,
Con el codigo anterior, necesito saber porque el counter entra en 1 y el item en 2 ?

Respuesta:
El comportamiento que estás observando, donde el contador (counter) comienza en 1 y el elemento (item) comienza en 2, es un resultado directo de cómo funciona la función functools.reduce y la forma en que está diseñada la función acumulador.

Cuando utilizas functools.reduce, el primer argumento que proporcionas a la función reduce es la función que se aplicará repetidamente a los elementos de la secuencia (numbers en este caso) para reducirlos a un solo valor. En cada paso de la reducción, esta función toma dos argumentos: el “contador” (counter) y el “elemento” (item).

En el primer paso de la reducción, counter toma el valor del primer elemento de la secuencia (1 en este caso) y item toma el valor del segundo elemento de la secuencia (2 en este caso). La función acumulador suma estos dos valores y devuelve 3 como el nuevo valor de counter.

En el siguiente paso de la reducción, counter toma el valor 3 que se devolvió en el paso anterior, y item toma el valor del tercer elemento de la secuencia (3). La función acumulador suma estos dos valores y devuelve 6 como el nuevo valor de counter.

Este proceso continúa hasta que todos los elementos de la secuencia se han procesado, y al final obtienes el resultado acumulado.

En resumen, el contador (counter) comienza con el primer elemento de la secuencia, y el elemento (item) comienza con el segundo elemento de la secuencia en el primer paso de la reducción, y luego se acumulan los valores sucesivamente.

Un ejemplo más cotidiano. Calcula el aumento de precio de una despensa de 599.00, tomando en cuenta la inflación anual durante seis meses:

import functools

def interes(cantidad, interes):
  print(cantidad)
  return cantidad * (1 + interes / 100 / 12)

inflacion = [7.07, 7.28, 7.45, 7.68, 7.65, 7.99]

result = functools.reduce(interes, inflacion, 599)

print(result)

¿Podríamos decir que reduce() es el equivalente en python de las funciones de agregación en SQL? e.g. MAX, MIN, COUNT; ETC? Esto en vista de que arrojan un valor único y no estructuras de datos, como map() y filter()

Código para sacar el factorial de un número usando reduce, no es lo más eficiente pero sirve para entender más:)

def factorial(n):
  numbers = [i for i in range(2, n+1)]
  result = functools.reduce(lambda mult, n : mult*n, numbers)
  return result

n = int(input('Número para sacar el factorial => '))
fact = factorial(n)
print(f'El factorial de {n} es: {fact}')

Podemos utilizar reduce() con un diccionario para combinar sus valores en un solo valor. Por ejemplo, si tenemos un diccionario con nombres y edades, podemos utilizar reduce() con una función lambda para calcular la edad promedio:

ages = {'Juan': 25, 'María': 30, 'Carlos': 20}
average_age = reduce(lambda x, y: x + y, ages.values()) / len(ages)
print(average_age)  # Salida esperada: 25.0

En este ejemplo, reduce() toma los valores del diccionario ages (que son las edades) y la función lambda lambda x, y: x + y como argumentos. La función lambda toma dos argumentos (x e y) y los suma, y el resultado se utiliza como nuevo acumulador para el siguiente valor del diccionario. El resultado final de la función reduce() es la suma de todas las edades, que se divide por el número de elementos en el diccionario para obtener la edad promedio, que es 25 en este caso.

Comparto forma más sencilla de resolverlo:

nums = [2,6,1,1]
result = sum(nums)

print(result)  =>  10

funciones basicas de manipulacion de listas en python:

1. MAP
2. FILTER
3. REDUCE

Con este código pueden hallar el máximo valor de una lista usando reduce:

result2 = functools.reduce(lambda counter, item: counter if counter > item else item, numbers)

Una herramienta muy util e importante cuando no sabemos como esta funcionando el Código o tenemos errores y no sabemos porque, el debugger es una herramienta muy util, y para los que están utilizando vs code, ya viene al instalar las extensiones

REDUCE

Tenemos el siguiente código:

import functools
#Calculamos la sumatoria de los números en la lista:

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

#Definimos la función suma

def suma(x, y): 
    return x + y

#Obtenemos el resultado final:

resultado = functools.reduce(suma, numeros)
print(resultado)

EXPLICACION

• En el contexto de la función reduce(), los parámetros x e y representan los dos primeros elementos de la secuencia iterable en cada llamada a la función. La función reduce() utiliza estos dos elementos como entrada para la función que le proporcionas, en este caso, la función suma(x, y).

Inicialmente, x toma el valor del primer elemento de la secuencia iterable y y toma el valor del segundo elemento. Luego, la función suma(x, y) se aplica a estos dos valores, y el resultado se convierte en el nuevo valor de x. Entonces, x se convierte en una especie de “contador acumulativo” y y toma el siguiente elemento de la secuencia.

• Este proceso se repite hasta que se haya recorrido toda la secuencia iterable. En cada paso, x toma el resultado de la función aplicada a los dos elementos anteriores y y toma el siguiente elemento en la secuencia. Finalmente, el resultado de la función reduce() es el valor final de x, que representa el resultado acumulado de aplicar la función a todos los elementos de la secuencia.

Entonces, en efecto, x puede considerarse como un “contador acumulativo” y y como el “próximo elemento” de la secuencia en cada paso de la reducción.

Aporto dos programitas sencillos combinando reduce con lambdas.

import functools

"""
1. Dada una lista de diccionarios con claves "producto" y "cantidad", calcular el total de la cantidad de productos.
"""

lista = [ {
            'producto' : 'cajas',
            'cantidad': 50
          },
          { 
            'producto' : 'lapices',
            'cantidad': 32
          },
         { 
            'producto' : 'cuadernos',
            'cantidad': 12
          },
         { 
            'producto' : 'pincel',
            'cantidad': 3
          }
        ]


resultado = functools.reduce(lambda counter, cantidad: counter+cantidad['cantidad'], lista, 0)
print(resultado)

import functools

"""
2. Dada una lista de diccionarios con claves "nombre" y "puntuacion", calcular el promedio de puntuaciones.
"""

lista = [ {
            'nombre' : 'juan',
            'puntuacion': 9.5
          },
          { 
            'nombre' : 'lau',
            'puntuacion': 6.4
          },
         { 
            'nombre' : 'miguel',
            'puntuacion': 10
          },
         { 
            'nombre' : 'poncho',
            'puntuacion': 8.9
          }
        ]


resultado = functools.reduce(lambda counter, puntuac: counter+puntuac['puntuacion']/4, lista, 0)
print(resultado)

Experimente un poco y vi una forma manual de crear un Reduce

def manual_reduce(func, iterable, counter=0):
    for item in iterable:
        counter = func(counter, item)
    return counter

resultado = manual_reduce(lambda counter, item: counter + item, lista)
print(resultado)

resultado = manual_reduce(lambda counter, item: counter if counter > item else item, lista)
print(resultado)

te la rifaste con esta explicación, Nicolás XD

La función reduce() en Python se encuentra en el módulo functools y se utiliza para aplicar una función acumulativa a los elementos de una secuencia, de manera que se reduce la secuencia a un solo valor.

La sintaxis básica de reduce() es la siguiente:

reduce(función, secuencia)

Donde:

• función: Es la función que se aplicará a los elementos de la secuencia de forma acumulativa.
• secuencia: Es la secuencia de elementos sobre la cual se aplicará la función.

Sin embargo, a partir de Python 3, reduce() ya no es una función incorporada, sino que se encuentra en el módulo functools. Por lo tanto, antes de usar reduce(), es necesario importarla de la siguiente manera:

from functools import reduce

Aquí tienes un ejemplo que muestra cómo utilizar reduce() para sumar los elementos de una lista:

from functools import reduce

# Definimos una función para sumar dos números
def suma(a, b):
    return a + b

# Creamos una lista de números
numeros = [1, 2, 3, 4, 5]

# Aplicamos la función suma a los elementos de la lista usando reduce()
resultado = reduce(suma, numeros)

# Imprimimos el resultado
print(resultado)

En este ejemplo, importamos reduce del módulo functools. Luego, definimos la función suma() que toma dos números y devuelve su suma. Creamos una lista llamada numeros con varios números.

Usamos reduce() para aplicar la función suma() de forma acumulativa a los elementos de la lista numeros. El resultado es un solo valor que representa la suma de todos los elementos.

Finalmente, imprimimos el resultado, que en este caso será:

15

En resumen, la función reduce() se utiliza para aplicar una función acumulativa a los elementos de una secuencia y reducir la secuencia a un solo valor.

El instructor es muy bueno enseñando, pero en esta clase si quedo a deber mucho. Hice lo siguiente de forma simple y sin sentido para ayudarme a entender el proceso que realiza el método Reduce:

items = [
    {
        'Player': 'Mbappe',
        'Goals': 0
    },
    {
        'Player': 'Ronaldo',
        'Goals': 0
    },
    {
        'Player': 'Messi',
        'Goals': 0
    },    
]

import random, copy, functools
copy_items = copy.deepcopy(items)

def update_values(goals):
    goals['Goals'] = goals['Goals'] + random.randint(0, 5)
    return goals

add_goals = list(map(update_values, copy_items))

select_players = list(filter(lambda x : x['Goals'] >= 3, add_goals))
print('\nJugadores que anotaron 3 goles o mas en su partido: \n', select_players,'\n')

get_list = list(map(lambda item : item['Goals'], add_goals))
print('Lista de goles de los tres jugadores: \n', get_list,'\n')

# En este caso mi lista es de tres elementos, entonces:
# counter tomare el utimo valor que conoce (la posicion cero de la lista)
# next_value tomara el segundo valor de la lista
# counter tomare el utimo valor que conoce (el resultado de sumar el valor que tomo antes counter con el valor que tiene next_value)
# next_value tomara el tercer valor de la lista
# El resultado es la suma de los ultimos valores que tienen counter y next_value
sum_goals = functools.reduce(lambda counter, next_value: counter + next_value, get_list)
print('Total de goles en los tres partidos: \n', sum_goals,'\n')

creo que puede mejorar ese ejemplo para no tener una lista con números que son los mismos de la iteración.

Uso de la función reduce para calcular el factorial de un numero:

from functools import reduce

n = int(input('Ingrese un numero entero positivo: '))

print(f'{n}!=',reduce(lambda a,b:a*b,list(range(1,n+1))))

Se ve mejor la manera en que toma los datos con otros números
😅

import functools

numbers = [5, 6, 7, 8]

def accum(counter, item):
  print('counter => ',counter)
  print('item => ',item)
  return counter + item

result = functools.reduce(accum, numbers)

print(result)

import functools

numbers = [1,2,3,4]

def accum(counter, item):
  print('counter => ',counter)
  print('item => ',item)
  return counter + item

result = functools.reduce(accum, numbers)

print(result)

Reduce recibe un tercer argumento: initializer que por defecto es None.
Además de reduce existe otra función similar, accumulate del módulo itertools.

Aquí pueden ver un artículo interesante

Genial!

En resumen, reduce() es una función versátil que se puede usar con varias estructuras de datos iterables en Python, no solo con listas. Su uso ha disminuido con la introducción de funciones más específicas en Python 3, en gran medida por otras funciones más modernas y específicas como sum(), any(), min(), max(), etc., que ofrecen una sintaxis más clara y eficiente para tareas comunes. Sin embargo, reduce() sigue siendo una herramienta útil para comprender la programación funcional y para casos de uso más complejos que requieren una reducción personalizada.

Especificando un valor inicial

También puedes especificar un valor inicial para el cálculo acumulativo. Por ejemplo, si quieres calcular el producto de los números en una lista:

from functools import reduce

numeros = [1, 2, 3, 4, 5]
producto_total = reduce(lambda a, b: a * b, numeros, 1)

print(producto_total)  # Output: 120

En este caso, el valor inicial de 1 se utiliza como punto de partida para el cálculo acumulativo; es decir, el 1 será el primer número a multiplicar por el 1 de la lista, en este ejemplo.

ejemplo:

from functools import reduce

def suma_acumulativa(a, b):
    return a + b

numeros = [1, 2, 3, 4, 5]
suma_total = reduce(suma_acumulativa, numeros)

print(suma_total)  # Output: 15

Es este ejemplo, la función ´suma_acumulativa()´ se aplica de manera acumulativa a los elementos de la lista ´numeros´ usando ´reduce()´, lo que resulta en la suma total de los números

Definición
´reduce()´ es una función del módulo ´functools´ en Python que toma una función de reducción, una secuencia de elementos y opcionalmente un valor inicial. Aplica la función de reducción de manera acumulativa a los valores de la secuencia y devuelve el resultado reducido a un solo valor.

2 EJEMPLOS MÁS:

import functools as fc

num = [1,2,3,4,5]
result = fc.reduce(lambda x,y: x * y, num)
print(result)

OUTPUT: 120

letters = ['E','N','J','O','Y']
result2 = fc.reduce(lambda x,y: x + y, letters)
print(result2)

OUTPUT: ENJOY

Super útil…!

si pasamos a la lista de numeros el 0…
se entiende mejor.

En este ejercicio aprendi a como reducir mi ejercicio a uno solo. Que bueno que aprendi las funciones basicas de python.

# Reduce

'''
Reducir una referencia a un solo valor, por ejemplo, hacer una suma de un array de números 
numbers = [1, 2, 3, 4] => 10

'''

import functools

numbers = [1, 2, 3, 4]

def accum(counter, item):
  print('counter => ',counter)
  print('item => ',item)
  return counter + item

# result = functools.reduce(lambda counter, item:counter + item, numbers)

result = functools.reduce(accum, numbers)

print(result)

Nombre de la Función: functools.reduce()

Módulo: functools

Descripción: La función reduce() se utiliza para aplicar una función acumulativa a los elementos de una secuencia (como una lista) de izquierda a derecha, lo que reduce la secuencia a un solo valor acumulado. Esta función es útil para realizar operaciones acumulativas como suma, multiplicación, concatenación, entre otras.

Sintaxis General:

pythonCopy code
functools.reduce(función, secuencia[, valor_inicial])

Argumentos:

• función: Una función que toma dos argumentos y realiza una operación entre ellos. Esta función se aplicará secuencialmente a los elementos de la secuencia.
• secuencia: La secuencia de elementos a la cual se aplicará la función acumulativa.
• valor_inicial (opcional): Un valor inicial que se utiliza como primer acumulador. Si se proporciona, la función acumulativa se aplicará primero a valor_inicial y al primer elemento de la secuencia. Si no se proporciona, el primer elemento de la secuencia se utiliza como valor inicial.

Resultado: La función reduce() devuelve el valor acumulado después de aplicar la función acumulativa a todos los elementos de la secuencia.

Ejemplo de Uso:

pythonCopy code
import functools

# Definir una función que suma dos números
def sumar(x, y):
    return x + y

numeros = [1, 2, 3, 4, 5]

# Utilizar reduce() para encontrar la suma de los números en la lista
resultado = functools.reduce(sumar, numeros)

print(resultado)  # Output: 15 (1 + 2 + 3 + 4 + 5)

Notas Importantes:

• La función función debe ser capaz de manejar los elementos de la secuencia y realizar una operación válida entre ellos.
• El orden de aplicación de la función acumulativa es de izquierda a derecha en la secuencia.
• reduce() es especialmente útil cuando deseas realizar operaciones acumulativas en una secuencia de elementos, como sumar, multiplicar, concatenar, entre otras.
• Puedes personalizar la función función según la operación que desees realizar en los elementos de la secuencia.

Recuerda que functools.reduce() es una herramienta poderosa para operaciones acumulativas y puede ser utilizada en una variedad de situaciones donde necesites combinar elementos de una secuencia en un solo valor acumulado.

La función reduce() en Python se utiliza para aplicar una función acumulativa a los elementos de una secuencia (por ejemplo, una lista) de izquierda a derecha, de manera que se reduce la secuencia a un solo valor acumulado. Esto significa que se toma un elemento a la vez de la secuencia y se combina con un acumulador utilizando la función especificada.

La sintaxis general de reduce() es la siguiente:

pythonCopy code
functools.reduce(función, secuencia[, inicial])

Donde:

• función: Es una función que toma dos argumentos y realiza una operación entre ellos. Esta función se aplicará secuencialmente a los elementos de la secuencia.
• secuencia: Es la secuencia de elementos (por ejemplo, una lista) a la cual se aplicará la función acumulativa.
• inicial (opcional): Es un valor inicial que se utiliza como primer acumulador. Si se proporciona, la función acumulativa se aplicará primero a inicial y al primer elemento de la secuencia. Si no se proporciona, el primer elemento de la secuencia se utiliza como valor inicial.

Aquí hay un ejemplo que muestra cómo usar reduce() para encontrar el producto de una lista de números:

pythonCopy code
from functools import reduce

# Definir una función que multiplique dos números
def multiplicar(x, y):
    return x * y

numeros = [1, 2, 3, 4, 5]

# Usar reduce() para encontrar el producto de los números en la lista
producto = reduce(multiplicar, numeros)

print(producto)  # Output: 120 (1 * 2 * 3 * 4 * 5)

En este ejemplo, la función multiplicar(x, y) toma dos números x e y y devuelve su producto. Luego, utilizamos reduce() para aplicar esta función a todos los elementos de la lista numeros. El resultado es el producto de todos los números en la lista.

reduce() es útil cuando necesitas realizar operaciones acumulativas en una secuencia, como encontrar la suma, el producto o cualquier otra operación que combine elementos de la secuencia en un solo valor.

Les comparto un ejercicio que intenté hacer con reduce y me tocó preguntarle a chatgpt que me explicará, lo curioso es que a reduce se le puede pasar un tercer elemento que es el que tomaría el contador para iniciar… les dejo el ejercicio y la explicación!

# 2. Crear una función que tome una lista de palabras y devuelva la longitud total de todas las palabras.
from functools import reduce

def longitud_total_palabras(lista_palabras):
    return reduce(lambda x, y: x + len(y), lista_palabras, 0)

# Ejemplo de uso
words = ['hola', 'juanes', 'exito']
resultado = longitud_total_palabras(words)
print("Longitud total de palabras:", resultado)

 # explicación:
    # En este ejemplo, hemos importado reduce de la librería functools. La función reduce toma una función y una secuencia (en este caso, la lista de palabras) y aplica la función acumulativamente a los elementos de la secuencia, acumulando un valor a medida que avanza. En este caso, la función lambda toma dos argumentos x e y, donde x es el acumulador y y es la palabra actual en la lista. 
    # La función suma la longitud de y a x y devuelve el resultado. La 0 al final es el valor inicial del acumulador.
    # El resultado será la longitud total de todas las palabras en la lista words.
    # El 0 que se pasa como tercer argumento a la función reduce en el ejemplo anterior es el valor inicial del acumulador. 
    # En reduce, el acumulador es el valor que se va acumulando a medida que la función proporcionada se aplica a los elementos de la secuencia.
    # En este caso, al proporcionar 0 como valor inicial, estamos diciendo que el acumulador comienza con un valor de cero antes de comenzar a iterar sobre la lista de palabras.
    #  A medida que la función lambda se aplica a cada palabra en la lista, el acumulador (inicializado en 0) se actualiza sumando la longitud de cada palabra.
    # El valor inicial es importante porque define el estado inicial del acumulador antes de comenzar a procesar la secuencia.
    #  Dependiendo de la situación, este valor inicial puede ser diferente; por ejemplo, si quisieras multiplicar todos los elementos de una lista,
    #   podrías usar 1 como valor inicial en lugar de 0.

Importante para los que quedaron un poco perdidos con la clase..

La función reduce() en Python se utiliza para aplicar una función a un iterable (lista, tupla, etc) de forma acumulativa para reducirlo a un único valor.

para el caso del ejemplo dado en la clase:

import functools

numbers = [3, 5, 7, 9]
def accum(counter, item):
  print('counter => ', counter)
  print('item => ', item)
  print('valor a retornar=>', counter + item)
  return counter + item

result = functools.reduce(accum, numbers)

como podemos darnos cuenta en el ejemplo se coloco varios mensajes impresos para mostrar los valores de los parametros que recibe la funcion en cada iteracion:

**ouput**
counter =>  3
item =>  5
valor a retornar=> 8

counter =>  8
item =>  7
valor a retornar=> 15

counter =>  15
item =>  9
valor a retornar=> 24

resultado:: 24

como no le estamos indicando cual es el valor inicial del acumulador entonces el programa hace solo tres iteraciones donde la primera iteración inicializara la variable counter con el primer elemento de la lista numbers, en este caso 3 y la variable item contendra el valor del segundo elemento de la lista, y asi seguira recorriendo los demas elementos de la lista.

ahora le podemos indicar un valor inicial a la funcion reduce, con la sigueinte instruccion:

result = functools.reduce(accum, numbers, 0) 

en este caso el programa sabe que la variable counter comenzara con el valor 0 y por lo tanto el valor que tomara la variable item sera la del primer elemento de la lista, esto conlleva a. que se realicen cuatro iteraciones en vez de tres.

Primera iteración: counter=0, item=3 -> retorna 0 + 3 = 3
Segunda iteración: counter=3, item=5 -> retorna 3 + 5 = 8
Tercera iteración: counter=8, item=7 -> retorna 8 + 7 = 15
Cuarta iteración: counter=15, item=9 -> retorna 15 + 9 = 24

En resumen, dependiendo si queremos que el acumulador empiece en 0 o en el primer elemento, pasamos o no el tercer argumento a reduce().
espero haya ayudado a resolver alguna duda que se tenga.

Lo que comprendo y supongo es que la función functools.recude() es la que hace las iteraciones para la función accum(counter, item). Ya que si no lo usáramos la función accum(counter, item) solo hace una iteración.

import functools

lista = [1,2,3,4]

def acumulador (counter , item):
print (" contador : " ,counter)
print (" item: " ,item)
return counter + item

resultado = functools.reduce(acumulador , lista)
print(" el resultado es: " ,resultado)

from functools import reduce

def suma(acumulador, elemento):
    return acumulador + elemento

numeros = [1, 2, 3, 4, 5]

resultado = reduce(suma, numeros)
print(resultado)  # Output: 15 (1 + 2 + 3 + 4 + 5 = 15)

Los slides llegan a ser un poco confusos ya que se ven mucho números y su única distinción es el encabezado.

Hubiera sido muy útil utilizar números romanos e la primera columna.

Pero bien explicado, gracias.

Es cuestión de practicar.

La función reduce() en Python se utiliza para aplicar una función a un iterable (lista, tupla, etc) de forma acumulativa para reducirlo a un solo valor.

La sintaxis de reduce() es:

reduce(función, iterable[, valor_inicial])

Donde:

• función: es la función que se aplicará de forma acumulativa. Debe tener dos argumentos.
• iterable: la secuencia a reducir.
• valor_inicial (opcional): valor inicial sobre el que se aplicará la función.

Por ejemplo, para sumar todos los elementos de una lista:

from functools import reduce

lista = [1,2,3,4,5]

suma = reduce(lambda x, y: x + y, lista)

print(suma) # 15

En este caso la función es una lambda que suma dos números. Reduce aplicará esta función de forma acumulativa a la lista:

1. Primero x=1 y=2, entonces devuelve 1 + 2 = 3
2. Luego x=3 y=3, entonces devuelve 3 + 3 = 6
3. Luego x=6 y=4, entonces devuelve 6 + 4 = 10
4. Y así sucesivamente hasta reducir la lista a un solo valor.

Otros usos comunes son concatenar elementos de una lista, encontrar el máximo o mínimo, etc.

En resumen, reduce() aplica una función de dos argumentos acumulando los elementos de izquierda a derecha para reducir una secuencia a un único valor.

Hay algo aquí que hace falta y es decir que por defecto el valor inicial no tiene que ser obligatoriamente el cero. La función reduce recibe un tercer argumento (opcional) que establece cuál será el valor inicial (puede ser lista, diccionario, entero, etc)

Ejemplo:
Obtener el valor de la ruta usando functools.reduce, el resultado deberia ser lo contenido en dicha ruta, es decir, 412100015

import functools

core = {
    'utils': {},
    'dates': {
        'str': {
            'timestamp': 412100015
        }
    }
}

route = 'dates.str.timestamp'

valorFinal = functools.reduce(lambda d, key: d.get(key), route.split('.'), core)

print(valorFinal)

o sea que los ultimos 2 numeros son los que van a generar la suma

La función reduce() es una función de la biblioteca estándar de Python que permite aplicar una operación acumulativa a una secuencia de elementos y devolver un resultado único. Requiere que se importe el módulo functools.

La sintaxis básica de reduce() es la siguiente:

import functools

resultado = functools.reduce(función, secuencia)

La función reduce() toma dos argumentos: la función que se aplicará repetidamente a los elementos de la secuencia y la secuencia en la que se aplicará la operación acumulativa.

La función pasada a reduce() debe ser una función que tome dos argumentos y devuelva un resultado. Esta función se aplicará a pares de elementos adyacentes en la secuencia de izquierda a derecha, acumulando el resultado de la operación.

Aquí hay un ejemplo para ilustrar el uso de reduce():

import functools

# Función para sumar dos números
def sumar(a, b):
    return a + b

# Utilizar reduce() para sumar los elementos de una lista
lista = [1, 2, 3, 4, 5]
resultado = functools.reduce(sumar, lista)
print(resultado)  # Imprime: 15

En este ejemplo, se define la función sumar() que simplemente suma dos números. Luego, se utiliza reduce() junto con sumar como argumento de función y lista como la secuencia de números. La función reduce() aplicará la función sumar sucesivamente a los elementos de la lista, acumulando el resultado. En este caso, se suman todos los números de la lista y se obtiene el resultado 15.

Es importante tener en cuenta que reduce() requiere al menos dos elementos en la secuencia para funcionar correctamente. Si se pasa una secuencia vacía, se generará un error. Si se desea aplicar reduce() a una secuencia con un solo elemento, se debe tener en cuenta y manejar adecuadamente ese caso.

La función reduce() en Python permite aplicar una operación acumulativa a una secuencia de elementos, utilizando una función específica para combinar los elementos adyacentes. Esto permite obtener un resultado único a partir de la secuencia.

Si quieren tener la tabla de referencia, tal vez estos print les pueda servir.

print ("{:<8} {:<15} {:<10} {:<10}".format('Iter','Counter','Item','Return'))
def accum(counter, item):
    print ("{:<8} {:<15} {:<10} {:<10}".format(item, counter, item, counter + item))
    return counter + item

"""
Iter     Counter         Item       Return    
1        0               1          1         
2        1               2          3         
3        3               3          6         
4        6               4          10  
"""

No es una función .reduce(), pero esta es otra forma de sumar los números en una lista:

numeros = [1,2,3,4,5]

suma = sum(numeros)
print(suma)

En realidad las 3 funciones vistas son una triada muy útil para ** ITERABLES** , y no solo para LISTAS como se menciona en la clase.

Deberíamos ser más estrictos al respecto, ojalá se corrija.

Me gusta como lo explica con ejemplos simples, e imágenes asi.

Esta ha sido la primera explicación del teacher que no ha sido clara, para tenerlo mas claro quiero dejar mi explicación como yo la entendi.

tengamos presente como funciona reduce

reduce(funcion, iterable)

1. entendamos lo mas facil que es el iterable en la funcion reduce, no es nada mas que la lista, tupla o diccionario, es decir elementos que podemos iterar.

ahora lo complicado que parece complicado pero que es facil jeje

1. la funcion que vamos a ingresar tiene que tener definidos dos argumentos (1) el valor acumulado que el profe llama counter (pero lo vamos a cambiar por acumulador para entender mejor) y el valor de iteracion que el profe llama item(este lo vamos a cambiar por valor_de_mi_lista). veamos el ejemplo.

#definimos nuestra lista
nums= [4, 5, 7, 8]

#definimos nuestra funcion
def suma(acumulador, valor_de_mi_lista):
	return acumulador + valor_de_mi_lista #Nota importante, el acumulador siempre va ser el primer valor de tu lista y el valor_de_mi_lista siempre va ser tu segundo valor

resultado = functools.reduce(suma, nums) # resultado 24

ahora bien entendamos las iteraciones y que hace mi funcion reduce.

mi funcion toma los dos primeros valores consecutivos de mi lista y a partir de ahi empezamos a iterar.

1. acumulador = 4, valor_de_mi_lista = 5,
   resultado = 9, ahora este es mi nuevo valor de acumulador.
2. acumulador = 9, valor_de_mi_lista = 7
   resultado = 16, ahora este es mi nuevo valor de acumulador.
3. acumulador = 16, valor_de_mi_lista = 8
   resultado = 24.

espero esto pueda ser de ayuda para su entendimiento de la funcion.

Les comparto un ejemplo de como obtener el número más alto/bajo con un reduce:

import functools
import random

rand_number = lambda x: random.randint(1, 1000)

numbers = [rand_number(it) for it in range(0, 1000)]
print(numbers)
# result = functools.reduce(lambda counter, item: counter + item, numbers)

def biggerNum(counter, item):
	# Para encontrar el más pequeño sería counter > item
	if counter < item:
		return item
	return counter

result = functools.reduce(biggerNum, numbers)

print(result)

El primer ejemplo GPT se baso en el ejemplo del profe 🤣 pero el ultimo ejemplo esta mas cool:

The reduce() function is used to apply a particular function passed in its argument to all of the list elements mentioned in the sequence passed along. It is used to perform a repetitive operation over the pairs of the list. Here are three examples of when you might want to use reduce() in Python:

• Summing up a list of numbers: You can use reduce() to sum up all the numbers in a list. For example, if you have a list of numbers [1, 2, 3, 4], you can use reduce() with the lambda function to sum them up as follows: reduce(lambda x, y: x + y, [1, 2, 3, 4]). This will return 10.

• Finding the maximum value in a list: You can use reduce() to find the maximum value in a list. For example, if you have a list of numbers [1, 2, 3, 4], you can use reduce() with the lambda function to find the maximum value as follows: reduce(lambda x, y: x if x > y else y, [1, 2, 3, 4]). This will return 4.

• Flattening a nested list: You can use reduce() to flatten a nested list. For example, if you have a nested list [[1, 2], [3], [4, 5]], you can use reduce() with the lambda function and the extend() method to flatten it as follows: reduce(lambda x,y: x.extend(y) or x, [[1, 2], [3], [4, 5]]). This will return [1, 2, 3, 4, 5].

2:40
El profesor lo explica bien…
The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable … https://docs.python.org/3.10/library/functools.html?highlight=reduce#functools.reduce

En esta clase escribí una lista con las potencias de dos desde el dos hasta un valor denominado tope. Mediante la función result calculé la suma de las potencias de dos y mediante una fórmula que calcula la suma de las potencias de 2 se realizó una comprobación del resultado.

import functools

top = 11     # valor tope
numbers = [2**i for i in range(1,top+1)]
print(numbers)

result = functools.reduce(lambda counter, item : counter+item, numbers)   # calculo de la suma

test = 2*(2**top-1)    # comprobación mediante la fórmula

print(result)
print(test)