Knihovna Pandas: použití metody groupby, naformátování a export tabulek pro tisk

Obsah

1. Zpracování a agregace údajů s využitím metody groupby

2. Načtení datového souboru

3. Rozdělení záznamů metodou groupby s agregací výsledků

4. Pokus o seřazení jazyků podle celkového počtu vítězství

5. Přejmenování vybraného sloupce či sloupců v agregovaném datovém rámci

6. Seřazení jazyků sestupně

7. Další možnosti nabízené operací groupby

8. Naformátování tabulky před jejím zobrazením na terminálu

9. Knihovna tabulate

10. Zobrazení tabulky naformátované knihovnou tabulate

11. Zobrazení naformátované tabulky s využitím formátu „pretty“

12. Naformátování tabulky napodobující psql

13. Styly (formáty) zobrazení tabulek nabízené knihovnou tabulate

14. Využití všech stylů nabízených knihovnou tabulate

15. Zobrazení tabulek naformátovaných předchozím demonstračním příkladem

16. Alternativní způsob získání jmen všech formátů

17. Obsah následujícího článku

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

19. Odkazy na předchozí části seriálu o knihovně Pandas

20. Odkazy na Internetu

1. Zpracování a agregace údajů s využitím metody groupby

V první polovině dnešního článku si popíšeme způsob zpracování a agregace údajů v datových rámcích s využitím metody pojmenované groupby. Jedná se o metodu, která umožňuje údaje z datových rámců rozdělit do skupin s tím, že se údaje z každé skupiny nějakým způsobem agregují; například se zjistí jejich počet, součet hodnot ve vybraném sloupci atd. Současně si ukážeme i další užitečné metody, například sort_values, rename, count apod.

Zpracovávat přitom budeme tabulku obsahující vybrané vítězné programovací jazyky pro daný kalendářní rok:

Year    Winner
2019    C
2018    Python
2017    C
2016    Go
2015    Java
2014    JavaScript
2013    Transact-SQL
2012    Objective-C
2011    Objective-C
2010    Python
2009    Go
2008    C
2007    Python
2006    Ruby
2005    Java
2004    PHP
2003    C++

2. Načtení datového souboru

Datový soubor s informacemi o vítězných programovacích jazycích používá formát TSV (Tab-Separated Values). Z tohoto důvodu můžeme pro jeho načtení a konverzi do datového rámce použít funkci read_csv s explicitním nastavením oddělovače buněk, kterým je řídicí znak „\t“. Následně určíme, který sloupec se má převést na index a obsah datového rámce vytiskneme společně s podrobnějšími informacemi o tomto rámci:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
print(df.info())

Tabulka s obsahem datového rámce vypadá takto:

            Winner
Year
2019             C
2018        Python
2017             C
2016            Go
2015          Java
2014    JavaScript
2013  Transact-SQL
2012   Objective-C
2011   Objective-C
2010        Python
2009            Go
2008             C
2007        Python
2006          Ruby
2005          Java
2004           PHP
2003           C++

Podrobnější informace o datovém rámci:

<class 'pandas.core.frame.DataFrame'>
Int64Index: 17 entries, 2019 to 2003
Data columns (total 1 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   Winner  17 non-null     object
dtypes: object(1)
memory usage: 272.0+ bytes
None

3. Rozdělení záznamů metodou groupby s agregací výsledků

Metoda groupby nám umožňuje provést následující operace:

1. Rozdělení údajů v datovém rámci na základě podmínky
2. Aplikace funkce na výsledný datový blok
3. Kombinace či agregace výsledků

Příkladem může být vytvoření nového datového rámce, který bude pro každý programovací jazyk obsahovat počet let, v nichž tento jazyk zvítězil (resp. kdy byl vybrán). Jazyky tedy rozdělíme podle jejich jména (sloupec „Winner“):

# rozdělení do skupin
gb = df.groupby(["Winner"])

Výsledkem bude nový datový blok (ale ne datový rámec), nad nímž můžeme provádět další operace, zejména agregaci. Můžeme například zjistit, kolikrát se každý jazyk ve své skupině vyskytuje. Vybereme tedy (jediný) sloupec „Winner“ a pro celou skupinu zavoláme metodu count:

# agregace výsledků
result = gb[["Winner"]].count()

Výsledek je ve formě datového rámce, který lze zobrazit či dále zpracovat:

# zobrazení výsledků
print(result)

Úplný zdrojový kód dnešního druhého demonstračního příkladu vypadá následovně:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# zobrazení výsledků
print(result)

S výsledkem:

            Winner
Year
2019             C
2018        Python
2017             C
2016            Go
2015          Java
2014    JavaScript
2013  Transact-SQL
2012   Objective-C
2011   Objective-C
2010        Python
2009            Go
2008             C
2007        Python
2006          Ruby
2005          Java
2004           PHP
2003           C++
 
              Winner
Winner
C                  3
C++                1
Go                 2
Java               2
JavaScript         1
Objective-C        2
PHP                1
Python             3
Ruby               1
Transact-SQL       1

4. Pokus o seřazení jazyků podle celkového počtu vítězství

V předchozím příkladu nebyly jazyky seřazeny podle počtu vítězství, ale abecedně. Ovšem vzhledem k tomu, že výsledkem agregace je běžný datový rámec, můžeme seřazení provést metodou sort_values, v níž navíc určíme, že se má seřazení provést přímo v rámci daného datového rámce (tedy nikoli tak, že se vrátí nový datový rámec, což je sice čistší řešení, ovšem u větších paměťových rámců je časově i paměťově náročnější):

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# pokusíme se o seřazení hodnot podle jediného sloupce
result.sort_values(by=["Winner"], inplace=True)
 
# zobrazení výsledků
print(result)

Výsledek ovšem nebude odpovídat očekávání:

            Winner
Year
2019             C
2018        Python
2017             C
2016            Go
2015          Java
2014    JavaScript
2013  Transact-SQL
2012   Objective-C
2011   Objective-C
2010        Python
2009            Go
2008             C
2007        Python
2006          Ruby
2005          Java
2004           PHP
2003           C++
 
Traceback (most recent call last):
  File "data_frame_group_by_03_try_to_sort.py", line 23, in <module>
    result.sort_values(by=["Winner"], inplace=True)
  File "/home/ptisnovs/.local/lib/python3.6/site-packages/pandas/core/frame.py", line 5298, in sort_values
    k = self._get_label_or_level_values(by, axis=axis)
  File "/home/ptisnovs/.local/lib/python3.6/site-packages/pandas/core/generic.py", line 1558, in _get_label_or_level_values
    self._check_label_or_level_ambiguity(key, axis=axis)
  File "/home/ptisnovs/.local/lib/python3.6/site-packages/pandas/core/generic.py", line 1518, in _check_label_or_level_ambiguity
    raise ValueError(msg)
ValueError: 'Winner' is both an index level and a column label, which is ambiguous.

5. Přejmenování vybraného sloupce či sloupců v agregovaném datovém rámci

Nezávisle na tom, jak je pojmenovaný index (a zda se náhodou nejmenuje stejně jako nějaký sloupec) můžeme provést přejmenování vybraného sloupce metodou rename. U této metody lze rovněž specifikovat, zda má být výsledkem nový datový rámec či zda se má modifikovat ten rámec, jehož metoda se volá. Sloupec či sloupce, které se mají přejmenovat, se zapisují formou slovníku, kde klíčem je původní jméno sloupce a hodnotou nové jméno:

# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)

Takto upravený demonstrační příklad by již měl být plně funkční:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků
result.sort_values(by=["Language"], inplace=True)
 
# zobrazení výsledků
print(result)

Výsledek získaný po spuštění tohoto příkladu:

            Winner
Year
2019             C
2018        Python
2017             C
2016            Go
2015          Java
2014    JavaScript
2013  Transact-SQL
2012   Objective-C
2011   Objective-C
2010        Python
2009            Go
2008             C
2007        Python
2006          Ruby
2005          Java
2004           PHP
2003           C++

Povšimněte si, že nyní jsou již jazyky seřazeny podle počtu vítězství:

              Language
Winner
C++                  1
JavaScript           1
PHP                  1
Ruby                 1
Transact-SQL         1
Go                   2
Java                 2
Objective-C          2
C                    3
Python               3

6. Seřazení jazyků sestupně

Pochopitelně je možné jazyky seřadit i sestupně, což je praktičtější. K tomuto účelu opět použijeme metodu sort_values, ovšem navíc uvedeme i nepovinný parametr ascending nastavený na hodnotu False:

result.sort_values(by=["Language"], inplace=True, ascending=False)

Úplný zdrojový kód takto upraveného demonstračního příkladu:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků v opačném pořadí (od nejlepšího)
result.sort_values(by=["Language"], inplace=True, ascending=False)
 
# zobrazení výsledků
print(result)

Nyní již bude tabulka vítězů sestavena podle očekávání:

            Winner
Year
2019             C
2018        Python
2017             C
2016            Go
2015          Java
2014    JavaScript
2013  Transact-SQL
2012   Objective-C
2011   Objective-C
2010        Python
2009            Go
2008             C
2007        Python
2006          Ruby
2005          Java
2004           PHP
2003           C++
 
              Language
Winner
C                    3
Python               3
Go                   2
Java                 2
Objective-C          2
C++                  1
JavaScript           1
PHP                  1
Ruby                 1
Transact-SQL         1

7. Další možnosti nabízené operací groupby

Výsledná struktura vrácená operací groupby ve skutečnosti umožňuje nad daty provádět i další operace, zejména jejich transformaci, popř. filtraci, což si ukážeme mj. i příště. Totéž platí i pro rozdělení záznamů podle většího množství kritérií. Vytvořené skupiny je taktéž možné zobrazit:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
import pprint
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df)
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# zobrazení skupin
pprint.pprint(gb.groups)

