J'ai essayé d'utiliser toolz, qui est une extension des bibliothèques standard itertools et `` `functools```.

Installation

Vous pouvez l'installer avec pip.

$ pip install toolz

Il existe également une version Cython qui fonctionne plus rapidement.

$ pip install cytoolz

Comment utiliser

toolzLes fonctions fournies par sont à peu près divisées en trois. cette maisonitertoolz 、functoolzSont chacunitertools 、functoolsFournit des fonctionnalités équivalentes à l'extension de.

Itertoolz
Functoolz
Dicttoolz

`toolz fournit également des fonctions standard telles que mapper, réduire et filtrer. Si vous les importez et qu'il s'agit d'une carte, itertools.Il sera remplacé par une fonction qui peut gérer Iterable comme imap. L'utilisation de ces fonctions est presque la même que celle d'origine, je vais donc l'omettre.`



 Ci-dessous, nous présenterons des fonctions susceptibles d'être utilisées fréquemment.

 Itertoolz


#### **`Il fournit les fonctionnalités équivalentes d'itertools.[recette itertools](http://docs.python.jp/2.7/library/itertools.html#itertools-recipes)Il existe également des fonctions comme celles répertoriées dans.`**

Obtenez élément-get, pluck

get

getEst une fonction qui récupère des éléments d'une séquence ou d'un dictionnaire.

Vous pouvez obtenir l'élément de la séquence en spécifiant l'index.

>>> from toolz import get
>>> get(1, range(5))
1

Vous pouvez également passer la clé pour obtenir la valeur du dictionnaire.

>>> get('a', {'a': 'A', 'b': 'B', 'c': 'C'})
'A'

Il est possible de spécifier une valeur par défaut lorsque out-of-index est spécifié ou que la clé n'existe pas.

>>> get(10, range(5), 0)
0
>>> get('d', {'a': 'A', 'b': 'B', 'c': 'C'}, 'None')
'None'

Vous pouvez obtenir plusieurs valeurs en passant un index ou une clé dans une liste.

>>> get([1, 3, 5], range(5), 0)
(1, 3, 0)
>>> get(['b', 'd', 'a'], {'a': 'A', 'b': 'B', 'c': 'C'}, 'None')
('B', 'None', 'A')

pluck

pluckEstgetÀmapRenvoie le résultat équivalent à.

>>> from toolz import pluck
>>> mat = [[(i, j) for i in range(5)] for j in range(5)]
>>> for r in mat:
...     print r
... 
[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)]
[(0, 1), (1, 1), (2, 1), (3, 1), (4, 1)]
[(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)]
[(0, 3), (1, 3), (2, 3), (3, 3), (4, 3)]
[(0, 4), (1, 4), (2, 4), (3, 4), (4, 4)]
>>> for r in pluck([2, 4], mat):
...     print r
... 
((2, 0), (4, 0))
((2, 1), (4, 1))
((2, 2), (4, 2))
((2, 3), (4, 3))
((2, 4), (4, 4))

Calcul cumulatif - accumuler

accumulateEstreduceSimilaire à, mais renvoie un itérateur qui renvoie cumulatif. Depuis Python 3.2, il est implémenté dans itertools.

>>> from toolz import accumulate
>>> from operator import add
>>> list(accumulate(add, range(5)))
[0, 1, 3, 6, 10]
>>> xs = [randint(1, 10) for n in range(10)]
>>> xs
[7, 3, 4, 2, 9, 4, 1, 10, 8, 1]
>>> list(accumulate(max, xs))
[7, 7, 7, 7, 9, 9, 9, 10, 10, 10]

Regroupement: grouper, compter, réduire

groupbyRegroupe les éléments de la séquence par la valeur de la fonction clé. countbyCompte le nombre d'éléments dans chaque groupe. reducebyDans chaque groupereduceRenvoie le résultat équivalent à l'exécution.

>>> from toolz import groupby, countby, reduceby
>>> from operator import add
>>> xs = range(10)
>>> is_even = lambda n: n % 2 == 0
>>> groupby(is_even, xs)
{False: [1, 3, 5, 7, 9], True: [0, 2, 4, 6, 8]}
>>> countby(is_even, xs)
{False: 5, True: 5}
>>> reduceby(is_even, add, xs)
{False: 25, True: 20}

`itertools.groupby regroupe les éléments consécutifs, alors que toolz.groupby groupes quel que soit l'ordre des éléments.`



