List – Seznam – Vektory od A do Z - Power Query Editor

Úvodem

V tomto článku se podíváme na seznamy (listy), z důvodo přehlednosti je článek rozdělen na kapitoly.

• Teorie
  • Teorie seznam - list
  • Jak zadat do M (tabulka/ručně)
  • Typy list – seznamů
• Praktická tvorba listu - seznamy
  • Ručně(čísla,písmena,datumy)
  • Proměnné v seznamech
  • Tvorba seznamů využitím funkce
• Porovnávací a slučování operátory
  • Porovnávání seznamů
  • Slučování seznamů
  • Rozdělován seznamů
• Operace s listy, seznamy, vektory
  • Ručně odkázat se na přechozí výsledek
  • Počet prvku seznamu – Count
  • Matematika nad seznamem – vektorem – listem
• Transformace seznamů
  • Transformace (výpočet)
  • Vybrat konkrétní položku ze seznamu
  • Vybrat více položek ze seznamu
  • Odstranění položky z listu
• Nahrazování přidávání a změna hodnot v listu
  • Využitím ReplaceValue
  • Transformaci funkce Transform
  • Vložit položky
• Řazení
  • Řazení podle velikosti - čísla
  • Řazení abecedně - písmena
  • Kombinace
• Pozice prvků
  • Jeden prvkek
  • Více prvků
• Speciálnosti
  • Do paměti - Buffer
  • Text do listu
  • Odstranění mezery

Teorie

V tomto článku se podíváme jak pracovat se seznamy (v češtině označováno jako seznam, někdo označuje jako vektor). List je k dispozici v Power Query Editoru, ten naleznete v Excel, stejně tak i v Power BI. Ukázky fungují v obou nástrojích.

_Než se prakticky podiváme na seznamy a jejich tvorbu, úpravu atd, je vhodné si definova co to ten seznam je, případně jak seznam do M vložit. Zde předpokládám mírně pokročilé znalosti, ale pro dokreslení situace se může hodit.

Co je list (seznam)

Seznam (List v EN názvosloví - proto i funkce a metody pracující se seznamem začínají List.), někdy označováno také jako vektor. List (seznam, vektor) si můžete představit jako řadu hodnot. Hodnoty jsou uloženy v jednom sloupci. Seznam se ukládá do složených závorek {} a jednotlivé hodnoty jsou odděleny čárkou.

Seznam si můžete vytvořit „nakliknutím“ v Power Query Editoru, nebo seznam můžete vytvořit ručně. Kdy začátek a konec seznamu je označen složenými závorkami { }. (tj. složené závorky označují začátek a konec seznamu). Jednotlivé hodnoty (hodnotou může být číslo, logická, text, symbol, parametr, další seznam, záznam, tabulka, funkce), tyto hodnoty jsou oddělené čárkami.

= {42,7}

Ukázkový seznam obsahuje dvě hodnoty 42 a 7.

Velikost list (seznam)

Listy seznamy jsou víceméně neomezené, mají neomezenou velikost. Jde o teorií, protože seznam musíte nějak zpracovat.

Ale pro ukázku, vytvořme velkou číselnou řadu. Jsme omezeni 32 bitovým číslem, tedy max velikot je 2.147.483.647 což můžeme zadat jako:

= {1.. 2147483647}

Větší číslo neprojde (32bitu)

= { 1.. 2147483648} //Chyba

Ale lze zadat za sebou...

Ale_lze_využít_= { 1.. 2147483647, 1.. 2147483647}

Rychlost zpracování

Tady popravdě nevím, jak zjistit a předpovědět, navíc v M-ku každý další krok zpracování prodlužuje. Pokud někdo ví metodu jak zjisti, jak rychle se ta která operace provede, budu rád za zmínku do komentářů. Pro vaše testy, můžete využít, třeba výpis tři největších čísel ze seznamu.

=List.MaxN({ 1.. 21474836}, 3) //hned =List.MaxN({ 1.. 214748364}, 3) //delší chvílí =List.MaxN({ 1.. 2147483647}, 3) //po pár minutách jsem čekání na výsledek vzdal

Zpracování potrvá velice dlouho! Aneb zde si můžete ověřit rychlost zpracování operací.

=List.MaxN({ 1.. 2147483647, 1.. 2147483647}, 3)

V následující kapitole si ukážeme jak do M seznam zadat. Případně lepší varinata přejít na tabulky, které jsou ve svém důsledku skládají ze seznamů (listů).

Jak zadat do M (tabulka/ručně)

Tvorba seznamu v Excel a Power BI jde provést pomocní nakliknutí.

Z hotové tabulky

Toto není součásti tohoto článku. Jen pro připomenutí například pravá klik nad sloupcem a vybrat „Procházet hiearchií“ v češtině.

Ručním zápisem

