Ich habe versucht, toolz zu verwenden, eine Erweiterung der Standardbibliotheken `` itertools``` und `functools```.

Installation

Sie können es mit pip installieren.

$ pip install toolz

Es gibt auch eine Cython-Version, die schneller läuft.

$ pip install cytoolz

Wie benutzt man

toolzDie von bereitgestellten Funktionen sind grob in die folgenden drei unterteilt. dieses Hausitertoolz 、functoolzSind jeweilsitertools 、functoolsBietet Funktionen, die der Erweiterung von entsprechen.

Itertoolz
Functoolz
Dicttoolz

`toolz bietet auch Standardfunktionen wie Zuordnen, Reduzieren und Filtern. Wenn Sie diese importieren und es sich um eine Karte handelt, handelt es sich um itertools.Es wird durch eine Funktion ersetzt, die Iterable wie IMAP verarbeiten kann. Die Verwendung dieser Funktionen ist fast die gleiche wie die ursprüngliche, daher werde ich darauf verzichten.`



 Im Folgenden werden Funktionen vorgestellt, die wahrscheinlich häufig verwendet werden.

 Itertoolz


#### **`Es bietet die entsprechende Funktionalität von itertools.[itertools Rezept](http://docs.python.jp/2.7/library/itertools.html#itertools-recipes)Es gibt auch Funktionen wie die in.`**

Holen Sie sich Element-Get, zupfen

get

getIst eine Funktion, die Elemente aus einer Sequenz oder einem Wörterbuch abruft.

Sie können das Element aus der Sequenz abrufen, indem Sie den Index angeben.

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

Sie können den Schlüssel auch übergeben, um den Wert aus dem Wörterbuch abzurufen.

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

Es ist möglich, einen Standardwert anzugeben, wenn kein Index angegeben ist oder der Schlüssel nicht vorhanden ist.

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

Sie können mehrere Werte erhalten, indem Sie einen Index oder Schlüssel in eine Liste übergeben.

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

pluckIstgetZumapGibt das Ergebnis zurück, das äquivalent zu ist.

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

Kumulative Berechnung - akkumulieren

accumulateIstreduceÄhnlich wie, gibt jedoch einen Iterator zurück, der kumulativ zurückgibt. Seit Python 3.2 ist es in `` `itertools``` implementiert.

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

Gruppierung --groupby, countby, redubyby

groupbyGruppiert die Elemente der Sequenz nach dem Wert der Tastenfunktion. countbyZählt die Anzahl der Elemente in jeder Gruppe. reducebyIn jeder GruppereduceGibt das Ergebnis zurück, das der Ausführung entspricht.

>>> 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 gruppiert aufeinanderfolgende Elemente, während toolz.groupby groups unabhängig von der Reihenfolge der Elemente.`



```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])]

Hinzufügen / Verketten von Elementen zur Sequenz --cons, concat, concatv

consFügt am Anfang der Sequenz ein Element hinzu. concatVerkettet die Sequenzen. concatvIstconcatvIst für ein Argument mit variabler Länge ausgelegt.

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

Teilen der Sequenz --partition, partition_all, partitionby

partition 、partition_allTeilt die Sequenz in Taples der angegebenen Länge auf. Die Operation, wenn es einen Rest gibt, ist anders.

