Módulo Toolz en Python

El paquete Toolz proporciona un conjunto de funciones de utilidad para iteradores, funciones y diccionarios. Estas funciones amplían las bibliotecas estándar itertools y functools y toman mucho de las bibliotecas estándar de los lenguajes funcionales contemporáneos. Este paquete consta de los siguientes módulos:

• dicttoolz
• functoolz
• itertoolz
• recetas
• salvadera

dicttoolz

Funciones –

• assoc(d, clave, valor[, fábrica]) – Devuelve un nuevo dict con un nuevo par de valores clave. No modifica el diccionario inicial.

  import toolz       d = toolz.dicttoolz.assoc({'Geeks':0}, 'forGeeks', 1) print(d)

  Producción –

  {'Geeks': 0, 'forGeeks': 1}
  

• assoc_in (d, claves, valor [, fábrica]): devuelve un nuevo dict con un nuevo par de valores clave potencialmente anidados

  import toolz    d = toolz.dicttoolz.assoc_in({'Geeks':0}, 'forGeeks', 1) print(d)

  Producción –

  {‘Geeks’: 0, ‘f’: {‘o’: {‘r’: {‘G’: {‘e’: {‘e’: {‘k’: {‘s’: 1}}} }}}}}

• dissoc(d, *keys) – Devuelve un nuevo dict con la(s) clave(s) dada(s) eliminada(s). No modifica el diccionario inicial.

  import toolz    d = toolz.dicttoolz.dissoc({'g':0, 'e':1,                              'k':2, 's':3},                             'k', 'e') print(d)

  Producción –

  {'g': 0, 's': 3}
  

• get_in(keys, ds[, default, no_default]) – Devuelve ds[I0][I1]…[IX] donde [I0, I1, …, IX] son ​​claves y ds es un diccionario anidado. Si no se puede encontrar ds[I0][I1]…[IX], devuelve «predeterminado».

  import toolz       nested_dict ={'d1':{'k1':'v1', 'k2':'v2'},                'd2':{'k3':{'d2A':{'k4':'v4'}}}}    d = toolz.dicttoolz.get_in(['d1'], nested_dict) print(d)    d = toolz.dicttoolz.get_in(['d2', 'k3', 'd2A'],                             nested_dict) print(d)

  Producción –

  {'k1': 'v1', 'k2': 'v2'}
  {'k4': 'v4'}
  

• itemfilter(predicate, d[, factory]) – Filtra elementos en el diccionario por elemento.

  import toolz       def func(item):            key, val = item            return key == ord(val)-65    d = {0:'A', 1:'B', 3:'C', 5:'F'} print(toolz.dicttoolz.itemfilter(func, d))

  Producción –

  {0: 'A', 1: 'B', 5: 'F'}
  

• itemmap(func, d[, factory]) – Aplica la función a los elementos del diccionario.

  import toolz       d = {0:'A', 1:'B', 3:'C', 5:'F'} print(toolz.dicttoolz.itemmap(reversed, d))

  Producción –

  {'A': 0, 'B': 1, 'C': 3, 'F': 5}
  

• keyfilter(predicate, d[, factory]) – Filtra elementos en el diccionario por clave.

  import toolz       def func(key):     return 5<= len(key)<7    d = {'python': 0, 'julia': 1, 'java': 3, 'javascript': 5} print(toolz.dicttoolz.keyfilter(func, d))

  Producción –

  {'python': 0, 'julia': 1}
  

• keymap(func, d[, factory] – Aplica la función a las teclas del diccionario.

  import toolz       def func(key):     return ''.join(reversed(key))    d = {'python': 0, 'julia': 1, 'java': 3, 'javascript': 5} print(toolz.dicttoolz.keymap(func, d))

  Producción –

  {'nohtyp': 0, 'ailuj': 1, 'avaj': 3, 'tpircsavaj': 5}
  

• merge(*dicts, **kwargs) – Fusiona una colección de diccionarios.

  import toolz       dict1 = {1:1, 2:4} dict2 = {3:9, 2:8, 4:16} print(toolz.dicttoolz.merge(dict1, dict2))

  Producción –

  {1: 1, 2: 8, 3: 9, 4: 16}
  

• merge_with(func, *dicts, **kwargs): fusiona diccionarios y aplica funciones a valores combinados.

  import toolz       dict1 = {1:1, 2:4} dict2 = {3:9, 2:8, 1:1} print(toolz.dicttoolz.merge_with(sum, dict1, dict2))

  Producción –

  {1: 2, 2: 12, 3: 9}
  

• update_in(d, keys, func[, default, factory]) – Actualiza el valor en un diccionario anidado. Si claves = [k0, .., kX] y d[k0, …, kX] = valor, update_in devuelve una copia del diccionario original con ‘valor’ reemplazado por func(valor).

  import toolz       def func(value):     return value//2    nested_dict = {1:{11:111}, 2:{22:222}} print(toolz.dicttoolz.update_in(nested_dict,         [1, 11], func))

  Producción –

  {1: {11: 55}, 2: {22: 222}}
  

• valfilter(predicate, d[, factory]) – Filtra elementos en el diccionario por valor.

  import toolz       def func(value):     return 4<len(value)<7    d = {0: 'python', 1: 'julia', 3: 'java', 5: 'javascript'} print(toolz.dicttoolz.valfilter(func, d))

  Producción –

  {0: 'python', 1: 'julia'}
  

• valmap(func, d[, factory]) – Aplicar la función a los valores del diccionario.

  import toolz       def func(value):     return ''.join(reversed(value))    d = {0: 'python', 1: 'julia', 3: 'java', 5: 'javascript'} print(toolz.dicttoolz.valmap(func, d))

  Producción –

  {0: 'nohtyp', 1: 'ailuj', 3: 'avaj', 5: 'tpircsavaj'}
  

functoolz

Funciones –

• apply(*func_and_args, **kwargs): simplemente aplica una función y devuelve el resultado.

  import toolz       def double(n):     return n + n    print(toolz.functoolz.apply(double, 2))

  Producción –

  4
  

• complement(func): como sugiere su nombre, convierte y devuelve el complemento lógico de la entrada proporcionada.

  import toolz       def is_mulitple_of_5(n):     return n % 5 == 0    not_multiple_of_5 = toolz.functoolz.complement(is_mulitple_of_5)    print(is_mulitple_of_5(10)) print(not_multiple_of_5(10))

  Producción –

  True
  False
  

• compose(*funcs) – Devuelve una función que aplica otras funciones en secuencia. Las funciones se aplican de derecha a izquierda. Si no se proporcionan argumentos, se devuelve la función de identidad (f(x) = x).

  import toolz       def func(n):     return n + n    def square(n):     return n * n    x = toolz.functoolz.compose(func, square)(3) print(x)

  Producción –

  18
  

• compose_left(*funcs) – Devuelve una función que aplica otras funciones en secuencia. Las funciones se aplican de izquierda a derecha. Si no se proporcionan argumentos, se devuelve la función de identidad (f(x) = x).

  import toolz       def func(n):     return n + n    def square(n):     return n * n    x = toolz.functoolz.compose_left(func, square)(3) print(x)

  Producción –

  36
  

• flip: llama a la función con los argumentos en orden inverso.

  import toolz       def mod(a, b):     return a % b    print('7 % 3 :', toolz.functoolz.flip(mod, 3, 7))

  Producción –

  7 % 3 : 1
  

• identidad (x): función de identidad, simplemente devuelve x.

  import toolz       print(toolz.functoolz.identity(6))

  Producción –

  6
  

• pipe(data, *funcs) – Canaliza un valor a través de una secuencia de funciones. Es equivalente a compose_left(*funcs)

  import toolz       print(toolz.functoolz.pipe(3, double, square))

  Producción –

  36
  

• thread_first(val, *forms) – Sube el valor a través de una secuencia de funciones/formularios.

  import toolz       def mod(a, b):     return a % b    def double(n):     return n + n    print(toolz.functoolz.thread_first(3, (mod, 2), double))

  Producción –

  2
  

• thread_last(val, *forms) – Sube el valor a través de una secuencia de funciones/formularios.

  import toolz       def mod(a, b):     return a % b    def double(n):     return n + n    print(toolz.functoolz.thread_last(3, (mod, 2), double))

  Producción –

  4
  

itertoolz

Funciones –

• acumular (binop, seq [, inicial]): esto es similar a la función ‘reducir’. Aplica repetidamente una función a una secuencia acumulando resultados.

  import toolz from operator import add    print(list(toolz.itertoolz.accumulate(add, [1, 2, 3, 4])))

  Producción –

  [1, 3, 6, 10]
  

• concat(seqs) – Concatena dos o más iterables.

  import toolz    print(list(toolz.itertoolz.concat([[1],                                    ['a'],                                    [2, 3, 4]])))

  Producción –

  [1, 'a', 2, 3, 4]
  

• cons(item, seq) – Agrega ‘item’ al comienzo de la secuencia. Es equivalente a insertar (0, artículo).

  import toolz       print(list(toolz.itertoolz.cons(1, ['a', 'b'])))

  Producción –

  [1, 'a', 'b']
  

• diff(*seqs, **kwargs): compara los elementos en cada índice en ambos iterables y devuelve la lista de pares diferentes.

  import toolz       print(list(toolz.itertoolz.diff([1, 2, 3], [2, 2, 4])))

  Producción –

  [(1, 2), (3, 4)]
  

• drop(n, seq) – Elimina los primeros n elementos de la secuencia y devuelve la nueva secuencia.

  import toolz    print(list(toolz.itertoolz.drop(3, [2, 3, 2, 6, 4, 7])))

  Producción –

  [6, 4, 7]
  

• frecuencias (seq) – Devuelve un diccionario con elementos y su cuenta en secuencia. Es equivalente a colecciones.Contador.

  import toolz    print(toolz.itertoolz.frequencies(['c',                                    'b',                                    'c',                                     'b',                                     'd',                                     'e',                                     'h',                                     'h',                                    'b']))

  Producción –

  {'c': 2, 'b': 3, 'd': 1, 'e': 1, 'h': 2}
  

• groupby(func, seq) – Devuelve un diccionario después de agrupar los elementos de secuencia según func.

  import toolz    print(toolz.itertoolz.groupby(len,                                ['geeks', 'for', 'geeks']))

  Producción –

  {5: ['geeks', 'geeks'], 3: ['for']}
  

• isdistinct(seq) – Devuelve True si todos los elementos en la secuencia son distintos, de lo contrario False.

  import toolz    print(toolz.itertoolz.isdistinct('geeks'))

  Producción –

  False
  

• isiterable(x) – Devuelve True si x es iterable, de lo contrario False.

print(toolz.itertoolz.isiterable([10]))

Output - True

[10, 5, 20, 8, 11]

[20, 11]

[10, 20, 5, 8]

[4, 5, 10, 12, 20, 24]

[10, 20, 40, 8, 24, 48]

[5, 21]