• La composición y la abstracción son dos conceptos relacionados:

  • Componer consiste en combinar elementos entre sí para formar otros más complejos.

  • Abstraer consiste en coger un elemento (normalmente complejo), darle un nombre y ocultar sus detalles internos (es decir, los elementos que lo componen) dentro de una caja negra.

• Lo interesante es que la composición y la abstracción son dos mecanismos recursivos:

  • Podemos aplicar la composición para crear nuevos elementos complejos a partir de otros elementos complejos.

  • Podemos aplicar la abstracción para crear nuevas abstracciones a partir de otras abstracciones.

• Además, por supuesto, podemos crear abstracciones a partir de composiciones y composiciones a partir de abstracciones.

• Por ahora, esos conceptos (composición y abstracción) sólo los hemos aplicado a las instrucciones del programa:

  • La composición de instrucciones da lugar a las expresiones compuestas y a las sentencias compuestas (también llamadas estructuras de control: secuencia, selección e iteración).

  • La abstracción de instrucciones da lugar a las abstracciones funcionales.

• Pero también se pueden aplicar a los datos:

  • La composición de datos da lugar a los datos compuestos (también llamados datos estructurados) y, en consecuencia, a los tipos de datos compuestos (también llamados tipos de datos estructurados).

  • La abstracción de datos da lugar a los datos abstractos y, en consecuencia, a los tipos abstractos de datos.

• En esta unidad hablaremos de la composición de datos y dejaremos la abstracción de datos para una unidad posterior.

• Normalmente, se puede acceder de manera individual a los elementos que componen un dato estructurado y, a veces, también se pueden modificar esos elementos de manera individual.

• El término estructura de datos se suele usar como sinónimo de tipo de dato estructurado, aunque nosotros haremos una distinción:

  • Usaremos tipo de dato estructurado cuando usemos un dato sin conocer sus detalles internos de implementación.

  • Usaremos estructura de datos cuando nos interesen esos detalles.

• En Python, el término más utilizado es el de colección.

• Una colección en Python es un objeto que representa un número finito de elementos (bien almacenándolos o bien generándolos), y que proporciona una interfaz estandarizada para acceder, recorrer y consultar esos elementos.

• Entre otras operaciones, una colección admite:

  • Consultar su tamaño (es decir, el número de elementos que contiene), mediante la función len.

  • Consultar si un elemento pertenece a la colección, mediante el operador in.

  • Además, dispone de otras operaciones dependiendo del tipo concreto de colección que se trate.

• Las colecciones en Python son todos objetos iterables (concepto que estudiaremos en breve).

• Según su mutabilidad:

  • Inmutables: el dato estructurado no puede cambiar nunca su estado interno a lo largo de su vida.

  • Mutables: el dato estructurado puede cambiar su estado interno a lo largo de su vida sin cambiar su identidad.

• El contenido de un dato estructurado forma parte del estado interno de ese dato, por lo que cambiar el contenido de un dato estructurado supone cambiar también su estado interno.

• Por ejemplo, si en la lista [7, 8, 9] sustituimos su segundo elemento (el 8) por un 5 para obtener la lista [7, 5, 9], estamos cambiando el contenido de la lista y, por consiguiente, su estado interno.

  Su identidad no ha cambiado, pero su estado interno sí.

• Según su materiabilidad:

  • Materializadas: todos los elementos se encuentran almacenados en memoria simultáneamente ocupando el espacio que sea necesario.

  • Calculadas: los elementos no están todos almacenados en memoria simultáneamente, sino que se calculan y se entregan individualmente a medida que se accede a cada uno de ellos.

• En Python, los rangos son colecciones calculadas, mientras que el resto de colecciones son materializadas.

\text{Tipos} \begin{cases} \text{Escalares (\texttt{int}, \texttt{float}, \texttt{bool}, \texttt{NoneType}, \ldots)} \\ \\ \text{Estructurados} \begin{cases} \text{Secuencias} \begin{cases} \text{Inmutables} \begin{cases} \text{Cadenas (\texttt{str})} \\ \text{Tuplas (\texttt{tuple})} \\ \text{Rangos (\texttt{range})} \end{cases} \\ \\ \text{Mutables} \begin{cases} \text{Listas (\texttt{list})} \end{cases} \end{cases} \\ \\ \text{No secuencias} \begin{cases} \text{Inmutables} \begin{cases} \text{Conjuntos (\texttt{frozenset})} \end{cases} \\ \\ \text{Mutables} \begin{cases} \text{Conjuntos (\texttt{set})} \\ \text{Diccionarios (\texttt{dict})} \end {cases} \end{cases} \end{cases} \end{cases}

