Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin · Oppitunti

reduce ja aggregate

Muita tapoja yhdistää alkioita.

Oppitunti 4/413 vaihetta

reduce ja aggregate on ilmainen Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssilla on yhteensä 4 oppituntia.

fold-rakenteesta reduce-rakenteeseen

Joskus haluat yhdistää alkiot ilman erillistä alkuarvoa.

reduce käyttää ensimmäistä alkiota alkuakkumulaattorina ja yhdistää loput alkiot siihen.

Se on fold-rakenteen pelkistetympi versio tilanteisiin, joissa alkioiden ja tuloksen tyyppi on sama.

reduce-perusteet

reduce ottaa binäärifunktion (a, b) ja soveltaa sitä kokoelmaan ilman erikseen määritettyä alkuarvoa.

Summassa se yksinkertaisesti laskee kaikki alkiot yhteen.

val xs = List(1, 2, 3, 4)
val total = xs.reduce((a, b) => a + b)

@main def run(): Unit =
  println(total)  // 10

Tyhjän kokoelman ansa

Koska reducella ei ole alkuarvoa, sen kutsuminen tyhjälle kokoelmalle aiheuttaa UnsupportedOperationException-poikkeuksen.

fold ja foldLeft toimivat turvallisesti tyhjillä kokoelmilla, koska ne käyttävät annettua alkuarvoa.

Käytä reducea vain, kun tiedät kokoelman olevan epätyhjä.

// List.empty[Int].reduce(_ + _)
// throws UnsupportedOperationException

List.empty[Int].foldLeft(0)(_ + _)  // safe, returns 0

reduceOption turvallisesti

reduceOption palauttaa Option-arvon ja antaa tyhjälle kokoelmalle None-arvon poikkeuksen heittämisen sijaan.

Tämä on turvallinen tapa tehdä reduce, kun kokoelma voi olla tyhjä.

val xs = List(5, 9, 2)
val maybeMax = xs.reduceOption(_ max _)

@main def run(): Unit =
  println(maybeMax)  // Some(9)

reduceLeft ja reduceRight

fold-funktion tavoin myös reducella on suunnan määrittävät muunnelmat.

reduceLeft yhdistää alkiot vasemmalta oikealle ja reduceRight oikealta vasemmalle. Tavallinen reduce ei takaa järjestystä rinnakkaisille kokoelmille, joten käyttäkää nimenomaista muunnelmaa, kun suunnalla on merkitystä.

val xs = List(1, 2, 3)
val l = xs.reduceLeft(_ - _)   // (1-2)-3 = -4
val r = xs.reduceRight(_ - _)  // 1-(2-3) = 2

@main def run(): Unit =
  println((l, r))  // (-4, 2)

Miksi aggregate on olemassa

fold ja reduce edellyttävät, että akkumulaattorin ja alkioiden tyypit liittyvät toisiinsa yksinkertaisella tavalla.

aggregate on yleisin fold-muoto: sen avulla akkumulaattori voi olla eri tyyppiä, ja Scalalle voidaan kertoa, miten osittaiset akkumulaattorit yhdistetään. Tämä on tärkeää rinnakkaisessa käsittelyssä.

aggregaten allekirjoitus

aggregate saa parametrikseen alkuarvon, seqop-funktion, joka lisää alkion akkumulaattoriin, sekä combop-funktion, joka yhdistää kaksi akkumulaattoria.

Peräkkäisesti käsiteltävässä kokoelmassa combopia käytetään harvoin. Rinnakkaisessa kokoelmassa sillä yhdistetään kunkin osan tulokset.

val xs = List(1, 2, 3, 4)
val sum = xs.aggregate(0)(
  (acc, x) => acc + x,   // seqop
  (a, b)   => a + b      // combop
)

@main def run(): Unit = println(sum)  // 10

aggregate eri tyypillä

Tässä aggregate yhdistää sanaluettelon yhdeksi sanojen pituuksien kokonaismääräksi, jonka tyyppi on Int.

seqop lisää kunkin sanan pituuden, kun taas combop yhdistää kaksi osittaista kokonaismäärää.

Akkumulaattorin tyyppi (Int) eroaa alkioiden tyypistä (String).

val words = List("hi", "there", "you")
val chars = words.aggregate(0)(
  (acc, w) => acc + w.length,
  (a, b)   => a + b
)

@main def run(): Unit = println(chars)  // 10

Rinnakkainen aggregointi

aggregaten todellinen voima tulee esiin rinnakkaisten kokoelmien kanssa.

Kukin säie käsittelee oman osansa seqop-funktiolla, minkä jälkeen osat yhdistetään combop-funktiolla. Näiden kahden funktion avulla Scala voi jakaa ja yhdistää työn turvallisesti.

// Conceptual: par splits the work
// val n = data.par.aggregate(0)(_ + _.length, _ + _)
// seqop runs per chunk, combop merges chunk results

Oikean työkalun valinta

Käyttäkää reducea tai reduceOptionia, kun tuloksen tyyppi on sama kuin alkioiden tyyppi ja yhdistämisoperaatio on assosiatiivinen.

Käyttäkää foldLeftia, kun tarvitsette alkuarvon tai eri tulostyypin peräkkäisessä käsittelyssä.

Käyttäkää aggregatea, kun akkumulaattorin ja alkioiden tyypit eroavat toisistaan ja haluatte rinnakkaiseen käsittelyyn sopivan yhdistämisen.

// reduce:    same type, non-empty, associative
// foldLeft:  seed + different type, sequential
// aggregate: different type + parallel merge

Yhdistäminen yhdellä läpikäynnillä

aggregate voi laskea useita asioita kerralla käyttämällä akkumulaattorina tuplea.

Tässä saadaan sekä summa että lukumäärä yhdellä läpikäynnillä, kun tuplet yhdistetään combop-funktiossa.

val xs = List(2, 4, 6, 8)
val (s, c) = xs.aggregate((0, 0))(
  (acc, x) => (acc._1 + x, acc._2 + 1),
  (a, b)   => (a._1 + b._1, a._2 + b._2)
)

@main def run(): Unit = println((s, c))  // (20, 4)

Pikatarkistus

Päättäkää, mikä operaatio on turvallisin mahdollisesti tyhjälle listalle.

Vastaa interaktiivisessa oppitunnissa

Kertaus

reduce yhdistää alkiot ilman alkuarvoa ja käyttää ensimmäistä alkiota aloituksena. Tyhjälle kokoelmalle se heittää poikkeuksen, kun taas reduceOption palauttaa None-arvon.

aggregate on yleisin fold-muoto: se käyttää alkuarvoa, seqop-funktiota alkioiden yhdistämiseen ja combop-funktiota osittaisten akkumulaattorien yhdistämiseen rinnakkaista käsittelyä varten.

Valitkaa reduce saman tyypin assosiatiiviseen yhdistämiseen, foldLeft peräkkäisiin alkuarvollisiin läpikäynteihin ja aggregate, kun tyypit eroavat tai käsittely tehdään rinnakkain.

Aloita maksutta

Opi Scala tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 143

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”reduce ja aggregate” ilmainen?

Kyllä – oppitunnin ”reduce ja aggregate” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssin, päivitä CoddyKit PROhon. Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”reduce ja aggregate”?

Muita tapoja yhdistää alkioita. Harjoittelet Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”reduce ja aggregate”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunnilla?

Kyllä. Jokainen Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin