Esquemes
========

.. contents::
   :local:
   :backlinks: none


Sintetitzar, aplicar i filtrar
------------------------------

Sintetitzar
~~~~~~~~~~~

- :py:func:`sum`, :py:func:`min`, :py:func:`max`,
  :py:meth:`str.join`, :py:func:`functools.reduce`...

- Calcula el producte dels elements d'un iterador. Defineix una funció
  auxiliar pel tractament.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # producte_1
     :end-before: # fi producte_1

  ..
     >>> from esquemes import producte_1

  >>> l = [-3, 5, -8, 4, -1, -12]
  >>> p1 = producte_1(l)
  >>> p1
  5760

- Calcula el producte dels elements d'un iterador. Usa una expressió
  lambda pel tractament.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # producte_2
     :end-before: # fi producte_2

  ..
     >>> from esquemes import producte_2

  >>> l = [-3, 5, -8, 4, -1, -12]
  >>> p1 = producte_2(l)
  >>> p1
  5760

- Calcula el producte dels elements d'un iterador. Usa la funció
  :func:`~operator.mul` del mòdul :mod:`operator` pel tractament.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # producte_3
     :end-before: # fi producte_3

  ..
     >>> from esquemes import producte_3

  >>> l = [-3, 5, -8, 4, -1, -12]
  >>> p1 = producte_3(l)
  >>> p1
  5760


Aplicar
~~~~~~~

- :py:func:`map`, :py:func:`enumerate`.

- Calcula el valor absolut dels elements d'un iterable.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # abs_iter
     :end-before: # fi abs_iter

  ..
     >>> from esquemes import abs_iter

  >>> l = [-3, 5, -8, 4, -1, -12]
  >>> it1 = abs_iter(l)
  >>> list(it1)
  [3, 5, 8, 4, 1, 12]


Filtrar
~~~~~~~

- :py:func:`filter`.

- Filtra els nombres negatius d'un iterable. Defineix una funció
  auxiliar pel tractament.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # negatius_1
     :end-before: # fi negatius_1

  ..
     >>> from esquemes import negatius_1

  >>> l = [-3, 5, -8, 4, -1, -12]
  >>> it1 = negatius_1(l)
  >>> list(it1)
  [-3, -8, -1, -12]

- Filtra els nombres negatius d'un iterable. Usa una expressió lambda
  pel tractament.

  ..
     >>> from esquemes import negatius_2

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # negatius_2
     :end-before: # fi negatius_2

  >>> it2 = negatius_2(l)
  >>> list(it2)
  [-3, -8, -1, -12]

Observeu que sintetitzar, aplicar i filtrar són esquemes que també es
poden usar en llistes: :download:`pf.py`, :download:`pf.txt`.


Llesques i concatenació
-----------------------

Llesques
~~~~~~~~

- :py:func:`itertools.islice`.

- Obté les unitats d'un nombre natural.

  ..
     >>> import sys
     >>> sys.path.append('..')

  .. code-block:: pycon

     >>> import itertools
     >>> from digits import digits

     >>> it = itertools.islice(digits(3674), 1)
     >>> list(it)
     [4]

- Obté els dígits a partir de les desenes.

  .. code-block:: pycon

     >>> it = itertools.islice(digits(3674), 1, None)
     >>> list(it)
     [7, 6, 3]


Concatenació
~~~~~~~~~~~~

- :py:func:`itertools.chain`,
  :py:meth:`itertools.chain.from_iterable`.

- Concatena els dígits de dos nombres naturals.

  >>> it1 = digits(732)
  >>> it2 = digits(9486)
  >>> it = itertools.chain(it1, it2)
  >>> list(it)
  [2, 3, 7, 6, 8, 4, 9]


Recorregut simultani
--------------------

- :py:func:`zip`, :py:func:`itertools.zip_longest`.

- Recorre en paral·lel els dígits de dos nombres.

  >>> it1 = digits(732)
  >>> it2 = digits(9486)
  >>> it = zip(it1, it2)
  >>> list(it)
  [(2, 6), (3, 8), (7, 4)]


Còpia d'iteradors
-----------------

- :py:func:`itertools.tee`.

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # diferencies
     :end-before: # fi diferencies

  ..
     from esquemes import diferencies

  >>> l = [1, 5, -3, 6, 2]
  >>> d = diferencies(l)
  >>> list(d)
  [-4, 8, -9, 4]


Cerques
-------

- Tots els elements compleixen una condició: combinant :py:func:`map`
  amb :py:func:`all`

  .. literalinclude:: esquemes.py
     :language: python3
     :start-after: # tots_positius
     :end-before: # fi tots_positius

  ..
     from esquemes import tots_positius

  >>> l = [1, 2, 3]
  >>> t = tots_positius(l)
  >>> t
  True
  >>> l = [1, 2, -5]
  >>> t = tots_positius(l)
  >>> t
  False

- Algun element compleix una condició: combinant :py:func:`map` amb
  :py:func:`any`.

- Troba el primer element que compleix una condició: combinant
  :py:func:`filter` amb :py:func:`itertools.slice`.


Longitud
--------

- Longitud d'un iterador.


Combinatòria
------------

- :py:func:`itertools.product`,
  :py:func:`itertools.permutations`, :py:func:`itertools.combinations`,
  :py:func:`itertools.combinations_with_replacement`.