Funkcionální programování v Pythonu s využitím knihovny Toolz (2. část)

Obsah

1. Funkcionální programování v Pythonu s využitím knihovny Toolz (2. část)

2. Získání četnosti prvků v sekvenci

3. Rozdělení sekvence na základě výsledků funkce aplikované na prvky

4. Rozdělení prvků nekonečné sekvence

5. Posuvné okno nad sekvencí

6. Posuvné okno a nekonečná vstupní sekvence

7. Nalezení unikátních prvků v sekvenci

8. Test, zda sekvence obsahuje unikátní prvky

9. Rozdíl mezi operací partition a partition_all

10. Operace get

11. Operace pluck

12. Spojení sekvencí na základě klíčů (join)

13. Vylepšení tisku výsledku operace join

14. Vnitřní spojení (inner join)

15. Vnější spojení (outer join)

16. Obsah navazujícího článku

17. Repositář s demonstračními příklady

18. Odkazy na Internetu

1. Funkcionální programování v Pythonu s využitím knihovny Toolz (2. část)

Ve druhém článku o knihovně Toolz, která podporuje funkcionální paradigma v programovacím jazyku Python, dokončíme popis podbalíčku itertoolz, jenž obsahuje funkce (a vlastně nic jiného než funkce) určené pro zpracování a analýzu sekvencí. Uveďme si pro úplnost všechny funkce z tohoto podbalíčku, které jsme si buď již popsali minule či které si popíšeme v dnešním článku:

2. Získání četnosti prvků v sekvenci

Velmi užitečná může být v praxi funkce nazvaná frequencies. Název této funkce naznačuje, jaký výpočet se provádí: analyzuje se vstupní sekvence a zjistí se četnost jejich prvků. Výsledkem je v tomto případě slovník (dictionary) jehož klíči jsou prvky ze vstupní sekvence a hodnotami pak jejich četnosti. Podívejme se na jednoduchý příklad se sekvencí tvořenou náhodnými celočíselnými hodnotami. Následně jsou ze sekvence získány unikátní prvky (funkcí unique popsanou dále) a znovu je vypočtena četnost prvků nové sekvence:

from random import randrange
from toolz.itertoolz import frequencies, unique
 
values = [randrange(1, 11, 1) for _ in range(30)]
print(frequencies(values))
 
values2 = unique(values)
print(frequencies(values2))

Na prvním řádku jsou vypsány četnosti prvků z původní sekvence náhodných čísel, na řádku druhém pak četnosti prvků ze sekvence unikátních hodnot:

{8: 6, 6: 3, 3: 2, 2: 4, 4: 3, 10: 2, 9: 5, 7: 2, 1: 2, 5: 1}
{8: 1, 6: 1, 3: 1, 2: 1, 4: 1, 10: 1, 9: 1, 7: 1, 1: 1, 5: 1}

Vše bude pochopitelně funkční i pro sekvence s řetězci či dalšími objekty:

from random import randrange
from toolz.itertoolz import frequencies, unique
 
values = ("Karel", "Ivan", "Petr", "Pavel", "Jan", "Petr", "Ivan", "Ivan")
print(frequencies(values))

Výsledky:

{'Karel': 1, 'Ivan': 3, 'Petr': 2, 'Pavel': 1, 'Jan': 1}

3. Rozdělení sekvence na základě výsledků funkce aplikované na prvky

Již minule jsme si popsali funkci nazvanou partition. Ovšem v balíčku itertoolz nalezneme ještě další dvě funkce s podobným jménem. Jedná se o funkce partitionby a partition_all. Nejprve se podívejme na funkci partitionby, která je taktéž obecně velmi užitečná. Tato funkce sekvenčně prochází vstupní sekvencí a pro každý přečtený prvek volá nějakou uživatelem specifikovanou funkci. Ve chvíli, kdy volaná funkce vrátí odlišnou hodnotu (od předchozího volání) jsou do výstupní sekvence vloženy všechny prvky, pro něž daná uživatelská funkce vrací stejnou hodnotu. Pokud například bude uživatelská funkce testovat, zda je prvek menší než 5, bude výstupní sekvence postupně obsahovat n-tice s prvky většími nebo rovny pěti následované sekvencí s prvky menšími než 5, následované sekvencí s prvky většími nebo rovny pěti atd.

Podívejme se na příklad:

from random import randrange
from toolz.recipes import partitionby
 
