Tables tabulky od A do Z v Power Query Editoru

Úvodem

• Teorie tabulky
  • Proč používat tabulky
  • Ukázky tabulek v Mku
• Vytvořit (zadat) tabulku využitím funkce #TABLE()
  • Zadat názvy sloupců a hodnoty - verze 1
  • Zadat počet sloupců a hodnoty - verze 2
  • Zadat název sloupce s typem dat ve sloupci a data/hodnoty - verze 3
• Funkci z listu Table.FromList()
• Funkci z tabulky Table.FromRecords()
• Funkci ze sloupce Table.FromColumns()
• Funkci z hodnoty Table.FromValue()
• Funkci z řádku Table.FromRows()
• Operace s tabulkami
  • Porovnávání tabulek
  • Slučování tabulek
• Práce s tabulkou – výběr – řádek- sloupec- hodnota
  • Z tabulky získat požadovaný sloupec
  • Z tabulky získat požadovaný řádek
  • Z tabulky získat požadovanou hodnotu
  • Z tabulky získat více sloupců
• Související články
• Ke stažení

Teorie tabulky

V této kapitole se podíváme na další typ strukturovaných dat, neboli tabulky, které se v Power Query Editoru nacházejí. Z mého pohledu se s tabulkami budete setkávat nejčastěji, proto se na ně prakticky podíváme.

Co je tabulka

Tabulka je sestava strukturovaných hodnot (podobně jako seznamy – listy – vektory nebo záznamy - recordy) a popisuje se jako „množina hodnot uspořádaných do sloupců (které jsou identifikovány jménem sloupec) a řádků (obsahují hodnoty). Když se na tabulky podíváte podrobnějí, tak se vlastně skládají z listu (seznamu, vektoru) případně může obsahovat i záznamy (record) například pro popis a typy sloupců.

#table( {"Sloupec_A", "Sloupec_B"}, { {1, 2}, {3, 4} } )

Tj. pokud si tabulku rozdělíte (podiváte podrobněji) tak obsahuje (je sestavena) z listu (seznamu, vektoru):

• {"Sloupec_A", "Sloupec_B"}
• { {1, 2}, {3, 4} }

V moudrých návodech se píše, že tabulky obsahují sloupce a řádky (jeto princip tabulek), ale mohou existovat i prázdné tabulky, což vypadá třeba takto:

=#table({},{})

Příkladem tabulky:

=#table( {"Sloupec_A", "Sloupec_B"}, { {1, 2}, {3, 4} } )

Proč používat

Tabulky jsou často konečným výsledkem dotazu, který pak lze načíst do datového modelu v Power BI nebo v Power Pivot (Excel).

Samozřejmě existují funkce, které pracují s tabulkami jako vstupními parametry a další, které generují tabulky jako návratové hodnoty.

Protože asi nejčastěji budete s tabulkami pracovat (načítat, upravovat atd.) využítím GUI (grafického rozhraní) - nebo-li naklikávat, je vhodné se i na takto strukturovaná data podívat jak funkgují v jazyku M.

Ukázky tabulek

Pro ukázku jak mohou tabulky v M-ku vypadat, v dalším textu si rozebereme podrobněji. =#table({},{}) // prázdná tabulka =#table( {"Sloupec_A", "Sloupec_B"}, { {1, 2}, {3, 4} } )

Vytvořit (zadat) tabulku

K vytvoření tabulky máte k dispozici několik možností:

• „Nakliknutím“ v GUI
• Ručně využitím funkce #table
  • Verze 1 - Zadat názvy sloupců a hodnoty
  • Verze 2 - Zadat počet sloupců a hodnoty
  • Verze 3 - Zadat název sloupce s typem dat ve sloupci a data/hodnoty
• Funkci z listu Table.FromList()
• Funkci z tabulky Table.FromRecords()
• Vytvořit tabulku ze sloupce Table.FromColumns()
• Tabulka z hodnoty - Table.FromValue()
• Tabulka z řádku - Table.FromRows()

„Nakliknutím“ v GUI

Klasicky načtete, vytvoříte tabulku využitím menu (ikonek) z Power Query Editoru. Toto téma v tomto článku přeskočím. Zde se na zub tabulkám podíváme podrobnějí využitím Rozšířeného (pokročilého) editoru.

Na pásu karet Domů > Rozšířený editor:

Ručně