Geben Sie keine Auffüllung für `Partition an. Der Überschuss wird nicht ausgegeben.
Gibt die Auffüllung für `` `Partition``` an. Den Rest ausgeben. Auffüllen mit dem angegebenen Wert, wenn kein Wert vorhanden ist.
`` `Partition_all``` kann das letzte Element verkürzen.

partitionbyTeilt die Sequenz mit der angegebenen Funktion.

>>> 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)]

Schiebefenster - Schiebefenster

sliding_windowGibt ein Taple der angegebenen Länge aus und verschiebt den Index nacheinander.

>>> 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)]

Mehrere sortierte Sequenzen zusammenführen --merge_sorted

merge_sortedNimmt mehrere sortierte Sequenzen als Argumente, führt sie zusammen und gibt sie aus.

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

Beachten Sie, dass die Ergebnisse nicht in der richtigen Reihenfolge sind, wenn die eingegebenen Sequenzen nicht sortiert sind.

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

Wenn die Eingaben nicht sortiert sind, können Sie verketten und sortieren, um die Ergebnisse in der richtigen Reihenfolge zu erhalten.

>>> 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 --Sequence join

Kombinieren Sie die beiden Sequenzen mit dem Wert der Tastenfunktion.

>>> from toolz import join
>>> from toolz.curried import get #Import gekräuselt bekommen
>>> 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

currySie können Funktionen zum Curry verwenden.

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

curryKann auch als Dekorateur verwendet werden.

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

Curry von Funktionen von toolz

`Für die von toolz bereitgestellten Funktionen gilt toolz.Sie können die gekräuselte Version erhalten, indem Sie sie aus Curry importieren.`



 Nehmen wir als Beispiel den Fall der Funktion `` `map```.
```toolz```Von```map```Wenn Sie nur die Funktion installieren und übergeben, wird eine Fehlermeldung angezeigt, dass nicht genügend Argumente vorhanden sind.

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

curryWenn Sie es mit curry, können Sie Folgendes tun:

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

`toolz.Wenn Sie aus Curry importieren, wird es Curry angezeigt, damit Sie es so ausführen können, wie es ist.`



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

Funktionssynthese --compose, pipe, thread_first, thread_last

compose

composeSie können mehrere Funktionen synthetisieren.

compose(f, g, h)(x)Istf(g(h(x)))Ist das gleiche wie.

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

pipe, thread_first, thread_last

pipeEbenfallscomposeSie können auf die gleiche Weise wie auf mehrere Funktionen auf die Daten anwenden composeUnd die Reihenfolge der Argumente ist umgekehrt.

Wie ein Rohrohr wird es wie der Datenfluss von links nach rechts ausgewertet. pipe(x, f, g, h)Isth(g(f(x)))Es wird sein.

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

thread_first 、thread_lastErhält eine Funktion mit einem ArgumentpipeEs funktioniert genauso wie.

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

Funktionen, die zwei oder mehr Argumente annehmen, können mithilfe von Tapples übergeben werden, und das Verhalten ist unterschiedlich. thread_firstIm Fall von wird das von der vorherigen Funktion übergebene Ergebnis zum ersten Argument. thread_lastIm Fall von ist es das letzte 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'

Auswendiglernen - merken

memoizeSie können ein Memo erstellen. memoizeKann auch als Dekorateur verwendet werden.

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

Wenden Sie mehrere Funktionen auf dasselbe Argument an --juxt

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

Gleiche Funktion - Identität

identityGibt das Argument wie es ist zurück.

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

Behandlung durch Nebenwirkungen-do

doFührt eine Funktion aus und gibt ein Argument zurück. Da das Ausführungsergebnis der Funktion verworfen wird, wird es beispielsweise zum Ausgeben eines Protokolls als Nebeneffekt verwendet.

Das folgende Beispiel fügt ein Argument zu `` `log``` hinzu.

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

Verschachtelte Wörterbücher durchsuchen / aktualisieren --get_in, update_in

get_inSie können leicht auf ein verschachteltes Wörterbuch verweisen, indem Sie eine Liste von Schlüsseln als Argument übergeben. Sie können auch einen Standardwert angeben.

>>> 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_inSie können ein verschachteltes Wörterbuch einfach aktualisieren, indem Sie eine Liste von Schlüsseln als Argument übergeben.

Die Aktualisierung erfolgt durch Übergabe einer Funktion zum Aktualisieren. Am ursprünglichen Wörterbuch werden keine Änderungen vorgenommen, und die Funktion wird angewendet, um das aktualisierte Wörterbuch zurückzugeben.

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

Wenn der Schlüssel nicht vorhanden ist, wird er mit dem Standardwert erstellt.

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

Schließlich

Viele Funktionen werden mit `itertools``` und` functools``` implementiert, daher ist es schwierig, sie als Referenz für die Verwendung dieser Module zu verwenden.

[PYTHON] Ich habe versucht, die funktionale Programmierbibliothek toolz zu verwenden