Mi is az a funkcionális programozás?
A mi szempontunkból ezek a legfontosabb jellemzői:
- Tiszta függvények, amelyek a bemeneteket következetesen, mellékhatások nélkül képezik le kimenetekre.
- Megváltoztathatatlan adatok.
- Első osztályú függvények, amelyeket bármely más típushoz hasonlóan értékként kezelhetünk.
- Magasabb rendű függvények, amelyek más függvényeket vesznek át argumentumként vagy adnak vissza értékként.
Az R azonban nem tiszta funkcionális nyelv (ellentétben például a Haskell-lel).
Tekints az R-re úgy, mint egy pragmatikus nyelvre, amely egyre inkább biztosít funkcionális lehetőségeket ott, ahol ezekkel tisztán és egyszerűen elvégezhető a munka.
Általában az adatelemzés a cél, a programozás pedig csupán eszköz ehhez.
Pipe-ok
A |> pipe-ok használata a függvények összekapcsolására egyre elterjedtebb technika több nyelvben is.
Röviden:
- A pipe bal oldaláról származó eredmény lesz a jobb oldali függvény első argumentuma (a „jobb oldali” itt figyelmen kívül hagyja az opcionális sortöréseket).
- A többi argumentum szerepelhet a függvényhívásban.
- Az R-ben egy függvény_hívásba_ kell pipe-olnunk, nem csupán egy névre, ezért a zárójelek mindig szükségesek (ez eltér néhány más nyelvtől).
Néhány programozó hasznosnak tartja, ha a kód átnézésekor a pipe-ot „then”-nek ejti ki: csináld meg az 1. lépést, THEN a 2. lépést...
Az alábbi példa szemlélteti a szintaxist.
library(stringr)
"Monday-25-February" |>
str_split("-") |>
unlist() |> # [1] "Monday" "25" "February"
str_sub(1, 3) |> # [1] "Mon" "25" "Feb"
str_to_upper() |> # [1] "MON" "25" "FEB"
str_flatten(collapse = ", ")
#> [1] "MON, 25, FEB"
Ezt a fajta pipe-ot a 4.1.0-s verzióban adták hozzá a Base R-hez, és találkozhatsz vele „natív pipe” néven is.
Az RStudio szerkesztő (többek között) a Ctrl-Shift-M billentyűkombinációt használja, hogy megfelelő szóközökkel illesszen be egy pipe-ot.
Az apply-függvények
Korábban láttuk, hogy az R-ben sok függvény „vektorizált”: egy egész vektoron működnek, anélkül hogy kifejezett ciklusokat kellene írnunk.
Azok a függvények, amelyek csak vektorizált függvényeket használnak, maguk is valószínűleg automatikusan vektorizáltak lesznek.
Egy egyszerű példán:
triple <- function(x) return(3 * x)
triple(1:10)
[1] 3 6 9 12 15 18 21 24 27 30
A bonyolultabb függvények azonban lehet, hogy nem fogadnak el vektoros bemenetet, például ha ciklusokat vagy if-else blokkokat tartalmaznak.
Általánosabb módszerre van szükségünk, hogy függvényeket alkalmazzunk vektorokra (hasonlóan a map() függvényhez néhány más nyelvben).
Mivel az R alapnyelvében gazdag választéka van az adatszerkezeteknek, egy egész családnyi *apply() függvénnyel is rendelkezik, hogy ezeken dolgozzon.
Technikailag ezeket a programozók gyakran „magasabb rendű függvényeknek”, a matematikusok pedig „funkcionáloknak” nevezik, mert függvényeket vesznek át argumentumként.
Egyelőre nézzük a lapply() és a sapply() függvényt.
lapply()
A „List-apply” lista bemeneteken való működésre készült, de a vektorokat szükség esetén csendben listává alakítja.
A kimenet egy lista, ezért lehet, hogy ki kell csomagolni, hogy vektort kapjunk:
h <- function(size) {
switch(size,
"small" = 6,
"medium" = 8,
"large" = 10
)
}
v <- c("small", "large", "medium")
h(v) # bad use of an unvectorized function
#> Error in switch(size, small = 6, medium = 8, large = 10) :
#> EXPR must be a length 1 vector
lapply(v, h) # output is a list
#> [[1]]
#> [1] 6
#> [[2]]
#> [1] 10
#> [[3]]
#> [1] 8
lapply(v, h) |> unlist() # output is a vector
#> [1] 6 10 8
A Switch fogalmat ismerő tanulók észrevehetik, hogy a skaláris switch helyett használhatnánk a vektorizált recode_values() függvényt a dplyr könyvtárból.
A vektorizáció jó, és a modern R többféle módot kínál rá, hogy elérjük.
library(dplyr)
h <- function(size) {
recode_values(size,
"small" ~ 6,
"medium" ~ 8,
"large" ~ 10
)
}
v <- c("small", "large", "medium")
h(v)
#> [1] 6 10 8
A „Simplified-apply” a lapply-hoz hasonló dolgot tesz, de meg is próbálja egyszerűsíteni a visszaadott értéket: például egy nevesített vektort lista helyett.
A helyzettől függően szükség lehet az unname() használatára:
sapply(v, h)
small large medium
6 10 8
sapply(v, h) |> unname()
#> [1] 6 10 8
A purrr könyvtár
A lapply és a sapply egyszerű, a legtöbb R-felhasználó ismeri őket, és még mindig elég népszerűek vektorokhoz és egyszerű listákhoz.
A Base R-nek is van sok más apply-függvénye.
Az ilyen fajta zűrzavar helyett egy egyszerűbb és következetesebb megoldás nyújtása a Tidyverse egyik kulcscélja.
Ma már létezik a purrr csomag, amely számos további lehetőséget kínál, például a map() függvényt, miközben a tervezés következetességét és a hibaüzenetek érthetőségét is javítja.
A visszafelé kompatibilitás kevésbé köti, mint a Base R-t, így ez a csomag jelentősen közelebb viszi az R-t a más nyelvekben megtalálható modern funkcionális programozáshoz.
A purrr-ban sokféle és változatos függvény található, amelyeket nem könnyű egyszerűen összefoglalni.
Néhány forrás, ami segít eligazodni a könyvtárban:
A sok map-függvény
A map() függvény a bemenet minden elemére alkalmaz egy függvényt, és mindig egy listát ad vissza.
Eddig úgy hangzik, mint a lapply(), csak átnevezve, és talán jobb hibaüzenetekkel.
A map() azonban egy nagy családnak csupán egyetlen tagja.
Néhány kérdés, amin érdemes elgondolkodni, amikor függvényt választasz:
- Mit szeretnél visszakapni? A
map() mindig listát ad vissza, de ha egy adott típusú atomi vektort szeretnél, használd a map_chr() függvényt stringekhez, a map_int() függvényt egészekhez, és így tovább.
- Szükséged van a bemenet minden pozíciós indexére? A függvénynevek elé írd oda az
i-t, például imap().
- Több bemenetet szeretnél párhuzamosan feldolgozni?
- A névben cseréld le a
map-et map2-re, mint a map2_dbl() két bemenethez (például értékek és súlyok, egy súlyozott átlag kiszámításához)
- Cseréld
pmap-re párhuzamos bemenetek listájához, mint a pmap_chr(). És igen, hardverszintű párhuzamosság is lehetséges.
- A bemenet minden elemét fel szeretnéd dolgozni? Ha nem, gondolj a
map_if() függvényre egy predikátum (Boolean) szerinti szűréshez, a map_at() függvényre pozíciós indexfeltételek megadásához, a head_while() függvényre pedig arra, hogy addig dolgozd fel a bemenetet, amíg egy elem meg nem bukik egy predikátumon.
- Mélyen egymásba ágyazott a bemeneti adat? Vannak függvények erre a helyzetre.
- Szeretnéd, hogy a visszaadott érték mindig ugyanolyan típusú legyen, mint a bemenet? Használj
map helyett modify() függvényeket, vagy modify_tree() függvényt a rekurzív alkalmazáshoz.
Ezeknél a függvényeknél lehetőség szerint a bemeneti adat az első argumentum, hogy jól működjenek a pipe-okkal.
A purrr ráadásul (szándékosan) pedánsabb, mint a Base R. Ha valami konkrétat kérsz, a függvények pontosan azt adják vissza, vagy hibával leállnak.
Szigorú, de nagyon hatékony a nehezen megtalálható hibák csökkentésében.
Reduce-függvények
A map-függvények visszaadott értéke általában ugyanolyan hosszú, mint a bemenet.
Néhány más függvény csökkenti az adat dimenzióinak számát, például a sum().
sum(1:100)
#> [1] 5050
A fenti esetben egy 100 hosszú vektort alakítunk egy 1 hosszú egésszé.
Egy későbbi, mátrixokról és tömbökről szóló fogalomban látni fogjuk, hogy a dimenziócsökkentés fogalma ennél általánosabb.
A sum() függvény beépített (ahogy sok más statisztikai függvény is).
Szükségünk van azonban egy módra, hogy tetszőleges dimenziócsökkentő függvényeket alkalmazzunk egy adatszerkezeten, egy map()-pel egyenértékű magasabb rendű függvény segítségével.
Több más nyelvben olyan függvényneveket használnak, mint a fold, a foldl és a foldr. Az R-ben a megfelelő függvény a reduce(), amely megfelel a (algoritmusok szerelmesei számára) jól ismert MapReduce keretrendszernek.
Az első argumentum, mint általában, a bemeneti adat. A második argumentum egy kétargumentumos függvény: gyakran egy névtelen függvény, de lehet olyan egyszerű is, mint egy aritmetikai operátor, például a +.
# surround an infix operator with backticks, to use as a function
reduce(1:100, `+`)
#> [1] 5050 # same as sum(1:100)
# anonymous function, alternately add and subtract
reduce(1:10, \(accum, nextval) ifelse(nextval %% 2 == 0, accum + nextval, accum - nextval))
#> [1] 7
Számít, hogy a függvényt a bemenet elejétől vagy a végétől alkalmazzuk?
Nem, ha az operátor asszociatív, mint a + vagy a *.
Nyilvánvalóan (1 + 2) + 3 == 1 + (2 + 3).
Ezzel szemben a - és a / nem asszociatív:
(1 - 2) - 3
#> [1] -4
1 - (2 - 3)
#> [1] 2
Azoknál a függvényeknél, ahol számít az irány, van egy opcionális .dir argumentum.
# default is .dir = "forward"
reduce(1:10, `-`)
#> [1] -53
reduce(1:10, `-`, .dir = "backward")
#> [1] -5
Ahogy a map() és a map2() esetében, itt is van egy reduce2() függvény, amely két bemeneti vektoron dolgozik párhuzamosan.
Az R-ben szeretünk vektorokkal dolgozni.
Tegyük fel, hogy egyetlen végső érték helyett az összes köztes lépést szeretnéd látni.
Erre valók a megfelelő függvények: a accumulate() és az accumulate2().
A szintaxis hasonló a reduce()-hoz, néhány további opcionális argumentummal a kimeneti típus megadásához.
accumulate(1:10, `+`)
#> [1] 1 3 6 10 15 21 28 36 45 55
Az accumulate néhány gyakori fajtájának saját függvénye van.
A Vektorfüggvények fogalom a Base R-beli cumsum() és cumprod() függvényt tárgyalta, a dplyr könyvtárban pedig van cummean() a numerikus átlagokhoz, valamint cumall() és cumany() a logikai vektorokhoz.
Szűrőfüggvények
Gyakran szeretnénk a bemenet bizonyos predikátumnak megfelelő elemeit megtartani (vagy kizárni).
A Vektorszűrés fogalomban láttunk egy idiomatikus módot erre.
v <- 1:3
v[v >= 2]
#> [1] 2 3
Ezt a hagyományos R-ben sokat használják, de nem illik jól a modern funkcionális munkafolyamatokba.
Ezért a purrr kínál egy sor predikátumfüggvényt, amelyek a szokásos f(input, func, ...) argumentumkonvenciót követik, hogy pipe-okkal is működjenek.
A nevek kicsit eltérnek a legtöbb más nyelvétől (az olyan nevek, mint a filter és a drop, az R-ben már egészen mást jelentenek).
A megfelelő purrr függvények közé tartozik a keep() és a discard(), valamint néhány további.
Ezenkívül ott van az every(), a some() és a none(), amelyek egyetlen logikai érték visszaadásában helyettesítik az all() és az any() függvényt.
Tanulófeladat