Tabulku lze vytvořit i ručním zápisem. Jelikož budeme testovat více možností, tak je nejlépe vytvořit nový Prázdný dotaz na pásu karet Domů > Nový zdroj, nebo pravým tlačítkem nad seznamem dotazů a vybrat Nový dotaz > Prázdný dotaz

Využitím funkce #TABLE()

Řekl bych, že není doslovně přesná syntaxe pro vytvoření tabulek za využití funkce #table, (z mého pohledu záznamy ([]) a seznamy ({}) jí mají jasněji definovanou), nebo spíše máte více možností, jak vytvořit tabulku.

Asi nejjednodušší je začít funkci #table

#table()

Poznámka: Podle informací na internetu tuto funkci nevrací vnitřní proměnná #shared. Popravdě jsem neprocházel, ale, jen pro informaci. Syntaxi atd, lze najít na internetu.

Syntaxe pro #table

• #table(columns as any, rows as any) as any

Syntaxi #table lze přepsat

= #table( columns as any, rows as any) as any

Existuje totiž několik způsobů jak tabulku vytvořit využitím funkce #table z mého pohledu bych rozdělil na tři:

• Zadat názvy sloupců a hodnoty
• Zadat počet sloupců a hodnoty
• Zadat název sloupce s typem dat ve sloupci a data/hodnoty

Tabulka se sestaví pomocí funkce #table, kdy jednotlivé řádky tabulky se zapisují jako seznam {"A", 1} více o seznamu (list, vektor) v samostatném článku.

Pojďme tedy na to.

VERZE 1 – Zadat názvů sloupce a data

První možností, kdy se zadají názvy sloupců a následně hodnoty do jednotlivých řádku. Asi nejčastější použití.

=#table( {"A", "B"}, { {1, 2}, {3, 4} } )

Zadáním názvů sloupců jako textových hodnot v seznamu získá každý sloupec svůj specifický název. 1,2 hodnoty v prvním řádku, 3,4 hodnoty v druhém řádku

Rozebereme si funkci

=#table( {"A", "B"}, // Názvy sloupců { {1, 2}, // hodnoty pro první řádek {3, 4} // hodnoty pro druhý řádek } )

Ukázka dalších možností – kombinace různých hodnot

= #table( {"A", "123"}, // Názvy sloupců { {1, null}, // hodnoty pro první řádek {{1,2,3}, "A"}, // hodnoty pro druhý řádek list a text {#date(2016,1,1),true}, // hodnoty 4 řádek datum a log hodnota { (x) => x+1,[A=1,B=2]} // hodnoty 5 řádek funkce a záznam } )

Úplně prázdná tabulka

=#table({},{})

Tabulka bez hodnot

=#table({"A"},{})

Tři řádky tři sloupce

= #table( {"Sloupec 1", "Sloupec 2", "Sloupec 3"}, { {1.1, 1.2, 1.3}, {2.1, 2.2, 2.3}, {3.1, 3.2, 3.3} } )

Jeden sloupec jeden řádek:

= #table({"A"},{{1}})

VERZE 2 – Definování počtu sloupců

Další možností je počet sloupců a hodnoty, kdy názvy sloupců budou Column1, Column2 atd.

=#table(2, {{ 1,2}, {3,4}} )

Pokud potřebuji vytvořit známý počet sloupců (např. 100), kdy potřebujete mít pouze hodnoty, bez konkrétních záhlaví u názvu sloupce, můžete použít tuto syntaxi.

=#table(2, // Počet sloupců – následně obecné názvy sloupců { {1, 2}, // hodnoty pro první řádek {3, 4} // hodnoty pro druhý řádek } )

Pokud nevíte počet sloupců, i tohle funkce umí... místo čísla zadáte null ...

=#table(null, // pokud nevím počet sloupců { {1, 2}, // hodnoty pro první řádek {3, 4} // hodnoty pro druhý řádek } )

Prázdná tabulka

= #table(null, {})

Pokud je zadán chybný počet položek v řádku

= #table(null, // Počet sloupců – následně obecné názvy sloupců { {1, 2}, // hodnoty pro první řádek {3, 4, 5} // hodnoty pro druhý řádek chybný počet } )

VERZE 3 – Používání typů a názvů sloupců

S touto verzí můžete definovat nejen názvy sloupců a odpovídající hodnoty, ale také datové typy jednotlivých sloupců.

#table( typ table [A = number, B = text], {{1,"jedna"}, {2,"dva"}, {3,"tři"}} )