```pycon
>>> import toolz as tz
>>> import itertools as it
>>> xs = range(10)
>>> is_even = lambda n: n % 2 == 0
>>> tz.groupby(is_even, xs)
{False: [1, 3, 5, 7, 9], True: [0, 2, 4, 6, 8]}
>>> [(k, list(g)) for k, g in it.groupby(xs, is_even)]
[(True, [0]), (False, [1]), (True, [2]), (False, [3]), (True, [4]), (False, [5]), (True, [6]), (False, [7]), (True, [8]), (False, [9])]

Ajout / concaténation d'éléments à la séquence --cons, concat, concatv

consAjoute un élément au début de la séquence. concatConcatène les séquences. concatvEstconcatvEst conçu pour prendre un argument de longueur variable.

>>> from toolz import cons, concat, concatv
>>> xs = range(10)
>>> cons(-1, xs)
>>> list(concat([xs, xs]))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(concatv(xs, xs))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Division de la séquence --partition, partition_all, partitionby

partition 、partition_allDivise la séquence en taples de la longueur spécifiée. L'opération lorsqu'il y a un reste est différente.

Ne spécifiez pas de remplissage pour `` partition ''. Le surplus n'est pas produit.
Spécifie le remplissage pour partition```. Sortez le reste. Remplissage avec la valeur spécifiée là où il n'y a pas de valeur.
`` Partition_all '' peut raccourcir le dernier élément.

partitionbyDivise la séquence avec la fonction spécifiée.

>>> from toolz import partition, partition_all, partition by
>>> xs = range(10)
>>> list(partition(3, xs))
[(0, 1, 2), (3, 4, 5), (6, 7, 8)]
>>> list(partition(3, xs, None))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]
>>> list(partition_all(3, xs))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9,)]
>>> list(partitionby(lambda x: x < 5, xs))
[(0, 1, 2, 3, 4), (5, 6, 7, 8, 9)]

slide_window --Fenêtre coulissante

sliding_windowProduit un taple de la longueur spécifiée, en décalant l'index un par un.

>>> from toolz import sliding_sindow
>>> list(sliding_window(3, range(10)))
[(0, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 7), (6, 7, 8), (7, 8, 9)]

Fusionner plusieurs séquences triées --merge_sorted

merge_sortedPrend plusieurs séquences triées comme arguments, les fusionne et les génère.

>>> from toolz import merge_sorted
>>> from random import randint
>>> xs = sorted([randint(1, 10) for _ in range(5)])
>>> ys = sorted([randint(1, 10) for _ in range(5)])
>>> zs = sorted([randint(1, 10) for _ in range(5)])
>>> xs
[3, 6, 6, 6, 9]
>>> ys
[3, 4, 5, 7, 8]
>>> zs
[1, 2, 4, 5, 8]
>>> list(merge_sorted(xs, ys, zs))
[1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 7, 8, 8, 9]

Notez que si la séquence saisie n'est pas triée, les résultats ne seront pas dans l'ordre.

>>> from toolz import merge_sorted
>>> from random import randint
>>> xs = [randint(1, 10) for _ in range(5)]
>>> ys = [randint(1, 10) for _ in range(5)]
>>> zs = [randint(1, 10) for _ in range(5)]
>>> xs
[4, 3, 10, 7, 3]
>>> ys
[7, 8, 1, 10, 2]
>>> zs
[2, 6, 2, 4, 10]
>>> list(merge_sorted(xs, ys, zs))
[2, 4, 3, 6, 2, 4, 7, 8, 1, 10, 7, 3, 10, 2, 10]

Si les entrées ne sont pas triées, vous pouvez concaténer et trier pour obtenir les résultats dans l'ordre.

>>> from toolz import concatv
>>> sorted(concatv(xs, ys, zs))
[1, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 10, 10, 10]

join: jointure de séquence

Combinez les deux séquences par la valeur de la fonction clé.

>>> from toolz import join
>>> from toolz.curried import get #Importer un get curled
>>> carts = [('Taro', 'Apple'), ('Taro', 'Banana'), ('Jiro', 'Apple'), ('Jiro', 'Orange'), ('Sabu', 'Banana'), ('Sabu', 'Banana')]
>>> prices = [('Apple', 100), ('Banana', 80), ('Orange', 150)]
>>> for x in join(get(1), carts, get(0), prices):
...     print x
... 
(('Taro', 'Apple'), ('Apple', 100))
(('Jiro', 'Apple'), ('Apple', 100))
(('Taro', 'Banana'), ('Banana', 80))
(('Sabu', 'Banana'), ('Banana', 80))
(('Sabu', 'Banana'), ('Banana', 80))
(('Jiro', 'Orange'), ('Orange', 150))

Functoolz

Curry - curry

curry

curryVous pouvez utiliser des fonctions pour curry.

>>> from tools import curry
>>> from operator import add
>>> curried_add = curry(add)
>>> curried_add(3)(4)
7

curryPeut également être utilisé comme décorateur.

>>> from tools import curry
>>> @curry
... def add(a, b):
...     return a+b
... 
>>> add(3)(4)
7

Curry de fonctions fournies par toolz

`Pour les fonctions fournies par toolz, toolz.Vous pouvez obtenir la version courbée en important à partir de curry.`



 Prenons le cas de la fonction `` map '' comme exemple.
```toolz```De```map```Si vous installez et transmettez uniquement la fonction, vous obtiendrez une erreur indiquant qu'il n'y a pas assez d'arguments.