values = [randrange(1, 11, 1) for _ in range(30)]
print(values)
 
values2 = partitionby(lambda x: x < 5, values)
print(list(values2))

Tento skript nejdříve vypíše vstupní sekvenci a následně sekvenci rozdělenou na n-tice s prvky většími nebo rovny 5, popř. naopak s prvky menšími než 5:

[6, 7, 9, 5, 8, 4, 3, 3, 4, 5, 10, 6, 1, 2, 5, 5, 10, 3, 10, 7, 6, 3, 1, 8, 9, 4, 9, 10, 2, 7]
[(6, 7, 9, 5, 8), (4, 3, 3, 4), (5, 10, 6), (1, 2), (5, 5, 10), (3,), (10, 7, 6), (3, 1), (8, 9), (4,), (9, 10), (2,), (7,)]

Více viditelné je chování ve chvíli, kdy se prvky rozdělují na sekvenci prvků kladných a záporných:

from random import randrange
from toolz.recipes import partitionby
 
values = [randrange(-5, 5, 1) for _ in range(30)]
print(values)
 
values2 = partitionby(lambda x: x < 0, values)
print(list(values2))

Výsledky:

[-5, -1, -2, -2, 0, -4, 0, 4, -5, -3, -4, -2, -3, -4, 4, -1, 0, -2, 3, -1, -5, -4, -4, 3, -5, -5, -1, 4, 3, -2]
[(-5, -1, -2, -2), (0,), (-4,), (0, 4), (-5, -3, -4, -2, -3, -4), (4,), (-1,), (0,), (-2,), (3,), (-1, -5, -4, -4), (3,), (-5, -5, -1), (4, 3), (-2,)]

4. Rozdělení prvků nekonečné sekvence

Funkce partitionby, podobně jako některé další funkce z knihovny Toolz, dokáže pracovat s nekonečnými sekvencemi. To znamená, že vyhodnocení (výstupní sekvence) je prováděno „líně“ a až ve chvíli, kdy je to skutečně nezbytné. Ostatně si toto chování můžeme relativně snadno otestovat na vstupní sekvenci celočíselných hodnot od 0 do (teoreticky) nekonečna. Pokusíme se tuto sekvenci rozdělit na podsekvence sudých nebo lichých čísel. To je pochopitelně nekonečně dlouhá operace, ovšem nás bude zajímat prvních deset prvků z výsledné sekvence. A ty lze vypočítat v konečném čase:

from toolz.recipes import partitionby
from toolz.itertoolz import iterate, take
 
 
def inc(x):
    return x+1
 
 
values = iterate(inc, 0)
 
values2 = partitionby(lambda x: x % 2 == 0, values)
 
print(list(take(10, values2)))

Výsledkem bude sekvence deseti prvků, přičemž každý prvek bude jednoprvková n-tice (sudost/lichost se mění s každým prvkem na vstupu):