Seznam lze vytvořit i ručním zápisem. Jelikož budeme testovat (můžete si vybrat Power BI nebo Excel, funguje stejně), nejlépe je v Power Query Editoru (jak Power Query Editoru spustit, mám popsáno v samostatných článcích, v tomto článku předpoklásám mírně pokročilou znalost Power Query Editoru) vytvořit nový Prázdný dotaz na pásu karet Domů > Nový zdroj > Jiné zdroje > Prázdný dotaz, nebo pravým tlačítkem nad seznamem dotazů a vybrat Nový dotaz > Prázdný dotaz

Následně do řádku vzorců postačí zadat M kód, neboli syntaxi, která vytvoří požadované, například ={42} vytvoří jedno hodnotový seznam s číslem 42.

Pro potvrzení je potřeba zadat Enter.

Na pásu karet Domů > Rozšířený editor se můžete podívat jak vypadá M-kód. Což přesahuje rámec článku, proto bude zmíněno v samostatném článku.

Poznámka: Co je za dvojitým lomítkem je poznámka a po kliku na enter zmizí.

Typy list – seznamů

Ukázka možných seznamů.

= {} // prázdný seznam = {42} // jedno hodnotový číselný {42} = {"A", "B", "C"} // stringový (písmenkový) seznam = {{ 1, 2 }, { 8, 9 }} // seznam ze seznamu = {[Jmeno = "Pavel"], [Jmeno = "Lucie" ]} // seznam rekordů/záznamů = {1, "A", (x,y)=>x+y}} // kombinace hodnot v seznamu = {1 .. 6 } // číselná řada viz dále = {"A" .. "C" } // písmenová (stringová) řada viz dále = {#date(2021, 10, 15), #date(2021, 10, 19)} // seznam s datumem = {"!", """", "#", "$", "%", "&" } // seznam speciálních znaků = {"!" .. "&" } // seznam speciální znaky sekce viz ASCI tabulka

Praktická tvorba Listu

Jak vytvořit list, vektor, různé způsoby:

• Ručně na základě požadavku můžete mít
  • Čísla
  • Písmena
  • Datum
  • Dynamicky
• Využitím funkce
  • List.Numbers
  • List.Reverse
  • List.Generate
  • List.Alternate
  • List.Repeat

Ručně(čísla, písmena, datumy)

Ruční vytvoření listu. Kdy lze vytvořit seznamy:

• Čísla
• Písmana,znaky
• Datum,čas
• Speciální_znaky

Ručně – čísla

Číselné řady můžete zadávat velice jednoduše, kdy do složených závorek za sebou zadáváte čísla (pokud jde o desetinné číslo tak desetinným oddělovačem je tečka). Pokud potřebujete číselnou řadu, lze vyžít dvou teček za sebou např. 1 .. 6 vytvoří číselnou řadu 1 až 6 (1,2,3,4,5,6).

= {1, 2, 8.2, -9} // řada čísel {1,2,8.2,-9} = {1 .. 6} // čísla {1,2,3,4,5,6} = {6 .. 1} // prázdný seznam = {1..6, {8..12}} // {1,2,3,4,5,6,List} = {-6 .. 6} // {-6,-5,-4,-3,-2,-1,1,2,3,4,5,6}

Ručně – Písmena

Stejně jako čísla můžete zadávat i písmena, texty, znaky

= {"A", "B", "C" } // {A,B,C} = {"Pavel", "Lasák", "MVP" } // {Pavel,Lasák,MVP} = { "A" .. "C" } // písmenová řada viz dále {A,B,C} = { "A" .. "C", "E" .. "H"} // {A,B,C,E,F,G,H} = { "AA" .. "CC" } // funguje pouze pro jednoznakové

Ručně Datumy, časy, datumy s časem

Budete-li potřebovat vytvořit řadu po sobě jsoucích dnů, času, datumu s časem, můžete využít funkce. Nebo klasicky z číselnou řadu, které následně přiřadíte formát datum:

• List.Times(start as time, count as number, step as duration) as list
• List.DateTimes(start as datetime, count as number, step as duration) as list
• List.Dates(start as date, count as number, step as duration) as list

Pro tvorbu datum se vám možná budou hodit:

• #date(2022, 11, 11)
• #datetime(2022, 11, 20, 12, 15, 0)
• #time(12, 0, 0)

Datumy