```pycon
>>> from toolz import map as not_curried_map
>>> list(not_curried_map(lambda x: x + 1)([1, 2, 3]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: imap() must have at least two arguments.

currySi vous le curry avec, vous pourrez faire ce qui suit:

>>> list(curry(not_curried_map)(lambda x: x + 1)([1, 2, 3]))
[2, 3, 4]

`toolz.Si vous importez du curry, il sera curry afin que vous puissiez l'exécuter tel quel.`



```pycon
>>> from toolz.curried import map as curried_map
>>> list(curried_map(lambda x: x + 1)([1, 2, 3]))
[2, 3, 4]

Synthèse des fonctions --compose, pipe, thread_first, thread_last

compose

composeVous pouvez utiliser pour synthétiser plusieurs fonctions.

compose(f, g, h)(x)Estf(g(h(x)))Est le même que.

>>> from toolz import compose, curry
>>> from operators import add, mul
>>> compose(curry(mul)(2), curry(add)(1))(3)
8

pipe, thread_first, thread_last

pipeAussicomposeVous pouvez appliquer plusieurs fonctions aux données de la même manière que composeEt l'ordre des arguments est inversé.

Comme un tube shell, il est évalué de gauche à droite comme le flux de données. pipe(x, f, g, h)Esth(g(f(x)))Ce sera.

>>> from toolz import pipe
>>> from toolz.curried import get
>>> pipe('hello world', str.split, get(0), str.upper)
'HELLO'

thread_first 、thread_lastReçoit une fonction à un argumentpipeCela fonctionne de la même manière que.

>>> from toolz import thread_first, thread_last
>>> from toolz.curried import get
>>> thread_first('hello world', str.split, get(0), str.upper)
'HELLO'
>>> thread_last('hello world', str.split, get(0), str.upper)
'HELLO'

Les fonctions qui acceptent deux arguments ou plus peuvent être passées à l'aide de tapples, et le comportement est différent. thread_firstDans le cas de, le résultat passé de la fonction précédente devient le premier argument. thread_lastDans le cas de, c'est le dernier argument.

>>> thread_first('hello world', str.split, get(0), str.upper, (add, 'WORLD'))
'HELLOWORLD'
>>> thread_last('hello world', str.split, get(0), str.upper, (add, 'WORLD'))
'WORLDHELLO'

Memoize --memoize

memoizeVous pouvez utiliser pour créer un mémo. memoizePeut également être utilisé comme décorateur.

>>> def tarai(x, y, z):
...     if x <= y:
...         return y
...     return tarai(tarai(x-1, y, z), tarai(y-1, z, x), tarai(z-1, x, y))
... 
>>> tarai(12, 6, 0)
12
>>> t = memoize(tarai)
>>> t(12, 6, 0)
12

Appliquer plusieurs fonctions au même argument --juxt

>>> from toolz import juxt
>>> from operator import add, mul
>>> juxt(add, mul)(3, 4)
(7, 12)

Fonction égale - identité

identityRenvoie l'argument tel quel.

>>> from toolz import identity
>>> identity(3)
3

Traitement par effets secondaires-faire

doExécute une fonction et renvoie un argument. Puisque le résultat de l'exécution de la fonction est ignoré, il est utilisé à des fins telles que la sortie d'un journal comme effet secondaire.

L'exemple suivant ajoute un argument à log```.

>>> from toolz import compose
>>> from toolz.curried import do
>>> log = []
>>> map(compose(str, do(log.append)), range(5))
['0', '1', '2', '3', '4']
>>> log
[0, 1, 2, 3, 4]

Dicttoolz

Parcourir / mettre à jour les dictionnaires imbriqués --get_in, update_in

get_inVous pouvez facilement faire référence à un dictionnaire imbriqué en passant une liste de clés comme argument. Vous pouvez également spécifier une valeur par défaut.

>>> from toolz import get_in
>>> d = {"a": {"b": {"c": 1}}}
>>> d
{'a': {'b': {'c': 1}}}
>>> get_in(["a", "b", "c"], d)
1
>>> get_in(["a", "b", "e"], d, 'None')
'None'

update_inVous pouvez facilement mettre à jour un dictionnaire imbriqué en passant une liste de clés comme argument.

La mise à jour se fait en passant une fonction de mise à jour. Aucune modification n'est apportée au dictionnaire d'origine et la fonction est appliquée pour renvoyer le dictionnaire mis à jour.

>>> from toolz import update_in
>>> d = {"a": {"b": {"c": 1}}}
>>> update_in(d, ["a", "b", "c"], lambda x: x+1)
{'a': {'b': {'c': 2}}}
>>> d
{'a': {'b': {'c': 1}}}

Si la clé n'existe pas, elle sera créée avec la valeur par défaut.

>>> update_in(d, ["a", "b", "e"], lambda x: x+1, 0)
{'a': {'b': {'c': 1, 'e': 1}}}

finalement

De nombreuses fonctionnalités sont implémentées en utilisant itertools et `` functools```, il est donc lourd à utiliser comme référence pour l'utilisation de ces modules.

J'ai essayé d'utiliser la bibliothèque de programmation fonctionnelle toolz