J'ai essayé d'utiliser toolz, qui est une extension des bibliothèques standard itertools et `` `functools```.
Vous pouvez l'installer avec pip.
$ pip install toolz
Il existe également une version Cython qui fonctionne plus rapidement.
$ pip install cytoolz
toolzLes fonctions fournies par sont à peu près divisées en trois. cette maisonitertoolz 、functoolzSont chacunitertools 、functoolsFournit des fonctionnalités équivalentes à l'extension de.
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.`**
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))
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]
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])]
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]
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.
partition```. Sortez le reste. Remplissage avec la valeur spécifiée là où il n'y a pas de valeur.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)]
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)]
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]
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
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
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]
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'
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
>>> from toolz import juxt
>>> from operator import add, mul
>>> juxt(add, mul)(3, 4)
(7, 12)
identityRenvoie l'argument tel quel.
>>> from toolz import identity
>>> identity(3)
3
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
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}}}
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.
Recommended Posts