Rozebereme si ukázku:

=#table( type table [ A = number, B = text], // Názvy a typy sloupců { {1,"jedna"}, // řádek jedna {2,"dva"}, // řádek dvě {3,"tři"} // řádek tři } )

Tabulka třeba s aktuálním časem

= #table(type table[#"Poslední Aktualizace"=datetime], {{DateTime.LocalNow()}})

Tabulka definované sloupce

= #table( type table [ #"Number Column"=number, // číslo #"Text Column"=text, // text #"Date Column"=date // datum ], { {1, "Pavel", #date(2022,11,11)}, {2, "Lasak", #date(2022,12,12)} } )

V přípravě

...

Funkci z listu Table.FromList()

Další možností, jak vytvořit tabulku je využít listu (seznamu, vektoru), a tento převést na tabulku.

Využijeme funkci Table.FromList, která má syntaxi:

• Table.FromList(list as list, optional splitter as nullable function, optional columns as any, optional default as any, optional extraValues as nullable number) as table

Syntaxe Table.FromList() jinak

// přepsaná syntaxe = Table.FromList( list as list, optional splitter as nullable function, optional columns as any, optional default as any, optional extraValues as nullable number) as table

Praktické ukázky

Prakticky převést seznam písmen na tabulku:

= Table.FromList({"A", "B", "C", "D", "E"}, null, {"Písmena"})

Vytvoří tabulku jen název sloupce bude Column1:

= Table.FromList({"A", "B", "C", "D", "E"})

Chyba, tabulku nevytvoří, jen čísla, musí být hodnoty (v uvozovkách):

= Table.FromList({ 1, 2 }) // Chyba

Tabulku již vytvoří hodnoty jsou v uvozovkách:

= Table.FromList({ "1", "2" }) // Zobrazí tabulku

Datový typ text

= Table.FromList({ "Pavel", "Petr" }, null, type table[ Jmeno = Text.Type ] )

Datový typ číslo

= Table.FromList({ "1", "2" }, null, type table[ Cislo = Number.Type ] )

Tvorba tabulky bez udání oddělovače

= Table.FromList({"A B C","D E F"}) //první radek jeden sloupce „A B C“ //druhy radek jeden sloupce „D E F“

Tvorba tabulky s udáním oddělovače mezera:

= Table.FromList({"A B C","D E F"},Splitter.SplitTextByDelimiter(" ")) //první radek 3 sloupce „A“, „B“, „C“ //druhy radek 3 sloupce „D“, „E“, „F“

Tvorba tabulky s udáním oddělovače - žádný ;)

= Table.FromList({"A,B,C","D,E,F"},Splitter.SplitByNothing()) //první radek 3 sloupce „A“, „B“, „C“ //druhy radek 3 sloupce „D“, „E“, „F“

Počet znaku místo oddělovače

= Table.FromList({"ABCD","EFG","HI"}, Splitter.SplitTextByRepeatedLengths(1)) //první radek 4 sloupce A B C D //druhy radek 4 sloupce E F G null //treti radek 4 sloupce H I null null

Počet znaku místo oddělovače, ale v datech různé jiné počty hodnot

= Table.FromList({"ABC","EFGH","I"}, Splitter.SplitTextByRepeatedLengths(1)) //první radek 3 sloupce „A“, „B“, „C“ //druhy radek 3 sloupce „Error“, „Error“, „Error“ //třetí radek 3 sloupce „I“, „null“ , „null“

Počet znaku, pro každý sloupec jiný

= Table.FromList({"110100100010000"}, Splitter.SplitTextByPositions({0,1,3,6,10}),{"Jednoty", "Desitky", "Stovky", "Tisíc", "Deset_tisíc"})

Další ukázka A

= Table.FromList({"A,B,C","D,E", "F,G,H,I"}) //první radek 3 sloupce „A“, „B“, „C“ //druhy radek 3 sloupce „D“, „E“, „“ //třetí radek 3 sloupce „Error“, „Error“, „Error“

Další ukázka B

= Table.FromList({"A,B,C,D","E", "F,G,H"}) //první radek 4 sloupce „A“, „B“, „C“, „D“ //druhy radek 4 sloupce „E“, „“, „“, „“ //třetí radek 4 sloupce „F“, „G“, „H“ , „“

Písmeno

= Table.FromList({ "A", "B" }, null, { "Pismeno" })

Písmeno a typ sloupce