[(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]

Zajímavější je test na zbytek po dělení pěti:

from toolz.recipes import partitionby
from toolz.itertoolz import iterate, take
 
 
def inc(x):
    return x+1
 
 
values = iterate(inc, 0)
 
values2 = partitionby(lambda x: x % 5 == 4, values)
 
print(list(take(10, values2)))

Nyní bude výsledkem opět sekvence deseti prvků, ovšem nyní každý prvek (jenž je n-ticí) může obsahovat různý počet hodnot:

[(0, 1, 2, 3), (4,), (5, 6, 7, 8), (9,), (10, 11, 12, 13), (14,), (15, 16, 17, 18), (19,), (20, 21, 22, 23), (24,)]

5. Posuvné okno nad sekvencí

Mnohdy je vhodné sekvenci hodnot zpracovávat nikoli po částech (což zajišťuje funkce partition, kterou již známe), ale s využitím posuvného okna. Takové okno nabízí pohled na několik po sobě jdoucích prvků sekvence (například na pět prvků). Další okno nabízí pohled na čtyři původní prvky a jeden prvek nový atd. Prvky se tedy v postupně vytvářené výstupní sekvenci vždy objeví vícekrát, pokaždé na jiném místě okna. Podívejme se na velmi jednoduchý příklad se vstupní sekvencí s deseti prvky a posuvným oknem, které má velikost (rozsah) pěti prvků:

from toolz.itertoolz import sliding_window
 
values = range(10)
 
print(values)
 
for window in sliding_window(5, values):
    print(window)

Posuvné okno nám vytvoří celkem pět pohledů na původní sekvenci s hodnotami 0 až 9:

(0, 1, 2, 3, 4)
(1, 2, 3, 4, 5)
(2, 3, 4, 5, 6)
(3, 4, 5, 6, 7)
(4, 5, 6, 7, 8)
(5, 6, 7, 8, 9)

Okna menší či naopak větší povedou k odlišným výsledkům:

from toolz.itertoolz import sliding_window
 
values = range(10)
 
print(values)
 
for window in sliding_window(3, values):
    print(window)
 
print()
 
for window in sliding_window(7, values):
    print(window)

Pro okno o šířce tří prvků dostaneme tyto výsledky:

(0, 1, 2)
(1, 2, 3)
(2, 3, 4)
(3, 4, 5)
(4, 5, 6)
(5, 6, 7)
(6, 7, 8)
(7, 8, 9)

A toto jsou výsledky pro širší okno, které obsáhne sedm prvků:

(0, 1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6, 7)
(2, 3, 4, 5, 6, 7, 8)
(3, 4, 5, 6, 7, 8, 9)

6. Posuvné okno a nekonečná vstupní sekvence

Zajímavé je, že posuvné okno lze vytvořit i pro nekonečnou sekvenci, což si pochopitelně taktéž musíme ukázat. Nad nekonečnou sekvencí celých čísel je vytvořeno okno o šířce pěti prvků, které bude generovat nekonečné množství pětic. Ovšem z těchto pětic si vybereme pouze prvních dvacet:

from toolz.itertoolz import iterate, partition, take, sliding_window
 
 
def inc(x):
    return x+1
 
 
values = iterate(inc, 10)
 
sw = sliding_window(5, values)
 
for window in take(20, sw):
    print(window)

Výsledné pohledy, přesněji řečeno prvních dvacet pohledů na nekonečnou sekvenci vypadají takto:

(10, 11, 12, 13, 14)
(11, 12, 13, 14, 15)
(12, 13, 14, 15, 16)
(13, 14, 15, 16, 17)
(14, 15, 16, 17, 18)
(15, 16, 17, 18, 19)
(16, 17, 18, 19, 20)
(17, 18, 19, 20, 21)
(18, 19, 20, 21, 22)
(19, 20, 21, 22, 23)
(20, 21, 22, 23, 24)
(21, 22, 23, 24, 25)
(22, 23, 24, 25, 26)
(23, 24, 25, 26, 27)
(24, 25, 26, 27, 28)
(25, 26, 27, 28, 29)
(26, 27, 28, 29, 30)
(27, 28, 29, 30, 31)
(28, 29, 30, 31, 32)
(29, 30, 31, 32, 33)

7. Nalezení unikátních prvků v sekvenci

V sekvencích se pochopitelně mohou vyskytovat duplikátní prvky. Ovšem v některých případech vyžadujeme, aby byl každý prvek v sekvenci unikátní. Někdy se tento problém řeší transformací sekvence na množinu a zpět (s problematickým pořadím prvků), ovšem lepší řešení spočívá ve využití funkce unique.

Nejprve vytvoříme sekvenci obsahující všechny znaky abecedy, ovšem opakované třikrát po sobě. Následně z této sekvence odstraníme duplicity, takže by měla vzniknout sekvence unikátních prvků, a to se zachováním jejich pořadí:

from toolz.itertoolz import unique
 
values = [chr(i) for i in range(ord('A'), ord('Z')+1)] * 3
 
print(values)
 
values2 = unique(values)
print(list(values2))

Skript nejprve vypíše vstupní sekvenci (abecedu opakovanou třikrát) a posléze sekvenci vypočtenou:

['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
 
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

Tutéž operaci můžeme pochopitelně provést i pro sekvenci pseudonáhodných celočíselných hodnot:

from random import randrange
from toolz.itertoolz import unique
 
values = [randrange(1, 11, 1) for _ in range(30)]
print(values)
 
values2 = unique(values)
print(list(values2))

Výsledek může vypadat následovně (opět se jedná nejprve o původní sekvenci následovanou sekvencí s odstraněnými duplicitami):

[6, 2, 9, 6, 2, 7, 9, 6, 1, 7, 1, 6, 5, 5, 7, 8, 3, 5, 5, 4, 6, 4, 3, 1, 4, 3, 1, 6, 1, 8]
[6, 2, 9, 7, 1, 5, 8, 3, 4]

8. Test, zda sekvence obsahuje unikátní prvky

S problematikou duplicit či naopak unikátních prvků souvisí i další popisovaná funkce, která se jmenuje isdistinct. Ta slouží k testu, zda sekvence obsahuje pouze unikátní prvky. Pokud je nalezena duplicita, vrací funkce pravdivostní hodnotu False.

Otestujme si chování na sekvenci s duplicitami i na sekvenci s unikátními prvky:

from random import randrange
from toolz.itertoolz import isdistinct, unique
 
values = [randrange(1, 11, 1) for _ in range(30)]
print(list(values))
print(isdistinct(values))
 
print()
 
values2 = unique(values)
print(list(values2))
print(isdistinct(values2))

Výsledky vypsané tímto skriptem mluví samy za sebe, jak by řekl Hans Niemann:

[7, 4, 1, 8, 7, 8, 6, 7, 1, 8, 2, 10, 2, 2, 9, 8, 8, 1, 4, 8, 9, 4, 8, 3, 4, 10, 5, 8, 10, 7]
False
 
[7, 4, 1, 8, 6, 2, 10, 9, 3, 5]
True

9. Rozdíl mezi operací partition a partition_all

Ještě se na chvíli vraťme k operaci partition, o níž jsme se zmínili v předchozím článku. Tato operace dokáže prvky z původní sekvence rozdělit do n-tic se zadanou délkou. Pokud ovšem například budeme chtít prvky rozdělit do trojic a celkový počet prvků nebude dělitelný třemi, poslední jeden až dva prvky budou zahozeny. To lze částečně „napravit“ tak, že specifikujeme i výchozí hodnotu prvků. V takovém případě budou poslední prvky doplněny o další prvky s touto hodnotou tak, aby výsledkem byla sekvence vždy stejně dlouhých n-tic. Funkce partition_all naproti tomu může vrátit poslední n-tici kratší, takže zde nemusíme řešit problém výchozí hodnoty prvků (na druhou stranu je nutné v dalším kódu počítat s tím, že n-tice nebudou mít shodnou délku):

from toolz.itertoolz import partition, partition_all
 
values = [chr(i) for i in range(ord('A'), ord('Z')+1)]
 
print(values)
print(list(partition(3, values)))
print(list(partition_all(3, values)))

Při pohledu na druhý a třetí řádek je vidět rozdílné chování obou výše zmíněných operací:

['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
 
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I'), ('J', 'K', 'L'), ('M', 'N', 'O'), ('P', 'Q', 'R'), ('S', 'T', 'U'), ('V', 'W', 'X')]
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I'), ('J', 'K', 'L'), ('M', 'N', 'O'), ('P', 'Q', 'R'), ('S', 'T', 'U'), ('V', 'W', 'X'), ('Y', 'Z')]

10. Operace get

V knihovně Toolz nalezneme i operaci get použitelnou na libovolnou kolekci, tedy jak na sekvenci, tak i na slovník. Přitom je možné v jediné operaci get specifikovat větší množství selektorů tak, jak je to ukázáno v dalším příkladu. Taktéž je možné specifikovat hodnotu, která se má vrátit v případě, že kolekce prvek s daným selektorem neobsahuje. Pokud tuto hodnotu nezadáme a prvek není nalezen, vyhodí se výjimka:

from toolz.itertoolz import get
 
phonebook = {"Alice": "555-1234", "Bob": "555-5678", "Charlie": "555-9999"}
 
print(get("Bob", phonebook))
print(get(["Alice", "Bob"], phonebook))
print(get("Zdenek", phonebook, "unknown"))
print(get("Zdenek", phonebook))

A takto vypadají výsledky, včetně výše zmíněné výjimky v posledním případě:

555-5678
('555-1234', '555-5678')
unknown
Traceback (most recent call last):
  File "get.py", line 8, in <module>
    print(get("Zdenek", phonebook))
  File "/home/ptisnovs/.local/lib/python3.8/site-packages/toolz/itertoolz.py", line 454, in get
    return seq[ind]
KeyError: 'Zdenek'

11. Operace pluck

Potenciálně velmi užitečná je operace nazvaná pluck. Jedná se vlastně o operaci get, ovšem postupně aplikovanou na všechny prvky sekvence. To například znamená, že pokud máme sekvenci slovníků a potřebujeme získat pouze hodnoty pod určitým klíčem (ve všech těchto slovnících), lze použít operaci pluck, a to bez nutnosti zápisu programové smyčky. Příklad použití na sekvenci obsahující telefonní čísla tří osob:

from toolz.itertoolz import pluck
 
phonebook = [
    {"id": 0, "name": "Alice",   "phone": "555-1234"},
    {"id": 1, "name": "Bob",     "phone": "555-5678"},
    {"id": 2, "name": "Charlie", "phone": "555-9999"},
]
 
print(list(pluck("id", phonebook)))
print(list(pluck("name", phonebook)))
print(list(pluck("phone", phonebook)))

V prvním případě získáme sekvenci ID, ve druhém případě sekvenci jmen a ve třetím případě sekvenci telefonních čísel:

[0, 1, 2]
['Alice', 'Bob', 'Charlie']
['555-1234', '555-5678', '555-9999']

Podobně jako u get je možné i zde použít více selektorů:

from toolz.itertoolz import pluck

phonebook = [
    {"id": 0, "name": "Alice", "phone": "555-1234"},
    {"id": 1, "name": "Bob", "phone": "555-5678"},
    {"id": 2, "name": "Charlie", "phone": "555-9999"},
]
 
print(list(pluck(["name", "phone"], phonebook)))

Tentokrát s výsledky:

[('Alice', '555-1234'), ('Bob', '555-5678'), ('Charlie', '555-9999')]

12. Spojení sekvencí na základě klíčů (join)

Už předchozí operace pluck do jisté míry připomíná příkaz query z SQL (či jiného dotazovacího jazyka). Knihovna Toolz nabízí programátorům i další „databázovou“ operaci. Jedná se o operaci spojení (join) realizovanou funkcí se stejným jménem, tedy join. Této funkci musíme předat dvojici sekvencí, které se mají spojit. Navíc je nutné předat i selektory prvků z první i ze druhé sekvence. Tyto selektory jsou použity podobně, jako v operaci pluck a pokud se v první i druhé sekvenci naleznou totožné vybrané hodnoty, jsou tyto prvky spojeny a vloženy do výsledné sekvence.

Podívejme se na příklad dvou sekvencí (konkrétně sekvencí n-tic), které chceme spojit přes jména. V první sekvenci jsou jména uložena ve druhých prvcích n-tic (tedy pod indexem 1), ve druhé sekvenci pak na začátku každé n-tice (tedy s indexem 0). Spojení se tedy provede operací join(1, names, 0, phones):

from toolz.itertoolz import join
 
names = [
    (0, "Alice"),
    (1, "Bob"),
    (2, "Charlie"),
]
 
phones = [
    ("Alice",   "555-1234"),
    ("Bob",     "555-5678"),
    ("Charlie", "555-9999"),
]
 
for item in join(1, names, 0, phones):
    print(item)

Výsledkem bude sekvence dvojic obsahujících původní prvky:

((0, 'Alice'), ('Alice', '555-1234'))
((1, 'Bob'), ('Bob', '555-5678'))
((2, 'Charlie'), ('Charlie', '555-9999'))

13. Vylepšení tisku výsledku operace join

Vzhledem k tomu, v jakém formátu jsou získány výsledky operace join, se pokusme vylepšit tisk tabulky se jmény a telefonními čísly. Výslednou sekvenci vytiskneme tak, že z každého jejího prvku (což je dvojice) přečteme jen ty hodnoty, které budeme chtít vytisknout. Například pro tento prvek z výsledné sekvence:

((1, 'Bob'), ('Bob', '555-5678'))

získáme první prvek z první n-tice (ID), druhý prvek z první n-tice (jméno) a druhý prvek ze druhé n-tice (telefonní číslo):

print(item[0][0], item[0][1], item[1][1])

Upravený skript bude vypadat následovně:

from toolz.itertoolz import join
 
names = [
    (0, "Alice"),
    (1, "Bob"),
    (2, "Charlie"),
]
 
phones = [
    ("Alice",   "555-1234"),
    ("Bob",     "555-5678"),
    ("Charlie", "555-9999"),
]
 
for item in join(1, names, 0, phones):
    print(item[0][0], item[0][1], item[1][1])

A takto bude vypadat vytištěný telefonní seznam:

0 Alice 555-1234
1 Bob 555-5678
2 Charlie 555-9999

14. Vnitřní spojení (inner join)

Ve skutečnosti je výchozím typem spojení vnitřní spojení neboli inner join. To si ostatně můžeme velmi snadno ukázat na dalším demonstračním příkladu, v němž spojujeme dvojici sekvencí přes „sloupce“ se jmény („Alice“, „Bob“ atd.). Ovšem povšimněte si, že v první sekvenci je jeden záznam, který nelze spojit se záznamem ve druhé sekvenci („Zdenek“). A naopak, i ve druhé sekvenci je záznam, jenž nemá svůj protějšek v první sekvenci („Martin“). Vnitřní spojení v podstatě tyto záznamy bude ignorovat:

from toolz.itertoolz import join
 
names = [
    (0, "Alice"),
    (1, "Bob"),
    (2, "Charlie"),
    (3, "Zdenek"),
]
 
phones = [
    ("Alice",   "555-1234"),
    ("Bob",     "555-5678"),
    ("Charlie", "555-9999"),
    ("Martin",  "000-0000"),
]
 
for item in join(1, names, 0, phones):
    print(item[0][0], item[0][1], item[1][1])

Výsledkem vnitřního spojení je skutečně jen sekvence se třemi záznamy, které vznikly propojením obou vstupních sekvencí přes sloupce se jmény:

0 Alice 555-1234
1 Bob 555-5678
2 Charlie 555-9999

15. Vnější spojení (outer join)

Funkce join umožňuje navíc realizovat i spojení zleva, spojení zprava i plné vnější spojení (left join, right join, outer join). Podívejme se nejdříve na spojení zleva, které je provedeno po nastavení nepovinného parametru nazvaného left_default, který slouží pro „doplnění“ hodnot v první sekvenci:

from toolz.itertoolz import join
 
names = [
    (0, "Alice"),
    (1, "Bob"),
    (2, "Charlie"),
    (3, "Zdenek"),
]
 
phones = [
    ("Alice",   "555-1234"),
    ("Bob",     "555-5678"),
    ("Charlie", "555-9999"),
    ("Martin",  "000-0000"),
]
 
for item in join(1, names, 0, phones, left_default=(0, "Nikdo")):
    print(item[0][0], item[0][1], item[1][0], item[1][1])

Výsledkem bude telefonní seznam se čtyřmi záznamy:

0 Alice Alice 555-1234
1 Bob Bob 555-5678
2 Charlie Charlie 555-9999
0 Nikdo Martin 000-0000

V případě, že specifikujeme „doplňované“ hodnoty jak pro první vstupní sekvenci (left_default), tak i pro sekvenci druhou (right_default), je provedeno plné vnější spojení neboli outer join. Opět se podívejme na příklad s dvojicí vstupních sekvencí, v nichž některé prvky nemají protějšek ve druhé sekvenci:

from toolz.itertoolz import join
 
names = [
    (0, "Alice"),
    (1, "Bob"),
    (2, "Charlie"),
    (3, "Zdenek"),
]
 
phones = [
    ("Alice",   "555-1234"),
    ("Bob",     "555-5678"),
    ("Charlie", "555-9999"),
    ("Martin",  "000-0000"),
]
 
for item in join(1, names, 0, phones, left_default=(0, "Nikdo"), right_default=("Neznamy", "111-1111")):
    print(item[0][0], item[0][1], item[1][0], item[1][1])

Nyní bude výsledkem pět řádků, protože pro chybějící protějšky se automaticky doplnila výchozí hodnota:

0 Alice Alice 555-1234
1 Bob Bob 555-5678
2 Charlie Charlie 555-9999
0 Nikdo Martin 000-0000
3 Zdenek Neznamy 111-1111

16. Obsah navazujícího článku

Ve třetím článku o funkcionální knihovně Toolz již opustíme funkce určené pro zpracování sekvencí. Namísto toho se zaměříme na mnohem zajímavější oblast, konkrétně na transformaci funkcí, currying, částečné vyhodnocení funkcí atd. Tedy na techniky, které jsme mohli vidět (i když v jiné podobě) i v knihovně funcy. Toolz ovšem nabízí ucelenější a dobře propojené API k těmto technikám.

17. Repositář s demonstračními příklady

Všechny Pythonovské skripty, které jsme si prozatím v tomto seriálu ukázali, naleznete na adrese https://github.com/tisnik/most-popular-python-libs. Následují odkazy na jednotlivé příklady (pro jejich spuštění je nutné mít nainstalovánu některou z podporovaných verzí Pythonu 3, a pro dnešní příklady i výše zmíněnou knihovnu funcy):

18. Odkazy na Internetu

1. Getting started with functional programming in Python using the toolz library
   https://opensource.com/ar­ticle/18/10/functional-programming-python-toolz
2. Toolz module in Python
   https://www.geeksforgeeks.org/toolz-module-in-python/
3. functools — Higher-order functions and operations on callable objects
   https://docs.python.org/3/li­brary/functools.html
4. Functional Programming HOWTO
   https://docs.python.org/3/how­to/functional.html
5. Functional Programming in Python: When and How to Use It
   https://realpython.com/python-functional-programming/
6. Functional Programming With Python
   https://realpython.com/learning-paths/functional-programming/
7. Awesome Functional Python
   https://github.com/sfermigier/awesome-functional-python
8. Currying
   https://en.wikipedia.org/wi­ki/Currying
9. Currying in Python – A Beginner’s Introduction
   https://www.askpython.com/pyt­hon/examples/currying-in-python
10. Fundamental Concepts in Programming Languages
    https://en.wikipedia.org/wi­ki/Fundamental_Concepts_in_Pro­gramming_Languages
11. When should I use function currying?
    https://stackoverflow.com/qu­estions/24881604/when-should-i-use-function-currying
12. Toolz
    https://github.com/pytool­z/toolz/tree/master
13. Coconut: funkcionální jazyk s pattern matchingem kompatibilní s Pythonem
    https://www.root.cz/clanky/coconut-funkcionalni-jazyk-s-pattern-matchingem-kompatibilni-s-pythonem/
14. A HITCHHIKER'S GUIDE TO functools
    https://ep2021.europython­.eu/media/conference/slides/a-hitchhikers-guide-to-functools.pdf
15. Coconut aneb funkcionální nadstavba nad Pythonem (2.část)
    https://www.root.cz/clanky/coconut-aneb-funkcionalni-nadstavba-nad-pythonem-2-cast/
16. Knihovny pro zpracování posloupností (sekvencí) v Pythonu
    https://www.root.cz/clanky/knihovny-pro-zpracovani-posloupnosti-sekvenci-v-pythonu/
17. clj – repositář s knihovnou
    https://github.com/bfontaine/clj
18. clj 0.1.0 – stránka na PyPi
    https://pypi.python.org/py­pi/clj/0.1.0
19. Clojure aneb jazyk umožňující tvorbu bezpečných vícevláknových aplikací pro JVM (4.část – kolekce, sekvence a lazy sekvence)
    https://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-4-cast-kolekce-sekvence-a-lazy-sekvence/
20. Clojure a bezpečné aplikace pro JVM: sekvence, lazy sekvence a paralelní programy
    https://www.root.cz/clanky/clojure-a-bezpecne-aplikace-pro-jvm-sekvence-lazy-sekvence-a-paralelni-programy/
21. Coconut: Simple, elegant, Pythonic functional programming
    http://coconut-lang.org/
22. coconut (Python package index)
    https://pypi.python.org/pypi/coconut/
23. Coconut Tutorial
    http://coconut.readthedoc­s.io/en/master/HELP.html
24. Coconut FAQ
    http://coconut.readthedoc­s.io/en/master/FAQ.html
25. Coconut Documentation
    http://coconut.readthedoc­s.io/en/master/DOCS.html
26. Coconut na Redditu
    https://www.reddit.com/r/Pyt­hon/comments/4owzu7/coconut_fun­ctional_programming_in_pyt­hon/
27. Repositář na GitHubu
    https://github.com/evhub/coconut
28. Object-Oriented Programming — The Trillion Dollar Disaster
    https://betterprogramming.pub/object-oriented-programming-the-trillion-dollar-disaster-92a4b666c7c7
29. Goodbye, Object Oriented Programming
    https://cscalfani.medium.com/goodbye-object-oriented-programming-a59cda4c0e53
30. So You Want to be a Functional Programmer (Part 1)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-1–1f15e387e536
31. So You Want to be a Functional Programmer (Part 2)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-2–7005682cec4a
32. So You Want to be a Functional Programmer (Part 3)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-3–1b0fd14eb1a7
33. So You Want to be a Functional Programmer (Part 4)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-4–18fbe3ea9e49
34. So You Want to be a Functional Programmer (Part 5)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-5-c70adc9cf56a
35. So You Want to be a Functional Programmer (Part 6)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-6-db502830403
36. Why Programmers Need Limits
    https://cscalfani.medium.com/why-programmers-need-limits-3d96e1a0a6db
37. Infographic showing code complexity vs developer experience
    https://twitter.com/rossi­pedia/status/1580639227313676288
38. Python's reduce(): From Functional to Pythonic Style
    https://realpython.com/python-reduce-function/
39. What is the problem with reduce()?
    https://stackoverflow.com/qu­estions/181543/what-is-the-problem-with-reduce
40. The fate of reduce() in Python 3000
    https://www.artima.com/we­blogs/viewpost.jsp?thread=98196
41. Reading 16: Map, Filter, Reduce
    http://web.mit.edu/6.031/www/sp22/clas­ses/16-map-filter-reduce/
42. Currying
    https://sw-samuraj.cz/2011/02/currying/
43. Používání funkcí v F#
    https://docs.microsoft.com/cs-cz/dotnet/fsharp/tutorials/using-functions
44. Funkce vyššího řádu
    http://naucte-se.haskell.cz/funkce-vyssiho-radu
45. Currying (Wikipedia)
    https://en.wikipedia.org/wi­ki/Currying
46. Currying (Haskell wiki)
    https://wiki.haskell.org/Currying
47. Haskell Curry
    https://en.wikipedia.org/wi­ki/Haskell_Curry
48. Moses Schönfinkel
    https://en.wikipedia.org/wi­ki/Moses_Sch%C3%B6nfinkel
49. ML – funkcionální jazyk s revolučním typovým systémem
    https://www.root.cz/clanky/ml-funkcionalni-jazyk-s-revolucnim-typovym-systemem/
50. Funkce a typový systém programovacího jazyka ML
    https://www.root.cz/clanky/funkce-a-typovy-system-programovaciho-jazyka-ml/
51. Curryfikace (currying), výjimky a vlastní operátory v jazyku ML
    https://www.root.cz/clanky/curryfikace-currying-vyjimky-a-vlastni-operatory-v-jazyku-ml/
52. Primer on Python Decorators
    https://realpython.com/primer-on-python-decorators/
53. Python Decorators
    https://www.programiz.com/python-programming/decorator
54. PythonDecorators (Python Wiki)
    https://wiki.python.org/mo­in/PythonDecorators
55. Funcy na GitHubu
    https://github.com/suor/funcy/
56. Welcome to funcy documentation!
    https://funcy.readthedocs­.io/en/stable/
57. Funcy cheatsheet
    https://funcy.readthedocs­.io/en/stable/cheatsheet.html
58. PyToolz API Documentation
    https://toolz.readthedocs­.io/en/latest/index.html
59. Toolz (PyToolz) na GitHubu
    https://github.com/pytoolz/toolz
60. Fn.py: enjoy FP in Python
    https://github.com/kachayev/fn.py
61. Funcy na PyPi
    https://pypi.org/project/funcy/
62. Underscore aneb další knihovna pro funkcionální programování v JavaScriptu
    https://www.root.cz/clanky/underscore-aneb-dalsi-knihovna-pro-funkcionalni-programovani-v-javascriptu/
63. Funkce vyššího řádu v knihovně Underscore
    https://www.root.cz/clanky/funkce-vyssiho-radu-v-knihovne-underscore/
64. Awesome functional Python
    https://github.com/sfermigier/awesome-functional-python
65. lispy
    https://pypi.org/project/lispy/
66. clojure_py na indexu PyPi
    https://pypi.python.org/py­pi/clojure_py
67. PyClojure
    https://github.com/eigenhom­bre/PyClojure
68. Hy na GitHubu
    https://github.com/hylang/hy
69. Hy: The survival guide
    https://notes.pault.ag/hy-survival-guide/
70. Hy běžící na monitoru terminálu společnosti Symbolics
    http://try-hy.appspot.com/
71. Welcome to Hy’s documentation!
    http://docs.hylang.org/en/stable/
72. Hy na PyPi
    https://pypi.org/project/hy/#des­cription
73. Getting Hy on Python
    https://lwn.net/Articles/596626/