Výsledek:

{'C': Int64Index([2019, 2017, 2008], dtype='int64', name='Year'),
 'C++': Int64Index([2003], dtype='int64', name='Year'),
 'Go': Int64Index([2016, 2009], dtype='int64', name='Year'),
 'Java': Int64Index([2015, 2005], dtype='int64', name='Year'),
 'JavaScript': Int64Index([2014], dtype='int64', name='Year'),
 'Objective-C': Int64Index([2012, 2011], dtype='int64', name='Year'),
 'PHP': Int64Index([2004], dtype='int64', name='Year'),
 'Python': Int64Index([2018, 2010, 2007], dtype='int64', name='Year'),
 'Ruby': Int64Index([2006], dtype='int64', name='Year'),
 'Transact-SQL': Int64Index([2013], dtype='int64', name='Year')}

8. Naformátování tabulky před jejím zobrazením na terminálu

Komplikovanější tabulky je vhodné před jejich zobrazením na terminálu naformátovat, popř. zvýraznit jejich okraje i okraje buněk. K tomu lze použít například metodu to_markdown. Pro export do dalších formátů pak slouží metody to_html, to_json, to_latex a to_csv. Ukažme si nejprve použití první zmíněné metody, která tabulku naformátuje takovým způsobem, aby ji bylo možné zařadit do nástrojů zpracovávajících rozšířený Markdown (protože vlastní Markdown tabulky nepodporuje):

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(df.to_markdown())
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků
result.sort_values(by=["Language"], inplace=True, ascending=False)
 
# zobrazení výsledků
print(result.to_markdown())

Výsledek by měl vypadat následovně:

|   Year | Winner       |
|-------:|:-------------|
|   2019 | C            |
|   2018 | Python       |
|   2017 | C            |
|   2016 | Go           |
|   2015 | Java         |
|   2014 | JavaScript   |
|   2013 | Transact-SQL |
|   2012 | Objective-C  |
|   2011 | Objective-C  |
|   2010 | Python       |
|   2009 | Go           |
|   2008 | C            |
|   2007 | Python       |
|   2006 | Ruby         |
|   2005 | Java         |
|   2004 | PHP          |
|   2003 | C++          |
 
| Winner       |   Language |
|:-------------|-----------:|
| C            |          3 |
| Python       |          3 |
| Go           |          2 |
| Java         |          2 |
| Objective-C  |          2 |
| C++          |          1 |
| JavaScript   |          1 |
| PHP          |          1 |
| Ruby         |          1 |
| Transact-SQL |          1 |

Traceback (most recent call last):
  File "data_frame_to_markdown.py", line 13, in <module>
    print(df.to_markdown())
  File "/home/ptisnovs/.local/lib/python3.6/site-packages/pandas/core/frame.py", line 2261, in to_markdown
    tabulate = import_optional_dependency("tabulate")
  File "/home/ptisnovs/.local/lib/python3.6/site-packages/pandas/compat/_optional.py", line 110, in import_optional_dependency
    raise ImportError(msg) from None
ImportError: Missing optional dependency 'tabulate'.  Use pip or conda to install tabulate.

9. Knihovna tabulate