= Table.FromList({ "A", "B" }, null, type table[ Písmeno = Text.Type ])

V přípravě další příklady

...

Více položkové Table.FromList

Ukázka jak na vícepoložkové seznamy:

• Table.FromList(list as list, optional splitter as nullable function, optional columns as any, optional default as any, optional extraValues as nullable number) as table

Pouze názvy sloupců

= Table.FromList( { [ID = 1, Jmeno= "Pavel" ], // jako záznam (record) v listu [ID = 2, Jmeno= "Eva" ] }, Record.FieldValues, // funkce pro zpracování record (záznam) {"ID", "Jmeno"} // pouze jména sloupců )

Pouze názvy a typ sloupců:

= Table.FromList( { [ID = 1, Jmeno= "Pavel" ], // jako záznam (record) v listu [ID = 2, Jmeno= "Eva" ] }, Record.FieldValues, // funkce pro zpracování record (záznam) type table[ ProductKey = Int64.Type, Name = Text.Type ] // jména a typ hodnot ve sloupci )

Pouze názvy využívá jiné pojmenování hodnot a sloupců:

= Table.FromList( { [ x = 1, y = "A" ], [ x = 2, y = "B" ] }, Record.FieldValues, { "ID", "Pismeno" } )

Pouze názvy a typ sloupců využívá jiné pojmenování:

= Table.FromList( { [ x = 1, y = "A" ], [ x = 2, y = "B" ] }, Record.FieldValues, { "ID", "Pismeno" } type table[ ProductKey = Int64.Type, Name = Text.Type ] )

Funkci z tabulky Table.FromRecords()

Stejně jako z listu, lze vytvořit tabulku i záznamu (ač v pár ukázkách z listu byl i zárodek seznamu v předchozí kapitole). Využijeme funkci Table.FromRecords:

• Table.FromRecords(records as list, optional columns as any, optional missingField as nullable number) as table

Syntaxe v jiném zobrazení:

=Table.FromRecords( records as list, optional columns as any, optional missingField as nullable number) as table

Tabulka ze dvou záznamu o dvou polích

= Table.FromRecords( { [ ID = 1, Jméno = "Pavel" ] , // první záznam [ ID = 2, Jméno = "Lucie" ] // druhý záznam } ) // Tabulky s názvy sloupců bez typu sloupců // 1 řádek: 1 Pavel // 2 řádek: 2 Lucie

Tabulka ze dvou záznamu, kdy druhému chybí jedno pole:

= Table.FromRecords( { [ ID = 1, Jméno = "Pavel" ] , // první záznam [ ID = 2 ] // druhý záznam nemá jméno } ) // Tabulky s názvy sloupců bez typu sloupců // 1 řádek: 1 Pavel // 2 řádek: Error, Error

Tabulka ze dvou záznamu o dvou polích definovány typy sloupců

= Table.FromRecords( { [ID = 1, Jméno = "Pavel"] , // první záznam [Jméno = "Lucie", ID = 2] // druhý záznam přehozeno }, type table[ID = Int64.Type, Jméno = Text.Type] ) // Tabulky s názvy sloupců včetně typu sloupců // 1 řádek: 1 Pavel // 2 řádek: 2 Lucie

Tabulka ze dvou záznamu o dvou polích definovány typy sloupců, chybně pojmenováno.

= Table.FromRecords( { [ID = 1, Jméno = "Pavel"] , // první záznam [Jméno = "Lucie", ID = 2] // druhý záznam }, type table[ID = Int64.Type, Jmeno = Text.Type] ) // Tabulky s názvy sloupců včetně typu sloupců // 1 řádek: Error Error // 2 řádek: Error Error // Chybně uvedeno Jméno vs Jmeno

Další v přípravě

...

Vytvořit tabulku ze sloupce Table.FromColumns()

Tabulku můžete vytvořit i ze sloupce. Tato finta se může hodit pro transponování. Využijeme funkci Table.FromColumns:

• Table.FromColumns(lists as list, optional columns as any) as table

Syntaxe jinak zobrazená:

= Table.FromColumns( lists as list, optional columns as any) as table

Poznámka: Může být použito k transponování tabulek.

Prakticky

Sloupec čísel na řádek čísel

// obecné názvy sloupců Column1, … = Table.FromColumns({ {1}, {2}, {3} })

Sloupec hodnot na řádek včetně pojmenování sloupců

= Table.FromColumns({{1},{"Pavel"},{"42"}},{"ID","Jméno","Věk"})

Sloupce na řádky

=Table.FromColumns({ {1, "Pavel", 42}, // první sloupec {2, "Eva", 77}, // druhý sloupec {3, "Iva", 1} // třetí sloupec }) // Výsledek // první řádek 1,2,3 // Druhý řádek Pavel, Eva, Iva // Třetí řádek 42, 77, 1

Sloupce na řádky, včetně pojmenování sloupců

= Table.FromColumns({ {1, "Pavel", 42}, // první sloupec {2, "Eva", 77}, // druhý sloupec {3, "Iva", 1} // třetí sloupec }, { "Sl_1", "Sl_2", "Sl_3" } )

Sloupce na řádky, včetně pojmenování sloupců a typu sloupce

= Table.FromColumns({ {1, 2, 3}, // první sloupec {"Pavel", "Eva", "Iva"}, // druhý sloupec {33.3, 44.44, 42} // třetí sloupec }, type table[ ID = Int64.Type, Jméno = Text.Type, Vek = Number.Type] ) // Pro datum Date.Type

Sloupce na řádky, včetně pojmenování sloupců, jen chybné pojmenování 2 sloupce stejný název

= Table.FromColumns({ {1, "Pavel", 42}, // první sloupec {2, "Eva", 77}, // druhý sloupec {3, "Iva", 1} // třetí sloupec }, { "Sl_1", "Sl_2", "Sl_2" } )

Další v přípravě

....

Tabulka z hodnoty - Table.FromValue()

Tabulku lze vytvořit i z hodnoty, využitím funkce Table.FromValue

• Table.FromValue(value as any, optional options as nullable record) as table

Syntaxe:

= Table.FromValue( value as any, optional options as nullable record) as table

Nejjednodušší tabulka s jednou hodnotou:

// obecný název sloupce Value = Table.FromValue( 1 ) // Returns a 1 column table of type number

Nejjednodušší tabulka s jednou hodnotou a názvem sloupce:

= Table.FromValue("A", [DefaultColumnName = "Znak" ])

Nejjednodušší tabulka s jednou hodnotou a názvem sloupce

= Table.FromValue(1, [DefaultColumnName = "Číslo" ])

Nejjednodušší tabulka s jednou hodnotou a názvem sloupce (Logická)

= Table.FromValue({true}, [DefaultColumnName = "Pravda/Lež" ] ) //hodnota: true

Dvě hodnoty ve sloupci

= Table.FromValue( { 1, 2 } ) // Ve sloupci 1 a 2

Dva sloupce

= Table.FromValue( [1 = "Pavel"] ) //řádek 1: 1, Pavel

Dva sloupce, dva řádky

= Table.FromValue([1 = "Pavel", 2 = "Lasák" ]) //řádek 1: 1, Pavel //řádek 2: 2, Lasák

Dva záznamy (record)

= Table.FromValue( { [ ID = 1, Jmeno = "Pavel" ], [ ID = 2, Jmeno = "Lucie" ] } ) // První sloupec Name, druhý sloupec Value //řádek 1 záznam: [1, Pavel] //řádek 2 záznam: [2, Lucie]

Dva seznamy (list, vektor)

= Table.FromValue( { {"ID", 1 } , {"ID", 2 } } ) //řádek 1 list: {1, Pavel} //řádek 2 list: {2, Lucie}

V přípravě

....

Tabulka z řádku - Table.FromRows()

Vytvořit tabulku z řádku, lze využít funkci Table.FromRows:

• Table.FromRows(rows as list, optional columns as any) as table

Syntaxe

= Table.FromRows( rows as list, optional columns as any) as table

Jeden sloupec jeden řádek jednička

= Table.FromRows({{1}})

Dva sloupce, jeden řádek

= Table.FromRows({{1, "Apple"}})

Dva sloupce, dva řádky

= Table.FromRows( { {1, "Pavel"}, // první_řádek {2, "Lasák"} // druhý_řádek } ) //Názvy sloupců: Column1, Column2 //řádek 1: 1, Pavel //řádek 2: 2, Lasák

Dva sloupce, dva řádky

= Table.FromRows( { {1, "Pavel"}, {2, "Lasák"} }, 2 ) //Názvy sloupců: Column1, Column2 //řádek 1: 1, Pavel //řádek 2: 2, Lasák

Dva sloupce, dva řádky

//Chyba počet sloupců 3 ale data pro dva! = Table.FromRows( { {1, "Pavel"}, {2, "Lasák"} }, 3 )

Dva sloupce, dva řádky – jména sloupců

= Table.FromRows( { {1, " Pavel "}, {2, " Lasák "} }, {"ID", "Jmena"} ) //Názvy sloupců: ID, Jmena //řádek 1: 1, Pavel //řádek 2: 2, Lasák

Dva sloupce, dva řádky – jména a typy sloupců

= Table.FromRows( { {1, " Pavel "}, {2, " Lasák "} }, type table[ ID = Int64.Type, Jmena = Text.Type ] ) //Názvy sloupců: ID (typ číslo), Jmena (typ text) //řádek 1: 1, Pavel //řádek 2: 2, Lasák

V přípravě

....

Operace s tabulkami

V této kapitole se podíváme na operace s tabulkami. Především:

• Porovnávání tabulek
• Slučování tabulek

Porovnávání tabulek

Pokud potřebujete porovnat, zda se dvě tabulky rovnají, lze využít znaménko rovná se:

Praktické ukázky

Pokud se tabulky rovnají

// Rovnají se #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true

Pokud se tabulky nerovnají

// Nerovnají se #table({"A","B"},{{1,2}}) <> #table({"B","A"},{{2,1}}) // false

Pokud se tabulky nerovnají, druhá tabulka dva řádky

#table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}, {3,4}}) // false

Pokud se tabulky nerovnají, ale vložím <> získám pravdu

#table({"A","B"},{{1,2}}) <> #table({"B","A"},{{2,1}, {3,4}}) // true

Pokud se tabulky rovnají

#table({"Col1"}, {{1}, {2}}) = #table({"Col1"}, {{1}, {2}}) // true

Tabulky se rovnají ale dotaz <>

#table({"Col1"}, {{1}, {2}}) <> #table({"Col1"}, {{1}, {2}}) // false

Tabulky se nerovnají druhý řádek (záznam) mají jiné pořadí

#table({"Col1", "Col2"}, {{"A", "B"}, {1,2}, {3,4}}) = #table({"Col2", "Col1"}, {{"B", "A"}, {2,1}, {4,3}}) // true

Tabulky se nerovnají je přehozeno pořadí řádku (pokud se řádky seřadí mohou se následně rovnat)

#table({"Col1"}, {{1}, {2}}) = #table({"Col1"}, {{2}, {1}}) // false--

Porovnávání dvou tabulek – nerozlišuje typ, využitím M-kódu a více řádku

let Table1 = Table.TransformColumnTypes(#table({"Col1"}, {{1}}),{{"Col1", type any}}), Table2 = Table.TransformColumnTypes(#table({"Col1"}, {{1}}),{{"Col1", type number}}) in Table1 = Table2 //

V přípravě

....

Slučování tabulek

Stejně jako listy (seznamy, vektory) a record (záznamy) můžete slučovat i tabulky využitím znaku &

Praktické ukázky

Sloučení dvou tabulek

#table({"ID", "Jmeno"}, {{1, "Pavel"}}) & #table({"ID", "Jmeno"}, {{2, "Lasák"}}) //Názvy sloupců: ID, Jmena //řádek 1: 1, Pavel //řádek 2: 2, Lasák

Sloučení dvou tabulek různé názvy sloupců

=#table({"ID"}, {{1}}) & #table({"Jméno"}, {{"Pavel"}}) //Názvy sloupců: ID, Jmeno //řádek 1: 1, null //řádek 2: null, Pavel

Sloučení dvou tabulek různé typy sloupců

= #table({"Vek"}, {{18}}) & #table({"Vek"}, {{"21"}}) //Názvy sloupců: Vek (typ - ABC123) //řádek 1: 18 //řádek 2: 21

Práce s tabulkou – výběr – řádek- sloupec- hodnota

V této kapitole se podíváme z tabulky získat:

• Požadovaný řádek
• Požadovaný sloupec
• Buňku (průsečík řádku a sloupce)
• Více sloupců
• Více buněk

Pojďme na to prakticky:

Z tabulky získat požadovaný sloupec

K získání sloupce můžeme využít hranaté závorky [] a do nich zadat jméno/název sloupce, který chcete získat (výsledkem bude list neboli česky seznam):

Chci z tabulky sloupec A – název existuje

= #table({"A","B"},{{1,2},{3,4}})[A] // vrátí seznam (list, vektor) // Sloupec {1 ,3}

Chci z tabulky sloupec C – název neexistuje

// Pokud název požadovaného sloupce neexistuje obdržíte chybu = #table({"A","B"},{{1,2},{3,4}})[C]

Chci z tabulky sloupec C – název neexistuje – ošetření

// Pokud název požadovaného sloupce neexistuje a za []_? dáte otazník // Místo chyb obdržíte hodnotu null = #table({"A","B"},{{1,2},{3,4}})[C]? // null

Kontrola

// Kontrola, že výstupem je list = Value.Is(#table({"A","B"},{{1,2}})[A], type list)

Z tabulky získat požadovaný Řádek

K získání řádku můžeme využít složené závorky {} a do nich zadat číslo řádku, který chcete získat. Pozor začíná se číslovat od nuly, takže první řádek má číslo 0 (nula - zero, neplést s null). Výsledkem bude record neboli česky záznam):

Chci z tabulky první řádek – řádek existuje

= #table({"A","B"},{{1,2}, {3,4}}){0} // vrátí record (záznam) // [A = 1] // [B = 2]

Chci z tabulky pátý řádek – řádek neexistuje

= #table({"A","B"},{{1,2}, {3,4}}){4} // Chyba

Chci z tabulky pátý řádek – řádek neexistuje – ošetření

Počítáte-li s tím, že požadovaný řádek nemusí existovat a nechcete ať provádějí dotazů skončí chybou, můžete využít otazník, vrátí se null

= #table({"A","B"},{{1,2}, {3,4}}){4}? // null

Kontrola

=Value.Is(#table({"A","B"},{{1,2}, {3,4}}){1}, type record) // true

V přípravě

....

Z tabulky získat požadovanou hodnotu (buňka)

Potřebujete-li z tabulky získat konkrétní hodnotu, assi vás napadne spojit [] s {} a jste na správné cestě.

Na pořadí zda vyberete nejprve řádek a pak sloupec nebo nejprve sloupec a pak řádek nezáleží, výsledek je stejný.

Chci z tabulky první řádek a hodnotu ze sloupce „A“– řádek i sloupec existuje

= #table({"A","B"},{{1,2}, {3,4}})[A]{0}

Chci z tabulky první řádek a hodnotu ze sloupce „A“– řádek i sloupec existuje

= #table({"A","B"},{{1,2}, {3,4}}){0}[A]

Chci z tabulky první řádek a hodnotu ze sloupce „C“– řádek existuje sloupec neexistuje

= #table({"A","B"},{{1,2}, {3,4}})[C]{0}

Chci z tabulky první řádek a hodnotu ze sloupce „C“– řádek existuje sloupec neexistuje – ošetření

// opět chyba protože neexistující sloupce vrací null = #table({"A","B"},{{1,2}, {3,4}})[C]?{0}

Chci z tabulky první řádek a hodnotu ze sloupce „C“– řádek existuje sloupec neexistuje – ošetření

// opět chyba protože neexistující sloupec vrací chybu – tak kontrola zda řádek existuje je zbytečná = #table({"A","B"},{{1,2}, {3,4}})[C]{0}?

Chci z tabulky první řádek a hodnotu ze sloupce „C“– řádek existuje sloupec neexistuje – ošetření

= #table({"A","B"},{{1,2}, {3,4}})[C]?{0}? // funkční výsledek null

Z tabulky získat více sloupců

Z tabulky lze ziskat i více sloupců

Potřebuji sloupec C a A:

= #table({"A","B","C"},{{1,2,3}, {4,5,6}, {7,8,9}})[[C],[A]]

Z tabulky získat více buněk

Potřebuji ze sloupce C a hodnoty na řádku 1:

= #table({"A","B","C"},{{1,2,3}, {4,5,6}, {7,8,9}})[[C],[A]]{1} //C=6 //A=4

V přípravě

Funkce pro práci s tabulkou...

Související články

S tabulkou souvisí list a recort o těchto strukturách jsem již něco sepsal:.

• List – Seznam – Vektory od A do Z
• Redord záznam od A do Z

Ke stažení

Soubor ke stažení zdarma je v přípravě. Podpořit zveřejnění můžete podporou na Patreon.

Závěrem

Narazili jste na nějaké problémy, máte tip na vylepšení nebo doplnění článku, můžete se zmínit v komentářích.

Článek byl aktualizován: 21.03.2024 18:32

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ář.