Esquemes

Sintetitzar, aplicar i filtrar

Sintetitzar

  • sum(), min(), max(), str.join(), functools.reduce()…

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

    import functools

def producte_1(iterable):
    def prod(p, e):
        return p*e
    it = functools.reduce(prod, iterable, 1)
    return it

    >>> 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.

    import functools

def producte_2(iterable):
    it = functools.reduce(lambda p, e: p*e, iterable, 1)
    return it

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

  • Calcula el producte dels elements d’un iterador. Usa la funció mul() del mòdul operator pel tractament.

    import functools
import operator

def producte_3(iterable):
    it = functools.reduce(operator.mul, iterable, 1)
    return it

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

Aplicar

  • map(), enumerate().

  • Calcula el valor absolut dels elements d’un iterable.

    def abs_iter(iterable):
    it = map(abs, iterable)
    return it

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

Filtrar

  • filter().

  • Filtra els nombres negatius d’un iterable. Defineix una funció auxiliar pel tractament.

    def negatius_1(iterable):
    def es_negatiu(x):
        return x < 0
    it = filter(es_negatiu, iterable)
    return it

    >>> 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.

    def negatius_2(iterable):
    it = filter(lambda x: x < 0, iterable)
    return it

    >>> 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: pf.py, pf.txt.

Llesques i concatenació

Llesques

  • itertools.islice().

  • Obté les unitats d’un nombre natural.

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

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

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

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

Concatenació

Recorregut simultani

  • zip(), 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

  • itertools.tee().

    import itertools

def diferencies(iterable):
    it1, it2 = itertools.tee(iterable)
    next(it2)
    itd = map((lambda x, y: x - y), it1, it2)
    return itd

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

Cerques

  • Tots els elements compleixen una condició: combinant map() amb all()

    def tots_positius(iterable):
    positius = map(lambda e: e > 0, iterable)
    tots = all(positius)
    return tots

    >>> 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 map() amb any().

  • Troba el primer element que compleix una condició: combinant filter() amb itertools.slice().

Longitud

  • Longitud d’un iterador.

Combinatòria