Pro zobrazení tabulek s využitím různých formátovacích pravidel (resp. stylů) lze použít knihovnu nazvanou příznačně tabulate, jejíž repositář je dostupný na adrese https://github.com/astanin/python-tabulate. Tato knihovna dokáže naformátovat datové rámce z knihovny Pandas, ovšem dokáže pracovat například i s n-dimenzionálními poli z Numpy atd. Cílem knihovny je poskytnout formáty tabulek pro zobrazení na terminálech (s pevnými šířkami znaků), ovšem přidány byly i styly pro export tabulek do Markdownu, LaTeXu atd. – viz navazující kapitoly.

Instalace této malé knihovny (tvořené jediným zdrojovým souborem) je snadná:

$ pip3 install --user tabulate
 
Collecting tabulate
  Downloading https://files.pythonhosted.org/packages/c4/f4/770ae9385990f5a19a91431163d262182d3203662ea2b5739d0fcfc080f1/tabulate-0.8.7-py3-none-any.whl
Installing collected packages: tabulate
Successfully installed tabulate-0.8.7

Možnosti této knihovny budou ukázány v navazujících kapitolách.

10. Zobrazení tabulky naformátované knihovnou tabulate

Podívejme se nyní na způsob zobrazení naformátované tabulky s využitím knihovny tabulate. Ve skutečnosti je to snadné. Po importu této knihovny je pouze nutné namísto přímého vytištění datového rámce zavolat funkci tabulate a předat jí příslušný datový rámec:

print(tabulate(df))

Navíc je možné určit, jak se mají zobrazit hlavičky sloupců:

print(tabulate(df, headers="keys"))

Předchozí demonstrační příklad nyní upravíme tak, aby se zobrazily naformátované tabulky:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
from tabulate import tabulate
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(tabulate(df, headers="keys"))
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků
result.sort_values(by=["Language"], inplace=True, ascending=False)
 
# zobrazení výsledků
print(tabulate(result, headers="keys"))

S tímto výsledkem:

  Year  Winner
------  ------------
  2019  C
  2018  Python
  2017  C
  2016  Go
  2015  Java
  2014  JavaScript
  2013  Transact-SQL
  2012  Objective-C
  2011  Objective-C
  2010  Python
  2009  Go
  2008  C
  2007  Python
  2006  Ruby
  2005  Java
  2004  PHP
  2003  C++
 
Winner          Language
------------  ----------
C                      3
Python                 3
Go                     2
Java                   2
Objective-C            2
C++                    1
JavaScript             1
PHP                    1
Ruby                   1
Transact-SQL           1

11. Zobrazení naformátované tabulky s využitím formátu „pretty“

Knihovna tabulate nabízí programátorům přibližně dvacet způsobů naformátování tabulky při jejím tisku. Formát tabulky se volí nepovinným parametrem tablefmt:

tabulate(datový_rámec, headers="keys", tablefmt=jméno_formátu)

Příkladem může být použití formátu nazvaného „pretty“:

tabulate(datový_rámec, headers="keys", tablefmt="pretty")

Předchozí demonstrační příklad lze tedy upravit takovým způsobem, aby zobrazil tabulku v odlišném formátu:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
from tabulate import tabulate
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(tabulate(df, headers="keys", tablefmt="pretty"))
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků
result.sort_values(by=["Language"], inplace=True, ascending=False)
 
# zobrazení výsledků
print(tabulate(result, headers="keys", tablefmt="pretty"))

Po spuštění tohoto demonstračního příkladu by se měla zobrazit dvojice tabulek v následujícím formátu (mj. kompatibilním i s hloupými „ASCII-only“ zařízeními):

+------+--------------+
| Year |    Winner    |
+------+--------------+
| 2019 |      C       |
| 2018 |    Python    |
| 2017 |      C       |
| 2016 |      Go      |
| 2015 |     Java     |
| 2014 |  JavaScript  |
| 2013 | Transact-SQL |
| 2012 | Objective-C  |
| 2011 | Objective-C  |
| 2010 |    Python    |
| 2009 |      Go      |
| 2008 |      C       |
| 2007 |    Python    |
| 2006 |     Ruby     |
| 2005 |     Java     |
| 2004 |     PHP      |
| 2003 |     C++      |
+------+--------------+
 