• Ejemplos:

  >>> hash('hola')
  6290906884732116299
  >>> hash('hola')
  6290906884732116299
  >>> hash(5)
  5
  >>> hash((1, 2, 3))
  529344067295497451
  >>> hash([1, 2, 3])
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'list'

• El concepto de hashable es importante en Python ya que existen tipos de datos estructurados que sólo pueden contener elementos hashables.

• Por ejemplo, los elementos de un conjunto y las claves de un diccionario deben ser hashables.

• La mayoría de los datos inmutables predefinidos en Python son hashables, incluyendo los valores de tipo int, float, str, range y bool, así como las funciones y el valor None.

• Las colecciones inmutables (como las tuplas o los frozensets) sólo son hashables si sus elementos también lo son.

• Las colecciones mutables (como las listas o los diccionarios) NO son hashables.

• El hash de un dato depende del estado interno del dato, ya que se calcula a partir de dicho estado interno usando un algoritmo que no nos debe preocupar por ahora.

  Como el estado interno de una colección viene determinado principalmente por los elementos que contiene, el hash de una colección dependerá también del contenido de la colección.

  Y por esta razón, las colecciones mutables no son hashables: si una colección es mutable, su contenido puede cambiar y, por tanto, su hash también cambiaría, pero esto está prohibido.

• El hash de un dato es un número que representa al dato y a todo su contenido.

• En cierto modo, ese número resume el estado del dato en un simple número entero.

• El hash de un dato se utiliza internamente para acceder a ese dato dentro de una colección de forma directa y eficiente.

• Para ello, el intérprete utiliza ciertas técnicas que permiten localizar directamente a un dato dentro de una colección, de forma casi inmediata y sin importar el tamaño de la colección (pero recordemos que para ello es necesario que el hash del dato nunca cambie).

• De no usar estas técnicas, el intérprete tendría que buscar el dato secuencialmente dentro de la colección, recorriéndola desde el principio hasta el final, lo que sería mucho más lento y consumiría un tiempo que sería mayor cuanto más grande fuese la colección.

• Muy en resumen, esas técnicas se basan en dividir el espacio de memoria que ocupa la colección en una serie de almacenes llamados buckets.

• Cada bucket va numerado por un posible valor de hash, de forma que el bucket número n contendrá todos los elementos cuyo hash valga n.

• Por tanto, el algoritmo que usa el intérprete para encontrar un elemento hashable dentro de una colección es:

  1. Calcular el hash del elemento a localizar.

  2. Irse directamente al bucket numerado con ese valor de hash (esta es una operación inmediata, con coste O(1)).

  3. Localizar dentro del bucket el elemento que se está buscando usando el ==, lo cual consumirá un tiempo que, en general, no será mucho, ya que los elementos están repartidos entre todos los buckets y, por tanto, normalmente no habrá muchos elementos en cada bucket.

• Al final, se consigue encontrar al elemento (si está) de forma muy rápida, con un coste que es casi constante, independientemente de la cantidad de elementos que haya en la colección.

No se debe confundir el id de un dato con el hash de un dato:

• Por ejemplo, las listas nos permiten acceder a todos sus elementos de uno en uno y, por tanto, podemos recorrerla.

• Para visitar sus elementos podemos usar la indexación, y para recorrer toda la lista podemos usar un bucle:

  def recorrer_lista(l):
      i = 0
      while i < len(l):
          print(l[i])
          i += 1

• Pero hay que hacerlo bien para asegurarse de que no se visita el mismo elemento dos veces, o se quedan elementos sin visitar, o se intenta acceder a un elemento inexistente a través de un índice que está fuera del rango permitido por la lista.

• La manera general de recorrer un dato iterable es usando un iterador.

  De hecho, técnicamente, un iterable se define como aquel dato al que le podemos asociar, al menos, un iterador.