= List.Dates(#date( 2022, 11, 11 ), 5, #duration( 1, 0, 0, 0 )) = List.Dates(#date( 2022, 11, 11 ), 5, #duration( 2, 0, 0, 0 ))

Časy

=List.Times(#time(12, 0, 0), 4, #duration(0, 0, 15, 0)) =List.Times(#time(12, 0, 0), 4, #duration(0, 1, 0, 0))

Datum a čas

= List.DateTimes(#datetime(2022, 11, 20, 12, 15, 0), 10, #duration(0, 0, 15, 0)) Datumy jako čísla

= { Number.From( #date( 2021, 10, 19 ) ) .. Number.From( #date( 2021, 10, 25 ) )} = List.Numbers( Number.From( #date( 2021, 10, 19 )), Duration.Days( #date( 2021, 10, 25 ) - #date( 2021, 10, 19 ) ) + 1)

Speciální nebo klasické znaky, písmena, čísla

Pro tvorbu speciálních řad můžete využít funkci Character.FromNumber

={Character.FromNumber(56), Character.FromNumber(59)} ={Character.FromNumber(33) .. Character.FromNumber(38)} ={Character.FromNumber(1) .. Character.FromNumber(254)}

Funkce v listu

Viz samostatný článek o funkcích

= { 1, "A", (x,y)=>x+y } } // kombinace hodnot v seznamu

Kombinace

Samozřejmě můžete mít v listu i kombinaci, čísla, texty, znaky, datumy, seznamy, záznamy.

= { true,null,{1,2} , "B", #date( 2022, 11, 11 ) , (x,y)=>x+y }

Seznam ze záznamů (Record)

={[Jmeno = "Pavel"],[Jmeno = "Lucie"]}

Proměné v seznamech

Předchozí hodnoty ručního zápisu, lze využít v kombinaci s proměnnými, kdy do příslušných proměnných se uloží minima a maxima a následně se vygeneruje seznam (list, neboli vektor).

let Minimum = 1, Maximun = 6, Source = { Minimum .. Maximun } in Source

Tvorba seznamů využitím funkce

Budeme využívat funkce:

• List.Numbers
• List.Reverse
• List.Generate
• List.Alternate
• List.Repeat

Jejich syntaxe je:

• List.Numbers(start as number, count as number, optional increment as nullable number) as list
• List.Reverse(list as list) as list
• List.Generate(initial as function, condition as function, next as function, optional selector as nullable function) as list
• List.Alternate(list as list, count as number, optional repeatInterval as nullable number, optional offset as nullable number) as list
• List.Repeat(list as list, count as number) as list

List.Numbers

V předchozích kapitolách jste zjistili, že můžete k vytvoření seznamu použít dvě tečky, zdy využijeme funkce, které tvorbu číselných řad více zpříjemní a přidají další možností, jako nastavit krok

=List.Numbers(1, 6 ) // {1,2,3,4,5,6} =List.Numbers(1, 6, 1) // {1,2,3,4,5,6} =List.Numbers(1, 6, 2) // {1,3,5,7,9,11} =List.Numbers(6, 6, -1) // {6,5,4,3,2,1} =List.Numbers(Number.From( #date(2021,10,19)),10)

List.Reverse

Zatím jsme stále číselná řady zvětšovali, co když budeme chtít číselné řady v opačně, od největšího čísla k nejmenšímu (a nebudeme chtít řadit). Zároveň převodem čísla můžete získat i datum, čas, písmena

= List.Reverse({1 .. 6}) // {6,5,4,3,2,1} = List.Reverse( { 6 .. 1 } ) // bude prázdný = List.Numbers( 6, 6, -1 ) // {6,5,4,3,2,1} využitím předchozí funkce

List.Generate

Případně vygenerovat číselnou řadu využitím funkce Genereat

=List.Generate(() => 6, each _ >= 1, each _ - 1) // {6,5,4,3,2,1} =List.Generate(() => 1, each _ <= 6, each _ + 1) // {1,2,3,4,5,6}

// jak funguje each viz samostatný článek

List.Alternate

Velice zajimavá funkce Alternate, která střídá zobrazování hodnot na základě parametrů (count, repeatInterval a offset

• List.Alternate(list as list, count as number, optional repeatInterval as nullable number, optional offset as nullable number) as list

= List.Alternate( { 1..10 }, 0 ) // {1,2,3,4,5,6,7,8,9,10} = List.Alternate({1..10}, 1, 1) // {2,4,6,8,10} = List.Alternate({1..10}, 1, 1, 1) // {1,3,5,7,9} = List.Alternate( { 1..10 }, 2,1) // {3,6,9} = List.Alternate( { 1..10 }, 2,2) // {3,4,7,8}

List.Repeat

Sezamy, listy, se dají vytvořit i opakováním

= List.Repeat( {1}, 3 ) // {1,1,1} = List.Repeat( { 1, 2, 3 }, 3 ) //{1,2,3, 1,2,3, 1,2,3} = List.Repeat( { "A", "B", "C" }, 3 ) // {A,B,C,A,B,C,A,B,C} = List.Repeat( { {1, 2} , {3,4 }}, 3 ) //

List.Random

Náhodné číslo (čísla do seznamu). Velikost čísel je v rozsahu 0 až 1

= List.Random( 1 ) // = List.Random( 3 )

Porovnávací a slučování operátory

Nad seznamy, listy, vektory se dají dělat různé operace, v této sekci se podíváme na

• Porovnávání
• Slučování
• Průnik
• Rozdělení

Porovnávání seznamů

Potřebujete-li porovnat dva seznamy

= {1,2} = {1,2} // true - pravda = {1,2} <> {1,2} // false – nepravda = {1,2} = {2, 1} // false – nepravda = {1,2} = {1,2,3} // nepravda = {{1,2}, {42}} = {{1,2}, {42}} // true - pravda = {1,2} >= { 1,2,3} // nelze = {1,2} + { 1,2,3} // nelze

Slučování seznamu

V této sekci se podiváte na:

• Slučování využitím znaku &
• Slučování| pomocí funkce
• Průnik seznamů

Slučování| (kombinování) znak &

Nejrychlejší je použití znaku &

= {1, 2} & {3, 42} // {1,2,3,42} = {1, 2} & {{3, 42}, {5,6}} // {1,2,list,list} = {"P", "a"} & {"v", "e", "l"} // { "P","a", "v", "e", "l" } = {"P", "a"} & {"v", "e"} & {"l"} // { "P","a", "v", "e", "l" }

Slučování| (kombinování) pomocí funkce

Sloučení seznamu využitím funkce:

• List.Combine(lists as list) as list

=List.Combine({{1, 2}, {3, 4}}) // Equals { 1, 2, 3, 4 }

Spojení seznamů

Ke spojení seznamu lze využít funkci

• List.Zip(lists as list) as list

= List.Zip({{1,2,3}, {"A","B","C"}}) // {{1,A},{2,B},{3,C}} = List.Zip( { { 1, 2, 3 }, { "A", "B", "C" },{ "a", "b", "c" } } ) // {{1,A,a},{2,B,b},{3,C,c}} = List.Zip( { { 1, 2, 3 }, { "A", "B", "C" },{ true, null, {1,2} } } ) // { 1, A, true },{ 2, B, null },{ 3, C, List }

Průnik seznamů

Průnik seznamů, lze využít funkci:

• List.Union(lists as list, optional equationCriteria as any) as list

Čísla

= List.Union( { { 1, 2 }, { 2, 3 } } ) // Výsledek { 1, 2, 3 } = List.Union( { { 1, 2 }, { 3, 2 } } ) // Výsledek { 1, 2, 3 } = List.Union( { { 1, 2, 2 }, { 3, 2, 2 ,1} } ) // Výsledek { 1, 2, 2, 3 }

Písmena

= List.Union( { { "a", "b" }, { "b", "c" } } ) // Výsledek { a, b, c } = List.Union( { { "a", "b" }, { "B", "c" } } ) // Výsledek { a, b, B, c } = List.Union( { { "a", "b" }, { "B", "c" } } , Comparer.OrdinalIgnoreCase) // Výsledek { a, b, c }

Rozdělování seznamů

Rozdělení seznamů využitím funkce:

• List.Split(list as list, pageSize as number) as list

= List.Split( { 1,2,3,4,5,6 }, 2) //{{1,2},{3,4},{3,4}} = List.Split( { 1,2,3,4,5,6 }, 1) = List.Split( { 1,2,3,4,5,6 }, 4) = List.Split( { 1,2,3,4,5,6 }, 7)

Matematické operace s list, seznam, vektor

Co vše lze nad seznamem provádět

• Odkázat se na předchozí krok v M-ku
• Zjistit počet prvků
• Matematika (součet, max, min...)

1.5 • • •

Ručně odkázat se na přechozí výsledek

Jen pro ukázku, odkazování se na předchozí kroky, práce s parametry atd. bude součásti jiného samostatného článku

let A = 1, B = 2, Source = {A,B} in Source

Počet prvků v senzma – Count

Při výpočtech je často potřeba znát počet prvků v listu (seznamu), případně zda list (seznam) neobsahuje nulové (null) hodnoty, nebo zda není prázdný. K tomu můžeme využít funkce:

• List.Count(list as list) as number
• List.NonNullCount(list as list) as number
• List.IsEmpty(list as list) as logical

Počet prvků (Count)

= List.Count({1,2,3,4}) // 4 - prvky = List.Count({{1,2,3},{4,2}}) // 2 - dva seznamy = List.Count({List.Count({1,2,3}),List.Count({4,2}) // 2, čísla výsledek funkcí

Počet bez null (opravdu prázdných) hodnot

= List.Count({1,2,3,null} ) // 4 = List.NonNullCount({1,2,3, null} ) // 3

Kontrola zda jde o prázdný seznam

= List.IsEmpty({}) // True = List.IsEmpty({1, 2}) // False

Matematika nad seznamem – vektorem – listem

Bez matematiky nad listy (seznamy) se nedá obejít, proto máte k dispozici několik funkcí, které vám tuto práci usnadní:

• List.Average(list as list, optional precision as nullable number) as any
• List.Max(list as list, optional default as any, optional comparisonCriteria as any, optional includeNulls as nullable logical) as any
• List.MaxN(list as list, countOrCondition as any, optional comparisonCriteria as any, optional includeNulls as nullable logical) as list
• List.Median(list as list, optional comparisonCriteria as any) as any
• List.Min(list as list, optional default as any, optional comparisonCriteria as any, optional includeNulls as nullable logical) as any
• List.MinN(list as list, countOrCondition as any, optional comparisonCriteria as any, optional includeNulls as nullable logical) as list
• List.Mode(list as list, optional equationCriteria as any) as any
• List.Modes(list as list, optional equationCriteria as any) as list
• List.Product(numbersList as list, optional precision as nullable number) as nullable number
• List.Percentile(list as list, percentiles as any, optional options as nullable record) as any
• List.StandardDeviation(numbersList as list) as nullable number

V následujících ukázkách jsou praktické příklady k odzkoušení a pochopení jak funkce fungují:

Součet – suma

Snad nejčastější požadavek, kromě počtu je součet.

= List.Sum( {1, 2, 3, 4} ) // 10 = List.Sum( { {1, 2}, {3, 4} } ) // nelze složeno ze seznamu = List.Sum( {1, "A", 3, 4} ) // nelze obsahuje znak

Nejčastější výskyt

Pro zjištění nejčastějšího výskytu prvku v seznamu, lze využít funkci

= List.Mode( {42, 1, 42, 3, 42, 5, 6}) // 42 = List.Mode( {42, 1, 42, 3, 42, 5, "A"}) // 42 = List.Mode( {42, 1, "A", 3, "A", 5, "A"}) // A = List.Mode( {42, 42, "A",42, "A", 5, "A"}) // A = List.Modes( {42, 1, 42, 3, 42, 5, 6}) // {42} = List.Modes( {42, "A", "A",42, "A", 5, 42}) // {42, "A"}

Průměr Medián

Pro zjištění mediánové, nebo-li střední hodnoty

= List.Average({1, 2, 3}) //2 = List.Average({1, 2, 3, 42}) //12 = List.Median({1, 2, 3}) //2 = List.Median({1, 2, 3, 42}) // 2,5

Maxima a minima

Pro zjištění minim a maxim existuje několik funkcí, záleží zda chcete, pouze jednu maximální (minimální) hodnotu, nebo několik maximální (či minimálních) hodnot.

Pro zjištění maximálních hodnoty

= List.Max({1, 2, 3, 4, 5, 42} ) // 42 = List.Max({1, 2, 3, "A", 42} ) // A = List.Max({1, 2, 3, "A", "AZ", "Z"} ) / Z = List.Max({1, 2, 3, 4, 5, 42, 42} ) // 42

Pro zjištění několika maximálních hodnot

= List.MaxN({1, 2, 3, 4, 5, 42}, 3) // {42,5,4} = List.MaxN({1, 2, 3, 4, 5, 42}, 1) // {42} = List.MaxN({1, 2, 3, null, "A", "Z", 42}, 3) // {Z,A,42} = List.MaxN({1, 2, 3, {}, "Z", 42}, 3) // Chyba = List.MaxN({1, "Z", 6}, 6) // {Z,6,1}

Pro zjištění minimální hodnoty

= List.Min({1, 2, 3, 4, 5, 42} ) // 1 = List.Min({1, null, true, 4, 5, 42} ) // 1

Pro zjištění několika minimálních hodnot

= List.MinN({1, null, true, 4, 5, 42} ,3) // {1,4,5} = List.MinN({1, 1, 1, 4, 5, 42} ,3) // {1,1,1}

Součin - Product

Pro zjištění součinu čisel z listu (seznamu)

= List.Product( {1, 2, 3} ) // 6 = List.Product( {1, 2, 3, 4} ) // 24 = List.Product( {1, 2, 3, 4,5} ) // 120

Směrodatná odchylka

Pro zjištění směrodatné odchylky.

= List.StandardDeviation( {1, 2, 3, 4} ) // 1,2909944487358056 = List.StandardDeviation( {1, 2, 3} ) // 1

Ano mohla by být k dispozici i výběrová, nebo rozptyl, ale kdo to prakticky využije? Pokud opravdu je potřeba lze využít DAX.

Transformace seznamů

Při práci se seznamy mnohdy potřebujete hodnoty v seznamu upravit. Například:

• Upravit hodnoty například přičíst, odečíst,...
• Vybrat konkrétní položku (položky)
• Odstranění položek

Transformace (výpočet)

Výpočty nad listem (seznam) se dají provádět využitím funkce:

• List.Transform(list as list, transform as function) as list

= List.Transform( { 1, 2, 3 }, each _ + 1 ) //{ 2, 3, 4 } = List.Transform( { 1, 2, 3 }, each _ * 10 ) //{ 10, 20, 30 }

Vybrat konkrétní položku ze seznamu

Potřebujete-li z listu získat konkrétní položku. Můžeme použít:

• Hranaté závorky pro přečtení hodnoty na konkrétní pozici
• Funkci pro první/poslední
• Funkci po prvních posledních N

Využitím hranaté závorky

Hranaté závorky nejen uzavírají list (seznam), ale mohou se využít i k získání požadovaného prvku ze seznamu. Jen se musí počítat s tím, že se čísluje od nuly, takže první prvek je nultý. Pokud budete požadovat zobrazit prvek, který v seznamu není, obdržíte chybu.

Toto lze ošetřit využitím otazníku

= { 1, 2, 3 }{0} // Vrátí první položku tj. 1 = { 1, 2, 3 }{1} // Vrátí druhou položku tj. 2 = { 1, 2, 3 }{1+1} // Vrátí třetí položku tj. 3 = { { 1, 2 },{ 3, 4 } }{0} // Vrátí první seznam { 1, 2 } = { { 1, 2 },{ 3, 4 } }{0}{1} // 2 // Z prvního seznamu { 1, 2 } vrátí druhou pozici tj výsledek tj. 2 = { 1, 2, 3 }{4} // chyba pátý prvek není = { 1, 2, 3 }{4}? // null – protože pátý prvek není a je ? = { 1, 2, 3 }?{4} // Chyba - otazník je před

Využitím funkcí First/Last

Pro zjištění hodnoty ze seznamu můžete využít i funkce:

• List.Last(list as list, optional defaultValue as any) as any
• List.First(list as list, optional defaultValue as any) as any

Které vrátí poslední prvek ze seznamu

= List.First( { 1, 2, 3 } ) // 1 = List.First( {null, 2, 3 } ) // null = List.First( {1, {}, 3 } ) // 1 = List.First( {} ) // null = List.First( {}, 3 ) // 3 = List.First( { {}, 2, 3 } ) // prázdný seznam

Které vrátí poslední prvek ze seznamu

= List.Last( { 1, 2, 3 } ) // 3 = List.Last( {} ) // null = List.Last( { {}, 2, 3 ,{}} ) // prázdný seznam

Vybrat více položek ze seznamu

Pro výběr více položek ze seznamu můžete využít funkce:

• List.FirstN(list as list, countOrCondition as any) as any
• List.LastN(list as list, optional countOrCondition as any) as any

Nadherně se dají funkce využít ve spojení s _ nebo-li pro každý prvek seznamu. Neboli použití each, proberu v samostatném článků.

Využítím funkcí FirstN/LastN

Prvních posledních N prvků, spolu s využitím each a podtržítka:

Prvních N

= List.FirstN( { 1, 2, 3, 4 }, 2) // {1,2} = List.FirstN( { {}, {}, 3, 4 }, 2) // { , {}} = List.FirstN( { {1,2}, {1,2}, 3, 4 }, 2) // {{1,2}, {1,2}} = List.FirstN( { null, null, 3, 4 }, 2) // {null, null} = List.FirstN( { 3, 4 }, 3) //{ 3, 4 } = List.FirstN({"A", "B", 42, "A", 5, 42}, 3) // {A, B, 42}

Prvních N využitím each

= List.FirstN( { 3, 2, 4, 1 }, each _ <= 3) //3,2 = List.FirstN( { 3, 2, 4, 1, 3,2 }, each _ <= 3) //3,2 = List.FirstN( { 3, 2, 1, 3,2 }, each _ <= 3) // 2,3,1,3,2 = List.FirstN( { 3, 2, 4, 1, 3,2 }, each _ >=2)

Prvních N využitím each a funkce

= List.FirstN({1, 2, 3, 4 }, each Number.IsOdd( _ ) ) // {1} = List.FirstN({1, 3, 4,5 }, each Number.IsOdd( _ ) ) // {1,3} = List.FirstN({1, 3, 4,5 }, each Number.IsOdd( _ ) ) = List.FirstN( { 2, 4,5 }, each Number.IsEven( _ ) ) // {2,4}

Posledních N, funguje podobně jako prvních N, proto pouze ve zkratce:

= List.LastN( { 1, 2, 3, 4 }, 2) = List.LastN({1, 3, 4,5 }, each Number.IsOdd( _ ) ) // {5}

Vybrat položky využitím Range

Vybírat položky můžete i využitím funkce Range

• Text.Range(text as nullable text, offset as number, optional count as nullable number) as nullable text

Praktické ukázky použití Range

= List.Range( { 1, 2, 3, 4, 5, 6 }, 0, 2 ) // {1, 2} = List.Range( { 1, 2, 3, 4, 5, 6 }, 0, 0 ) // {} = List.Range( { 1, 2, 3, 4, 5, 6 }, 5, 1 ) // {6} = List.Range( { 1, 2, 3, 4, 5, 6 }, 6, 1 ) // {} = List.Range( { 1, {}, 3, 4, 5, 6 }, 0, 2 ) // {1, {}}

Vybrat položky využitím Select

Další možností jak vybírat položky ze seznamu je využití List.Select

• List.Select(list as list, selection as function) as list

Vyběr sudých a lichých

= List.Select( { 1, 2, 3, 4, 5, 6, 42 }, each Number.IsEven( _ ) ) // {2,4,6,42} = List.Select( { 1, 2, 3, 4, 5, 6, 42 }, each Number.IsOdd( _ ) ) // {1,3,5}

Vyběr větší menší

= List.Select( {1, 2, 0, 4, 5, 42, -2}, each _ <= 2 ) // {1,2,0,-2} = List.Select( {1, 2, 0, 4, 5, 42, -2}, each _ > 2) // {4, 5, 42} = List.Select( {1, 2, 0, 4, 5, 42, -2}, each _ = 2 ) // {2} = List.Select( {1, 2, 4, 5, "A", "B"}, each _ > 2) // Chyba

Vyběr větší menší za použití operátoru and a or

= List.Select( {1, 2, 0, 4, 5, 42, -2}, each (_ = 2 or _ = 4) ) // {2, 4} = List.Select( {1, 2, 0, 4, 5, 42, -2}, each (_ = 2 and _ = 4) ) // prázdný = List.Select( {1, 2, 0, 4, 5, 42, -2}, each (_ >= 2 and _ <= 4) ) // {2, 4} = List.Select( {1, 2, 0, 4, 5, 42, -2}, each (_ >= 1 and _ <= 5) ) // {1, 2, 4,5}

Vyběr typu hodnoty, číslo, text, ...

= List.Select({"A", 1, "B", 2, null }, each Value.Type( _ ) = type text ) // {A,B} = List.Select({"A", 1, "B", 2, null }, each Value.Type(_) = type number) // {1, 2} = List.Select({"A", 1, "B", 2, null }, each Value.Type(_) = type null) // {null}

Odstranění položky z listu

Na úpravu seznamu se můžete dívat i z jiného pohledu, nebudete zobrazovat co chcete, ale odstraníte co nechcete, což někdy může být vhodnější a rychlejší, opět máte na výběr několik funkci:

• List.RemoveFirstN(list as list, optional countOrCondition as any) as list
• List.RemoveItems(list1 as list, list2 as list) as list
• List.RemoveLastN(list as list, optional countOrCondition as any) as list

List.RemoveFirstN

Základy

= List.RemoveFirstN({1, 2, 3, 4 }, 2 ) // {3, 4} = List.RemoveFirstN({ 1, 2, 3, 4 }, 3 ) // { 4 }

Využitím each

= List.RemoveFirstN({3, 2, 5, 4, 1}, each _ <= 3 ) // {5,4,1} = List.RemoveFirstN({3, 2, 5, 4, 1}, each (_ = 3 or _ = 2)) // {5,4,1} = List.RemoveFirstN({3, 1, 5, 4, 1}, each Number.IsOdd( _ ) ) // {4,1} = List.RemoveFirstN({2, 4, 5, 4, 1}, each Number.IsEven( _ ) ) // {5,4,1}

List.RemoveLastN

základy

= List.RemoveLastN({ 1, 2, 3, 4 }, 3 ) // {1} = List.RemoveLastN({ 1, 2, 3, 4 }, 2 ) // {1,2}

Využitím each

...

Nahrazování přidávání a změna hodnot v listu

Jak na transformaci a změnu hodnot, například nahrazování jednoho znaku jiným, případně změnu velikosti písmen, všechna malá. a to využitím:

• Využitím ReplaceValue
• Transformaci_funkce_ Transform
• Vložením položky

Využitím ReplaceValue

V seznamu můžete upravovat i znaky, hodnoty využitím funkce ReplaceValue, výhodou můžete požadovat ať se celý hledaný řetězec shoduje, nebo jen část řetězce.

Například chceme nahradit slovo koruna na kačka, a požadavek může být sova obsahující koruna (takže stokoruna, koruna stromů, koruna česká atd.) a všude se slovo koruna nahradí, nebo přesnou shodu, teda k náhradě dojde pouze u slova koruna, stokoruna td již ne, obsahují znaky navíc.

Využijete funkci:

• List.ReplaceValue(list as list, oldValue as any, newValue as any, replacer as function) as list
  • Replacer.ReplaceText
  • Replacer.ReplaceValue

Prakticky

= List.ReplaceValue({"a", "B", "a", "a"}, "a", "A", Replacer.ReplaceText) = List.ReplaceValue({"pavel", "petr", }, "p", "P", Replacer.ReplaceText) = List.ReplaceValue({"pavel", "petr", "prokop"}, "p", "P", Replacer.ReplaceText) = List.ReplaceValue({"a", "B", "a", "a"}, "a", "1", Replacer.ReplaceText) = List.ReplaceValue({"a", "B", "a", "a"}, "a", "1", Replacer.ReplaceText) = List.ReplaceValue({"a", "B", "a", "a"}, "a", "1", Replacer.ReplaceValue) = List.ReplaceValue({"a", "B", "a", "a"}, "a", 1, Replacer.ReplaceValue) = List.ReplaceValue( { "Bar", "Cat", "Dat" }, "a", "1", Replacer.ReplaceValue ) = List.ReplaceValue( { "Bar", "Cat", "Dat" }, "a", "1", Replacer.ReplaceText ) = List.ReplaceValue( { "Bar", "Cat", "Dat" }, "Cat", "1", Replacer.ReplaceValue ) = List.ReplaceValue( { "Bar", "Cat", "Catt" }, "Cat", "1", Replacer.ReplaceText )

Transformaci_funkce_ Transform

Jak na transformace využitím funkce Transform. Například záměna znaků atd (což se v Power Query dá provést využitím ikon, ale proč nenapsat přímo v M-ku).

• List.Transform(list as list, transform as function) as list

= List.Transform({"abc", "cde", "fgh"}, Text.Proper) //{"Abc", "Cde", "Fgh" } = List.Transform({"abc", "cde", "fgh" }, Text.Upper ) = List.Transform({"ABC", "cde", "Fgh" }, Text.Lower )

Vložením položky

Pro vkládání polložek do seznamu lze využít:

• List.InsertRange(list as list, index as number, values as list) as list

= List.InsertRange({1, 2, 3}, 1, {-1, -2}) // {1, -1, -2, 2, 3} = List.InsertRange({1, 2, 3}, 0, {-1, -2}) // {-1, -2, 1, 2, 3}

Řazení

Jak položky v seznamu řadit? Využít funkci Sort. Vhodné je ve spojení s funkci Buffer, která je zmíněna v článku níže:

• List.Sort(list as list, optional comparisonCriteria as any) as list

Řazení podle velikosti čísla

Asi nejčastějším požadavkem se seřadit hodnoty podle číselné velikosti, od největších (věk, váha, výška, zisky)

=List.Sort({2, 3, 1, 4}) =List.Sort({2, 3, 1, 4}, Order.Ascending ) =List.Sort({2, 3, 1, 4}, Order.Descending ) =List.Buffer(List.Sort({5,1,2,3,4}))

Řazení abecedně – písmena

Další požadavek seřadit seznam abecedně (názvy, jména, ...)

= List.Sort( { "Z", "A", "C", "K" }, Order.Ascending) = List.Sort( { "Z", "A", "C", "K" }) = List.Sort( { "Z", "A", "C", "K" }, Order.Descending)

Kombinace

V poslední řadě, kombinace, kdy se v listu mohou nacházet různé hodnoty (čísla, písmena, logické hodnoty, ...)

= List.Sort( { "Z", true, 1, 9 }) = List.Sort( { "Z", true, 1, {1,2} }) //Chyba

Pozice prvků v seznamu

Při práci se seznamem, je potřeba najít pozici prvku v tomto seznamu, můžeme využít:

• List.PositionOf(list as list, value as any, optional occurrence as nullable number, optional equationCriteria as any) as any
• List.PositionOfAny(list as list, values as list, optional occurrence as nullable number, optional equationCriteria as any) as any

Pozice pro jeden prvek

Jak najít pozici jednoho prvku. Kdy pokud není prrvek nalezen obdržíte hodnotu -1.

= List.PositionOf( { 1, 2, 3, 4}, 3 ) // Výsledek 2 - třetí pozice = List.PositionOf( { "A", "B", "C", "D"}, "C" ) = List.PositionOf( { "A", "B", "C", "D"}, "E" ) // Vrátí – 1 - nenalezeno = List.PositionOf( { "A", "B", "C", "D"}, "E" )? // Otazník nefunguje

Více prvků

Z více prvku najít pozici.

=List.PositionOfAny({1, 2, 3}, {2, 3}) // 1 =List.PositionOfAny({1, 3, 2}, {2, 3}) // 1 =List.PositionOfAny({1, 2, 3}, {3, 2}) // 1 =List.PositionOfAny({1, 2, 3}, {5, 3}) // 2 =List.PositionOfAny({1, 3, 2}, {4, 5}) // Výsledek -1, protože nenalezeno

Speciálnosti

Co se mi jinam nepovedlo zařadit a může se hodit,nejen pro práci se seznamem.

• Využít paměť (Buffer)
• Z textu seznam
• Odstraňování mezer

Do paměti

Uložení seznamu do vyrovnávací paměti, nejčastěji po seřazení, kdy po M vynutíte vytvořit seřazený seznam, který například potřebujete v dalším kroku kdy odeberete poslední prvek který je poslední v abecedě.

• List.Buffer(list as list) as list

=List.Buffer({1..3}) // {1, 2, 3} =List.Buffer(List.Sort({5,1,2,3,4}))

Z textu seznam (list, vekror)

Dokonce z textu lze vytvořit seznam využitím funkce (pokud nechcete "naklikávat").

• Text.ToList(text as text) as list

= Text.ToList("Pavel")

Odstranění mezer

V textech se dají odstraňovat mezery. Pro informaci, viz samostatný článek, kde sepíši poznámky o práci s textem.

• Text.Trim(text as nullable text, optional trim as any) as nullable text
• Text.TrimEnd(text as nullable text, optional trim as any) as nullable text
• Text.TrimStart(text as nullable text, optional trim as any) as nullable text

=Text.Trim(" a b c d ") =Text.TrimStart(" a b c d ") =Text.TrimEnd(" a b c d ")

Závěrem

Narazili jste na nějaký problém/ nejasnost? Máte tip na doplnění, můžete to zmínit v komentářích.

Článek byl aktualizován: 01.11.2022 08:41

Pavel Lasák - autor webu

Microsoft Office (Word, Excel, Google tabulky, PowerPoint) se věnuji od roku 2000 (od 2004 na této doméně) - V roce 2017 jsem od Microsoft získal prestižní ocenění MVP (zatím jsem jediný z ČR v kategorií Excel). Své vědomosti a zkušenosti dávám k dispozici i on-line ve videích pro SEDUO. Ve firmách školím a konzultuji, učím na MUNI. Tento web již tvořím přes 15 let. Zdarma je zde přes 1.000 návodu, tipů a triků, včetně přes 250 různých šablon, sešitů.

           

Komentáře zatím nejsou

Můžete být prvními co zanechají smysluplný komentář.