+--------------+----------+
|    Winner    | Language |
+--------------+----------+
|      C       |    3     |
|    Python    |    3     |
|      Go      |    2     |
|     Java     |    2     |
| Objective-C  |    2     |
|     C++      |    1     |
|  JavaScript  |    1     |
|     PHP      |    1     |
|     Ruby     |    1     |
| Transact-SQL |    1     |
+--------------+----------+

12. Naformátování tabulky napodobující psql

Velmi přehledným způsobem je obsah tabulek formátován nástrojem psql, což je terminálové rozhraní ke známé relační databázi PostgreSQL. Tento formát je možné napodobit následovně:

tabulate(datový_rámec, headers="keys", tablefmt="psql")

Předchozí demonstrační příklad si upravíme pro použití tohoto stylu zobrazení tabulek:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
from tabulate import tabulate
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("hall_of_fame.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Year
df.set_index("Year", inplace=True)
 
# datový rámec zobrazíme
print(tabulate(df, headers="keys", tablefmt="psql"))
print()
 
# rozdělení do skupin
gb = df.groupby(["Winner"])
 
# agregace výsledků
result = gb[["Winner"]].count()
 
# přejmenování sloupce
result.rename(columns={"Winner": "Language"}, inplace=True)
 
# seřazení výsledků
result.sort_values(by=["Language"], inplace=True, ascending=False)
 
# zobrazení výsledků
print(tabulate(result, headers="keys", tablefmt="psql"))

Výsledek získaný po spuštění tohoto demonstračního příkladu nyní bude vypadat následovně:

+--------+--------------+
|   Year | Winner       |
|--------+--------------|
|   2019 | C            |
|   2018 | Python       |
|   2017 | C            |
|   2016 | Go           |
|   2015 | Java         |
|   2014 | JavaScript   |
|   2013 | Transact-SQL |
|   2012 | Objective-C  |
|   2011 | Objective-C  |
|   2010 | Python       |
|   2009 | Go           |
|   2008 | C            |
|   2007 | Python       |
|   2006 | Ruby         |
|   2005 | Java         |
|   2004 | PHP          |
|   2003 | C++          |
+--------+--------------+
 
+--------------+------------+
| Winner       |   Language |
|--------------+------------|
| C            |          3 |
| Python       |          3 |
| Go           |          2 |
| Java         |          2 |
| Objective-C  |          2 |
| C++          |          1 |
| JavaScript   |          1 |
| PHP          |          1 |
| Ruby         |          1 |
| Transact-SQL |          1 |
+--------------+------------+

13. Styly (formáty) zobrazení tabulek nabízené knihovnou tabulate

Knihovna tabulate nabízí uživatelům poměrně širokou škálu formátů tabulek. Některé z těchto formátů jsou určeny pro zobrazení tabulky na terminálu, další pak pro zařazení tabulky do různých dokumentů zapsaných ve formátech Markdown, RST, HTML, různé formy Wiki či LaTeX:

import tabulate
 
for fmt in tabulate._table_formats:
    print(fmt)

S výsledkem:

simple
plain
grid
fancy_grid
github
pipe
orgtbl
jira
presto
pretty
psql
rst
mediawiki
moinmoin
youtrack
html
latex
latex_raw
latex_booktabs
tsv
textile

14. Využití všech stylů nabízených knihovnou tabulate

Po spuštění následujícího demonstračního příkladu se na standardním výstupu zobrazí tabulka s obsahem datového souboru tiobe.tsv. Tabulka je přitom postupně zobrazena s využitím všech formátů, jejichž jména jsou uvedena v n-tici table_styles:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
from tabulate import tabulate
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("tiobe.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Language
df.set_index("Language", inplace=True)
 
# jména stylů
table_styles = (
        "plain",
        "simple",
        "github",
        "grid",
        "fancy_grid",
        "pipe",
        "orgtbl",
        "jira",
        "presto",
        "pretty",
        "psql",
        "rst",
        "mediawiki",
        "moinmoin",
        "youtrack",
        "html",
        "latex",
        "latex_raw",
        "latex_booktabs",
        "textile",
        "tsv"
        )
 
for table_style in table_styles:
    # oddělovač
    print()
    print("*" * 40)
    print("* {:^36s} *".format(table_style))
    print("*" * 40)
    print()
    # datový rámec zobrazíme s vybraným stylem
    print(tabulate(df, headers="keys", tablefmt=table_style))

15. Zobrazení tabulek naformátovaných předchozím demonstračním příkladem

Soubor obsahující tabulku zobrazenou s využitím všech dostupných formátů je poměrně rozsáhlý (cca 54kB), proto není zařazen přímo do textu článku. Naleznete ho na adrese https://raw.githubusercon­tent.com/tisnik/most-popular-python-libs/master/pandas/table_styles.txt.

16. Alternativní způsob získání jmen všech formátů

Ve třinácté kapitole jsme si ukázali alternativní přístup k dostupným (resp. podporovaným) formátům tabulek – jména formátů jsou klíči ve slovníku tabulate._table_formats (což je privátní hodnota!). Pokud nám nevadí, že v kódu přistupujeme k privátní hodnotě (která ani nemusí v novější verzi knihovny existovat), lze předchozí demonstrační příklad zkrátit následovně:

#!/usr/bin/env python3
# vim: set fileencoding=utf-8
 
from tabulate import tabulate, _table_formats as table_styles
import pandas
 
# přečtení zdrojových dat
df = pandas.read_csv("tiobe.tsv", sep="\t")
 
# specifikace indexu - má se získat ze sloupce Language
df.set_index("Language", inplace=True)
 
# zobrazit tabulku ve všech podporovaných formátech
for table_style in table_styles:
    # oddělovač
    print()
    print("*" * 40)
    print("* {:^36s} *".format(table_style))
    print("*" * 40)
    print()
    # datový rámec zobrazíme s vybraným stylem
    print(tabulate(df, headers="keys", tablefmt=table_style))

17. Obsah následujícího článku

V navazující části seriálu o knihovně Pandas si ukážeme použití takzvaných multiindexů, kontingenčních tabulek a rozšíříme si naše znalosti o takzvaných „oknech“, které již byly v některých demonstračních příkladech použity, ovšem bez podrobnějšího vysvětlení.

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

Zdrojové kódy všech dnes popsaných demonstračních příkladů určených pro Python 3 a nejnovější stabilní verzi knihovny Pandas byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/most-popular-python-libs. V případě, že nebudete chtít klonovat celý repositář (ten je ovšem stále velmi malý, dnes má velikost zhruba několik desítek kilobajtů), můžete namísto toho použít odkazy na jednotlivé příklady, které naleznete v následující tabulce:

Některé demonstrační příklady načítají následující soubory s daty:

19. Odkazy na předchozí části seriálu o knihovně Pandas

1. Knihovna Pandas: základy práce s datovými rámci
   https://www.root.cz/clanky/knihovna-pandas-zaklady-prace-s-datovymi-ramci/
2. Knihovna Pandas: zobrazení obsahu datových rámců, vykreslení grafů a validace dat
   https://www.root.cz/clanky/knihovna-pandas-zobrazeni-obsahu-datovych-ramcu-vykresleni-grafu-a-validace-dat/
3. Knihovna Pandas: práce s datovými řadami (series)
   https://www.root.cz/clanky/knihovna-pandas-prace-s-datovymi-radami-series/
4. Knihovna Pandas: pokročilejší práce s datovými řadami (series)
   https://www.root.cz/clanky/knihovna-pandas-pokrocilejsi-prace-s-datovymi-radami-series/
5. Knihovna Pandas: spojování datových rámců s využitím append, concat, merge a join
   https://www.root.cz/clanky/knihovna-pandas-spojovani-datovych-ramcu-s-vyuzitim-append-concat-merge-a-join/

20. Odkazy na Internetu

1. Combining Data in Pandas With merge(), .join(), and concat()
   https://realpython.com/pandas-merge-join-and-concat/
2. Repositář python-tabulate na GitHubu
   https://github.com/astanin/python-tabulate
3. python-tabulate na PyPi
   https://pypi.org/project/tabulate/
4. Understanding Pandas groupby() function
   https://www.askpython.com/python-modules/pandas/pandas-groupby-function
5. Python Pandas – GroupBy
   https://www.tutorialspoin­t.com/python_pandas/python_pan­das_groupby.htm
6. Pandas GroupBy: Group Data in Python
   https://pythonspot.com/pandas-groupby/
7. JOIN
   https://cs.wikipedia.org/wiki/JOIN
8. Plotting with matplotlib
   https://pandas.pydata.org/pandas-docs/version/0.13/visualization.html
9. Plot With Pandas: Python Data Visualization for Beginners
   https://realpython.com/pandas-plot-python/
10. Pandas Dataframe: Plot Examples with Matplotlib and Pyplot
    https://queirozf.com/entries/pandas-dataframe-plot-examples-with-matplotlib-pyplot
11. Opulent-Pandas na PyPi
    https://pypi.org/project/opulent-pandas/
12. pandas_validator na PyPi
    https://pypi.org/project/pan­das_validator/
13. pandas-validator (dokumentace)
    https://pandas-validator.readthedocs.io/en/latest/
14. 7 Best Python Libraries for Validating Data
    https://www.yeahhub.com/7-best-python-libraries-validating-data/
15. Universally unique identifier (Wikipedia)
    https://en.wikipedia.org/wi­ki/Universally_unique_iden­tifier
16. Nullable integer data type
    https://pandas.pydata.org/pandas-docs/stable/user_guide/integer_na.html
17. pandas.read_csv
    https://pandas.pydata.org/pandas-docs/stable/reference/api/pan­das.read_csv.html
18. How to define format when using pandas to_datetime?
    https://stackoverflow.com/qu­estions/36848514/how-to-define-format-when-using-pandas-to-datetime
19. Pandas : skip rows while reading csv file to a Dataframe using read_csv() in Python
    https://thispointer.com/pandas-skip-rows-while-reading-csv-file-to-a-dataframe-using-read_csv-in-python/
20. Skip rows during csv import pandas
    https://stackoverflow.com/qu­estions/20637439/skip-rows-during-csv-import-pandas
21. Denni kurz
    https://www.cnb.cz/cs/finan­cni_trhy/devizovy_trh/kur­zy_devizoveho_trhu/denni_kur­z.txt
22. UUID objects according to RFC 4122 (knihovna pro Python)
    https://docs.python.org/3­.5/library/uuid.html#uuid­.uuid4
23. Object identifier (Wikipedia)
    https://en.wikipedia.org/wi­ki/Object_identifier
24. Digital object identifier (Wikipedia)
    https://en.wikipedia.org/wi­ki/Digital_object_identifi­er
25. voluptuous na (na PyPi)
    https://pypi.python.org/py­pi/voluptuous
26. Repositář knihovny voluptuous na GitHubu
    https://github.com/alectho­mas/voluptuous
27. pytest-voluptuous 1.0.2 (na PyPi)
    https://pypi.org/project/pytest-voluptuous/
28. pytest-voluptuous (na GitHubu)
    https://github.com/F-Secure/pytest-voluptuous
29. schemagic 0.9.1 (na PyPi)
    https://pypi.python.org/py­pi/schemagic/0.9.1
30. Schemagic / Schemagic.web (na GitHubu)
    https://github.com/Mechrop­hile/schemagic
31. schema 0.6.7 (na PyPi)
    https://pypi.python.org/pypi/schema
32. schema (na GitHubu)
    https://github.com/keleshev/schema
33. XML Schema validator and data conversion library for Python
    https://github.com/brunato/xmlschema
34. xmlschema 0.9.7
    https://pypi.python.org/py­pi/xmlschema/0.9.7
35. jsonschema 2.6.0
    https://pypi.python.org/py­pi/jsonschema
36. warlock 1.3.0
    https://pypi.python.org/pypi/warlock
37. Python Virtual Environments – A Primer
    https://realpython.com/python-virtual-environments-a-primer/
38. pip 1.1 documentation: Requirements files
    https://pip.readthedocs.i­o/en/1.1/requirements.html
39. unittest.mock — mock object library
    https://docs.python.org/3­.5/library/unittest.mock.html
40. mock 2.0.0
    https://pypi.python.org/pypi/mock
41. An Introduction to Mocking in Python
    https://www.toptal.com/python/an-introduction-to-mocking-in-python
42. Unit testing (Wikipedia)
    https://en.wikipedia.org/wi­ki/Unit_testing
43. Unit testing
    https://cs.wikipedia.org/wi­ki/Unit_testing
44. Test-driven development (Wikipedia)
    https://en.wikipedia.org/wiki/Test-driven_development
45. Pip (dokumentace)
    https://pip.pypa.io/en/stable/
46. 5 Differences between clojure.spec and Schema
    https://lispcast.com/clojure.spec-vs-schema/
47. Schema: Clojure(Script) library for declarative data description and validation
    https://github.com/plumatic/schema
48. clojure.spec – Rationale and Overview
    https://clojure.org/about/spec