• Un iterador es un objeto que sabe cómo recorrer un iterable concreto.

• Para ello, el iterador crea un flujo de datos perezoso que va entregando los elementos de ese iterable de uno en uno a medida que se los vamos solicitando.

• Los sucesivos elementos del flujo de datos se van obteniendo al llamar repetidamente a la función next aplicada al iterador.

• Cuando ya no hay más elementos disponibles, la función next lanza una excepción de tipo StopIteration, lo que indica que el iterador se ha agotado (se han consumido todos sus elementos), por lo que si se sigue llamando a la función next se seguirá lanzando esa excepción.

• Se puede obtener un iterador a partir de cualquier dato iterable aplicando la función iter al iterable.

  (Recordemos que todo iterable puede tener asociado un iterador.)

• Ejemplo de uso de iter y next:

  >>> lista = [1, 2, 3]
  >>> it = iter(lista)
  >>> next(it)
  1
  >>> next(it)
  2
  >>> next(it)
  3
  >>> next(it)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  StopIteration

• Si se le pasa un dato no iterable, iter lanza una excepción TypeError:

  >>> it = iter(9)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'int' object is not iterable

• Los iteradores son iterables perezosos de un solo uso:

  • Son perezosos porque van generando sus elementos a medida que los va entregando, en lugar de generarlos todos a la vez primero.

  • Son de un solo uso porque cada elemento sólo se entrega una vez.

• Además, los iteradores son iterables que actúan como sus propios iteradores:

  • Por tanto, cuando llamamos a iter pasándole un iterador, se devuelve el mismo iterador:

    >>> lista = [1, 2, 3, 4]
    >>> it = iter(lista)
    >>> it
    <list_iterator object at 0x7f3c49aa9080>
    >>> it2 = iter(it)
    >>> it2
    <list_iterator object at 0x7f3c49aa9080>
    >>> it is it2
    True

  • En consecuencia, podemos usar un iterador en cualquier sitio donde se espere un iterable.

• Muchas funciones devuelven iteradores en lugar de colecciones porque, al ser perezosos, los iteradores son más eficientes en memoria que si se devolviera toda una lista o tupla.

• El flujo de datos que entrega un iterador se puede convertir en una lista o tupla usando las funciones list y tuple:

  >>> l = [1, 2, 3]
  >>> iterador = iter(l)
  >>> t = tuple(iterador)
  >>> t
  (1, 2, 3)

• Ejemplo:

  for x in ['hola', 23.5, 10, [1, 2]]:
      print(x * 2)

  devuelve:

  'holahola'
  47.0
  20
  [1, 2, 1, 2]

• Por ejemplo:

  • range(2, 7) representa la secuencia de números enteros comprendidos entre 2 y 6, es decir, la secuencia 2, 3, 4, 5, 6.

  • range(2, 7, 2) representa la misma secuencia pero saltándose uno cada vez, es decir, la secuencia 2, 4, 6.

  • range(3) representa la secuencia 0, 1, 2 (se empieza por 0 si no se indica otra cosa).

  • range(4, 0, -1) representa la secuencia 4, 3, 2, 1.

• Como ocurre en toda secuencia, podemos usar indexación para acceder al contenido de un rango, es decir, a cada uno de sus elementos.

• El contenido de un rango r vendrá determinado por la fórmula: r[i] = start + step \cdot i donde i \geq 0. Además:

  • Si step > 0, se impone también la restricción r[i] < \text{\textit{stop}}.

  • Si step < 0, se impone también la restricción r[i] > \text{\textit{stop}}.

• Un rango es vacío cuando r[0] no satisface las restricciones anteriores.

• Los rangos admiten índices negativos, pero se interpretan como si se indexara desde el final de la secuencia usando índices positivos.

• Los rangos son perezosos ya que no hay que reservar espacio en memoria para almacenar todos sus elementos simultáneamente, sino que tan sólo necesita recordar los valores de start, stop y step.

• Esto hace que ocupen mucho menos espacio en memoria que las listas o las tuplas, por ejemplo.

• Los rangos, además, son iterables, por lo que se pueden usar iteradores para recorrer sus elementos.

• En cambio, los rangos NO se consideran colecciones, ya que, estrictamente hablando, no contienen elementos sino que los calcula a partir de una fórmula.

• Para ver con claridad todos los elementos de un rango, podemos convertirlo en una tupla o una lista. Por ejemplo:

  >>> list(range(10))
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> list(range(1, 11))
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  >>> list(range(0, 30, 5))
  [0, 5, 10, 15, 20, 25]
  >>> list(range(0, 10, 3))
  [0, 3, 6, 9]
  >>> list(range(0, -10, -1))
  [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
  >>> list(range(0))
  []
  >>> list(range(1, 0))
  []

• La forma normal de un rango es una expresión en la que se llama a la función range con los argumentos necesarios para construir el rango:

  >>> range(10)
  range(0, 10)
  >>> range(0, 10)
  range(0, 10)
  >>> range(0, 10, 1)
  range(0, 10)

  >>> range(0, 30, 5)
  range(0, 30, 5)
  >>> range(0, -10, -1)
  range(0, -10, -1)
  >>> range(4, -5, -2)
  range(4, -5, -2)

• El rango vacío es un valor que no tiene expresión canónica, ya que cualquiera de las siguientes expresiones representan al rango vacío tan bien como cualquier otra:

  • range(0).

  • range(a,\;a), donde a es cualquier entero.

  • range(a,\;b,\;c), donde a \geq b y c > 0.

  • range(a,\;b,\;c), donde a \leq b y c < 0.

>>> range(3, 3) == range(4, 4)
True
>>> range(4, 3) == range(3, 4, -1)
True

• Los rangos se usan frecuentemente para hacer bucles que se repitan un determinado número de veces.

• Por ejemplo, el cuerpo del siguiente bucle se ejecuta 5 veces:

  for i in range(5):
      print(i)

  y produce la siguiente salida:

  0
  1
  2
  3
  4

• itertools.cycle(⟨iterable⟩) devuelve un iterador que va entregando los elementos del iterable del primero al último, repitiéndolos indefinidamente:

  itertools.cycle([1, 2, 3, 4]) \Rightarrow 1, 2, 3, 4, 1, 2, 3, 4, …

• itertools.repeat(⟨elem⟩[, ⟨n⟩]) entrega ⟨n⟩ veces el elemento ⟨elem⟩, o lo entrega indefinidamente si no se indica ⟨n⟩:

  itertools.repeat('abc') \Rightarrow abc, abc, abc, abc, abc, abc, abc, …

  itertools.repeat('abc', 5) \Rightarrow abc, abc, abc, abc, abc

• Por ejemplo, la siguiente función recibe otra función como argumento y devuelve el resultado de aplicar dicha función al número 5:

  >>> aplica5 = lambda f: f(5)
  >>> cuadrado = lambda x: x ** 2
  >>> cubo = lambda x: x ** 3
  >>> aplica5(cuadrado)
  25
  >>> aplica5(cubo)
  125

• No hace falta crear las funciones cuadrado y cubo para pasárselas a la función aplica5 como argumento. Se pueden pasar directamente las expresiones lambda, que también son funciones:

  >>> aplica5(lambda x: x ** 2)
  25
  >>> aplica5(lambda x: x ** 3)
  125

• Naturalmente, la función que se pasa a aplica5 debe recibir un único argumento de tipo numérico.

• Lo mismo se puede hacer con funciones imperativas, o combinando funciones imperativas con expresiones lambda:

  >>> def aplica5(f):
  ...     return f(5)
  >>> def cuadrado(x):
  ...     return x ** 2
  >>> cubo = lambda x: x ** 3
  >>> aplica5(cuadrado)
  25
  >>> aplica5(cubo)
  125

• También se puede devolver una función como resultado.

• Por ejemplo, la siguiente función suma_o_resta recibe una cadena y devuelve una función que suma si la cadena es 'suma'; en caso contrario, devuelve una función que resta:

  >>> suma_o_resta = lambda s: (lambda x, y: x + y) if s == 'suma' else \
                               (lambda x, y: x - y)
  >>> suma_o_resta('suma')
  <function <lambda>.<locals>.<lambda> at 0x7f526ab4a790>
  >>> suma = suma_o_resta('suma')
  >>> suma(2, 3)
  5
  >>> resta = suma_o_resta('resta')
  >>> resta(4, 3)
  1
  >>> suma_o_resta('suma')(6, 4)
  10

• Tanto aplica5 como suma_o_resta son funciones de orden superior.

• Y con funciones imperativas:

  >>> def suma_o_resta(s):
  ...    def sumar(x, y):
  ...        return x + y
  ...    def restar(x, y):
  ...        return x - y
  ...    if s == 'suma':
  ...        return sumar
  ...    else:
  ...        return restar
  >>> suma_o_resta('suma')
  <function <lambda>.<locals>.sumar at 0x7f3ab30de200>
  >>> suma = suma_o_resta('suma')
  >>> suma(2, 3)
  5
  >>> resta = suma_o_resta('resta')
  >>> resta(4, 3)
  1
  >>> suma_o_resta('suma')(6, 4)
  10

• Una función es una abstracción porque agrupa lo que tienen en común determinados casos particulares que siguen el mismo patrón.

• El mismo concepto se puede aplicar a casos particulares de funciones, y al hacerlo damos un paso más en nuestro camino hacia un mayor grado de abstracción.

• Es decir: muchas veces observamos el mismo patrón en funciones diferentes.

• Para poder abstraer, de nuevo, lo que tienen en común dichas funciones, deberíamos ser capaces de manejar funciones que acepten a otras funciones como argumentos o que devuelvan otra función como resultado (es decir, funciones de orden superior).

• Supongamos las dos funciones siguientes:

  def suma_enteros(a, b):
      """Suma los enteros comprendidos entre a y b."""
      suma = 0
      for i in range(a, b + 1):
          suma += i
      return suma
  
  def suma_enteros(a, b):
      """Suma los cubos de los enteros comprendidos entre a y b."""
      suma = 0
      for i in range(a, b + 1):
          suma += cubo(i)
      return suma

• Estas dos funciones comparten claramente un patrón común. Se diferencian solamente en:

  • El nombre de la función.

  • La función que se aplica a a para calcular cada término de la suma.

• Podríamos haber escrito las funciones anteriores rellenando los «casilleros» ⟨nombre⟩ y ⟨término⟩ del siguiente patrón general:

  def ⟨nombre⟩(a, b):
       suma = 0
       for i in range(a, b + 1):
             suma +=  ⟨término⟩(i)
       return suma

• La existencia de este patrón común nos demuestra que hay una abstracción esperando que la saquemos a la superficie.

• De hecho, los matemáticos han identificado hace mucho tiempo esta abstracción llamándola sumatorio de una serie, y la expresan así: \sum _ {n=a}^b f(n)

  La ventaja que tiene usar la notación anterior es que podemos trabajar directamente con el concepto de sumatorio en vez de trabajar con sumas concretas, y podemos sacar conclusiones generales sobre los sumatorios independientemente de la serie particular con la que estemos trabajando.

• Igualmente, como programadores estamos interesados en que nuestro lenguaje tenga la suficiente potencia como para describir directamente el concepto de sumatorio, en vez de funciones particulares que calculen sumas concretas.

• En programación lo conseguimos creando funciones que conviertan los «casilleros» en parámetros que recibirían funciones:

  def suma(term, a, b):
      suma = 0
      for i in range(a, b + 1):
          suma += term(i)
      return suma

• De esta forma, las dos funciones suma_enteros y suma_cubos anteriores se podrían definir en términos de esta suma:

  def suma_enteros(a, b):
      return suma(lambda x: x, a, b)
  def suma_cubos(a, b):
      return suma(lambda x: x * x * x, a, b)  # o suma(cubo, a, b)

• suma es una abstracción que captura el patrón común que comparten suma_enteros y suma_cubos, las cuales también son abstracciones que capturan sus respectivos patrones comunes.

• Una forma de hacerlo sería:

  def elevar_cubo(l):
      res = []
      for e in l:
          res.append(e ** 3)
      return res

• ¿Y elevar a la cuarta potencia?

  def elevar_cuarta(l):
      res = []
      for e in l:
          res.append(e ** 4)
      return res

• Es evidente que hay un patrón subyacente que se podría abstraer creando una función de orden superior que aplique una función f a los elementos de una lista y devuelva la lista resultante.

• Esa función se llama map, y viene definida en Python con la siguiente signatura:

  \texttt{map(\(func\),\;\(iterable\))\;->\;Iterator}

  donde:

  • func debe ser una función de un sol parámetro.

  • iterable puede ser cualquier iterable.

• Podemos usarla así:

  >>> map(cubo, (1, 2, 3, 4))
  <map object at 0x7f22b25e9d68>

• Lo que devuelve es un iterador que luego podemos recorrer o, por ejemplo, convertir en una lista usando la función list:

  >>> list(map(cubo, (1, 2, 3, 4)))
  [1, 8, 27, 64]

• Podemos usar cualquier iterable como argumento para map, como por ejemplo un rango:

  >>> for e in map(cubo, range(1, 5)):
  ...     print(e, end=' ')
  1 8 27 64

• ¿Cómo definirías la función map de forma que devolviera una lista?

• Podríamos definirla así:

  def map(f, l):
      res = []
      for e in l:
          res.append(f(e))
      return res

• Si abstraemos ese patrón común, podemos crear una función de orden superior que capture la idea de reducir todos los elementos de un iterable a un único valor.

• Eso es lo que hace la función reduce.

• Su signatura es:

  \texttt{reduce(\(function\),\;\(sequence\)\;\([\),\;\(initial\)\(]\))\;->\;Any}

  donde:

  • function debe ser una función de dos parámetros.

  • sequence debe ser cualquier objeto iterable (normalmente, una secuencia como una cadena, una tupla o un rango).

  • initial, si se indica, se usará como primer elemento sobre el que realizar el cálculo y servirá como valor por defecto cuando la secuencia esté vacía (si no se indica y la secuencia está vacía, generará un error).

• Para usarla, primero tenemos que importarla del módulo functools:

  from functools import reduce

• No es la primera vez que importamos un módulo. Ya lo hicimos con el módulo math.

• En su momento estudiaremos con detalle qué son los módulos. Por ahora nos basta con lo que ya sabemos: que contienen definiciones que podemos incorporar a nuestros scripts.

• Por ejemplo, para calcular la suma y el producto de (1, 2, 3, 4), podemos definir las funciones suma_de_numeros y producto_de_numeros a partir de reduce:

  from functools import reduce
  
  tupla = (1, 2, 3, 4)
  
  def suma_de_numeros(tupla):
      return reduce(lambda x, y: x + y, tupla, 0)
  
  def producto_de_numeros(tupla):
      return reduce(lambda x, y: x * y, tupla, 1)

• También podemos importar y usar las funciones add y mul del módulo operator, las cuales actúan, respectivamente, como el operador + y *:

  from functools import reduce
  from operator import add, mul
  
  tupla = (1, 2, 3, 4)
  
  def suma_de_numeros(tupla):
      return reduce(add, tupla, 0)
  
  def producto_de_numeros(tupla):
      return reduce(mul, tupla, 1)

  De esta forma, usamos add y mul en lugar de las expresiones lambda (lambda x, y: x + y) y (lambda x, y: x * y), respectivamente.

• En general, si iterable representa un objeto iterable que contiene los elementos e_1, e_2, \ldots, e_n (en este orden), entonces tenemos que: \texttt{reduce(\(f\),\;\(iterable\),\;\(ini\))} = f(\ldots{}f(f(f(ini, e_1), e_2), e_3), \ldots, e_n)

• Por ejemplo, la siguiente llamada a reduce:

  reduce(add, (1, 2, 3, 4), 0)

  realiza y devuelve el resultado del siguiente cálculo:

  add(add(add(add(0, 1), 2), 3), 4)

  lo que, en la práctica, equivale a:

  ((((0 + 1) + 2) + 3) + 4)

• Si iterable representa un iterable vacío, entonces:

  \texttt{reduce(\(f\),\;\(iterable\),\;\(ini\))} = ini

• Por ejemplo:

  reduce(add, (), 0)

  devuelve directamente 0.

• Si no se indica un valor inicial, tenemos que: \texttt{reduce(\(f\),\;\((e_1, e_2, \ldots, e_n)\))} = f(\ldots{}f(f(e_1, e_2), e_3), \ldots, e_n)

  Es decir: el valor inicial será el primer elemento del iterable.

• Por ejemplo, la siguiente llamada a reduce:

  reduce(add, (1, 2, 3, 4))

  realiza y devuelve el resultado del siguiente cálculo:

  add(add(add(1, 2), 3), 4)

  lo que, en la práctica, equivale a:

  (((1 + 2) + 3) + 4)

• Pero si el iterable es vacío, dará un error:

  >>> reduce(add, ())
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: reduce() of empty iterable with no initial value

• Con lo que acabamos de ver, se demuestra que la implementación de la función reduce en Python va reduciendo de izquierda a derecha y que, por tanto, las operaciones se hacen agrupándose por la izquierda.

• Esto es algo que debemos tener muy en cuenta a la hora de diseñar la función que se le pasa a reduce.

• Se denomina iteración a cada paso que da la función reduce, es decir, cada vez que reduce visita un nuevo elemento del iterable (la tupla, cadena o lo que sea) y aplica la función para calcular el resultado parcial.

• Esa función, como ya dijimos antes, debe tener dos parámetros, pero de forma que, en cada iteración:

  1. Su primer parámetro va a contener siempre el valor parcial acumulado hasta ahora (por tanto, es un acumulador).

  2. Su segundo parámetro va a contener el valor del elemento que en este momento está visitando reduce.

• Por tanto, es frecuente que el primer parámetro de esa función se llame acc o algo similar, para expresar el hecho de que ahí se va recibiendo el valor acumulado hasta el momento.

• Por ejemplo, en la siguiente llamada:

  reduce(lambda acc, e: acc + e, (1, 2, 3, 4), 0)

  • acc va a contener la suma parcial acumulada hasta ahora.

  • e va a contener el elemento que en este momento se está visitando.

  Así, durante la ejecución del reduce, ésta provocará las siguientes llamadas a la expresión lambda:

  (lambda acc, e: acc + e)(0, 1)   # acc = 0, e = 1
  (lambda acc, e: acc + e)(1, 2)   # acc = 1, e = 2
  (lambda acc, e: acc + e)(3, 3)   # acc = 3, e = 3
  (lambda acc, e: acc + e)(6, 4)   # acc = 6, e = 4

• ¿Cómo podríamos definir la función reduce si recibiera una tupla y no cualquier iterable?

• Una forma (con valor inicial obligatorio) podría ser así:

  def reduce(fun, tupla, ini):
      if len(tupla) == 0:
          return ini
      return reduce(fun, tupla[1:], fun(ini, tupla[0]))

• O bien, de forma iterativa y no recursiva:

  def reduce(fun, tupla, ini):
      res = ini
      for e in tupla:
          res = fun(res, e)
      return res

• Por ejemplo:

  >>> tuple(x ** 3 for x in (1, 2, 3, 4))
  (1, 8, 27, 64)
  # equivale a:
  >>> tuple(map(lambda x: x ** 3, (1, 2, 3, 4)))
  (1, 8, 27, 64)

  >>> tuple(x for x in (-4, 3, 5, -2, 8, -3, 9) if x > 0)
  (3, 5, 8, 9)
  # equivale a:
  >>> tuple(filter(lambda x: x > 0, (-4, 3, 5, -2, 8, -3, 9)))
  (3, 5, 8, 9)

• Su sintaxis es:

  ⟨expr_gen⟩ ::= (⟨expresión⟩ (for ⟨identificador⟩ in ⟨iterador⟩ [if ⟨condición⟩])^+)

• Los elementos de la salida generada serán los sucesivos valores de ⟨expresión⟩.

• Las cláusulas if son opcionales. Si están, la ⟨expresión⟩ sólo se evaluará y añadirá al resultado cuando se cumpla la ⟨condición⟩.

• Los paréntesis ( y ) alrededor de la expresión generadora se pueden quitar si la expresión se usa como único argumento de una función.

• Por ejemplo:

  >>> sec1 = 'abc'
  >>> sec2 = (1, 2, 3)
  >>> tuple((x, y) for x in sec1 for y in sec2)
  (('a', 1), ('a', 2), ('a', 3),
   ('b', 1), ('b', 2), ('b', 3),
   ('c', 1), ('c', 2), ('c', 3))

• Las expresiones generadoras, al igual que las expresiones lambda, determinan su propio ámbito.

• Ese ámbito abarca toda la expresión generadora, de principio a fin.

• Los identificadores que aparecen en la cláusula for se se van ligando automáticamente, uno a uno, a cada elemento del iterable indicada en la cláusula in.

• Al recorrer el iterable, las variables van almacenando en cada iteración del bucle el valor del elemento que en ese momento se está visitando.

• Debido a ello, podemos afirmar que las variables que aparecen en en cada cláusula for de la expresión generadora son identificadores cuantificados, ya que toman sus valores automáticamente y éstos están restringido a los valores que devuelva el iterable.

• Además, estos identificadores cuantificados son locales a la expresión generadora, y sólo existen dentro de ella.

• Por tanto, esos identificadores cumplen estas dos propiedades:

  • Se pueden renombrar (siempre de forma consistente) sin que la expresión cambie su significado.

    Por ejemplo, las dos expresiones generadoras siguientes son equivalentes, puesto que producen el mismo resultado:

    (x for x in (1, 2, 3))

    (y for y in (1, 2, 3))

  • No se pueden usar fuera de la expresión generadora, ya que estarían fuera de su ámbito y no serían visibles.

    Por ejemplo, lo siguiente daría un error de nombre:

    >>> e = (x for x in (1, 2, 3))
    >>> x       # Intento acceder a la 'x' de la expresión generadora
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'x' is not defined

• Para que esta solución funcione de manera eficiente, es importante que una etapa no genere más cantidad de datos de los que va a necesitar la etapa siguiente, sino que genere exactamente los datos necesarios.

• Para ello, cuando una etapa necesite generar un nuevo dato de salida, le pedirá un nuevo dato de entrada a la etapa anterior, y ésta a la anterior, y así sucesivamente.

• Eso significa que entre etapas se deben intercambiar datos perezosos (es decir, flujos), de manera que los datos intercambiados sean justamente los que cada etapa necesita.

• Si el flujo de datos intercambiado no fuera perezoso, se crearían en memoria muchísimos datos intermedios innecesarios de conservar.

• La idea clave es pensar que las cuatro etapas funcionan a la vez, y NO pensar que una etapa empieza y termina antes de empezar la siguiente.

• Este esquema se puede implementar mediante la composición de funciones ya conocidas, de la siguiente forma:

• Por ejemplo, supongamos el siguiente problema:

  «Dada una lista con los n primeros números naturales, obtener la suma de los cuadrados de los números impares que haya en la lista.»

• Este problema se podría resolver de la siguiente forma:

• Lo que se traduce en la siguiente composición de funciones:

  def suma_cuadrados_impares(n):
      return sum(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, range(n + 1))))

• Por ejemplo, la función que devuelve el máximo elemento de una lista donde todos sus elementos son del mismo tipo, se puede anotar de la siguiente forma:

  def maximo[T](l: list[T]) -> T:
      ...

  y podríamos llamarla pasándole cualquier tipo de lista, siempre que todos los elementos de la lista sean del mismo tipo:

  >>> maximo([1, 2, 3, 4])
  4
  >>> maximo(['a', 'b', 'c', 'd'])
  'd'

• Según la signatura de la función, no sería correcto pasarle una lista con elementos de diferentes tipos, pero el intérprete no detectaría el error ya que no hace comprobación de tipos. De todas formas, la función probablemente no funcionaría bien en ese caso, ya que es una violación de su especificación:

  >>> maximo([1, 'a', True, 2.5])  # Incorrecto si se comprueban los tipos
  ???                              # No se sabe cómo se comportará la función en este caso

• Una función genérica puede tener más de un parámetro de tipo en caso necesario.

• Por ejemplo:

  def crear_tupla[T, U](elem1: T, elem2: U) -> tuple[T, U]:
      """Crea una tupla con dos elementos."""
      return (elem1, elem2)

• Un ejemplo de uso:

  >>> crear_tupla(1, 'a')
  (1, 'a')

  Aquí, mandamos a la función un elemento de tipo int y otro de tipo str, y la función produce como resultado una tupla de tipo tuple[int, str].