EDA 5: Pokročilejší manipulace a agregace

Další čtení pro dlouhé večery v tomto ročním období:

In [1]:

import pandas as pd
%matplotlib inline

Analýza dat po skupinách

Jedním ze základních postupů v datové analýze je rozdělení dat do skupin, aplikace nějaké operace na jednotlivé skupiny a nakonec kombinace výsledků do vhodného datasetu. Anglicky se tento postup označuje jako split-apply-combine. Skupiny jsou často, byť ne nutně, definovány nějakou (kategorickou) proměnnou, např. by to mohla být barva, pohlaví nebo kontinent. Skupiny lze ale vytvářet i odvozováním, např. pomocí rozsahu nebo nebo vlastností časových řad. Oboje už jsme vlastně viděli v EDA 3, kdy jsme skupiny vytvářeli pro deštivé dny nebo jednotlivé roky.

Pojďme si to vysvětlit prakticky. Použijeme k tomu hezký dataset s údaji z amerického Kongresu, který obsahuje seznam všech mužů a žen, kteří kdy v jedné z jeho komor (Sněmovně nebo Senátu) zasedli.

In [2]:

# odkaz přímo na csv soubor na internetu
LEGISLATORS_HISTORICAL_URL_CSV = (
    "https://theunitedstates.io/congress-legislators/legislators-historical.csv"
)

In [3]:

legislators_historical = pd.read_csv(
    LEGISLATORS_HISTORICAL_URL_CSV,
    usecols=["gender", "type", "state", "party", "birthday", "first_name", "last_name"],
    parse_dates=["birthday"],
)

In [4]:

legislators_historical

Out[4]:

	last_name	first_name	birthday	gender	type	state	party
0	Bassett	Richard	1745-04-02	M	sen	DE	Anti-Administration
1	Bland	Theodorick	1742-03-21	M	rep	VA	NaN
2	Burke	Aedanus	1743-06-16	M	rep	SC	NaN
3	Carroll	Daniel	1730-07-22	M	rep	MD	NaN
4	Clymer	George	1739-03-16	M	rep	PA	NaN
...	...	...	...	...	...	...	...
11978	Hunter	Duncan	1976-12-07	M	rep	CA	Republican
11979	Meadows	Mark	1959-07-28	M	rep	NC	Republican
11980	Ratcliffe	John	1965-10-20	M	rep	TX	Republican
11981	Lewis	John	1940-02-21	M	rep	GA	Democrat
11982	Graves	Tom	1970-02-03	M	rep	GA	Republican

11983 rows × 7 columns

Krok 1: Split

Na rozdělení dat do skupin slouží metoda groupby. Nejjednodušší a možná i nejčastější použití je seskupení podle existujícího sloupce v tabulce. Třeba podle type, tedy u nás konkrétně podle komory: rep je Sněmovna reprezentatntů, sen je Senát.

In [5]:

legislators_historical_by_type = legislators_historical.groupby("type")
legislators_historical_by_type

Out[5]:

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x11f8d2580>

Dostali jsme objekt typu GroupBy. Pokud vám to připomíná DatetimeIndexResampler z Explorativní analýzy a statistiky jedné proměnné, je to velice dobrá asociace. Tato operace totiž data jen rozdělila do skupin, ještě jsme ale neřekli, co s těmi skupinami chceme dělat.

Krok 2 + 3: Apply + Combine

Na skupiny, které jsme vytvořili pomocí groupby, teď můžeme aplikovat nějakou operaci. To je právě krok apply. Nemá pro nás moc cenu oddělovat tento krok od třetího kroku combine, protože když už nějakou opraci aplikujeme, tak bychom rádi výsledek sestavili do výsledného datasetu. Pandas navíc tyto kroky sám nijak neodděluje.

Pozn.: Apply a combine začne být více odděleno v nástrojích na zpracování velkých dat, které už se nevejdou pohodlně do operační paměti počítače a pandas na ně už nestačí. Apply pak probíhá po částech, třeba i distribuovaně na oddělených serverech, a výsledné combine se provádí sesbíráním částečných výsledků.

Použijeme teď jednoduchou agregační metodu count, která nám vrátí počet hodnot (po skupinách samozřejmě).

In [6]:

legislators_historical_by_type.count()

Out[6]:

	last_name	first_name	birthday	gender	state	party
type
rep	10153	10153	9662	10153	10153	9929
sen	1830	1830	1770	1830	1830	1822

Vidíme, že v datech je zaznamenáno 1830 senátorů a 10151 kongresmanů. Na levé straně v indexu vidíme skupiny, podle kterých se dataset agregoval a do sloupců se daly všechny sloupce, na které bylo možné aplikovat naši agregační funkci (v tom případě na všechny zbylé).

Z čísel si můžeš všimnout, že u některých chybí údaje o datu narození nebo straně.

Než aplikujeme krok apply, můžeme si vybrat, na který ze sloupců tak učiníme, trochu si tím zpřehledníme výstup. Pokud si vybereme jen jeden sloupec, dostaneme Series.

In [7]:

legislators_historical_by_type['party'].count()

Out[7]:

type
rep    9929
sen    1822
Name: party, dtype: int64

Tento krok si můžeme trochu zjednodušit - než abychom se doptávali na count nad jedním sloupcem v rámci agregace, můžeme se doptat na velikost každé ze skupin.

In [8]:

legislators_historical_by_type.size()

Out[8]:

type
rep    10153
sen     1830
dtype: int64

Úkol: Rozděl data podle strany (party) a vypiš počet záznamů v každé skupině. Dokážeš výsledek setřídit podle velikosti skupin?

In [ ]:

Možná sis všimla, jaký je u výsledku index. Pokud ne, nevadí, určitě si všimneš teď. Zkusíme totiž vytvořit skupiny ne z jednoho sloupce, ale ze dvou. Pojďme si rozdělit zákonodárce podle států, a každou skupinu za jeden stát ještě podle pohlaví.

In [9]:

legislators_by_state_gender_counts = legislators_historical.groupby(["state", "gender"]).count()
legislators_by_state_gender_counts

Out[9]:

		last_name	first_name	birthday	type	party
state	gender
AK	M	16	16	16	16	14
AL	F	3	3	3	3	3
AL	M	203	203	194	203	203
AR	F	5	5	5	5	5
AR	M	112	112	109	112	110
...	...	...	...	...	...	...
WI	M	197	197	197	197	197
WV	F	1	1	1	1	1
WV	M	119	119	117	119	119
WY	F	2	2	2	2	2
WY	M	38	38	38	38	38

104 rows × 5 columns

Máme tedy skupiny, které jsou definované dvojicí hodnot stát a pohlaví (state, gender). A to je přesně důvod, proč existuje v Pandas MultiIndex.

Práce s MultiIndex

Vlastnosti MultiIndexu, vlastně takového víceúrovňového či vícerozměrného indexu, můžeme prozkoumat (kromě prostého zobrazení) pomocí několika užitečných atributů (properties).

In [10]:

# počet úrovní 
legislators_by_state_gender_counts.index.nlevels

Out[10]:

In [11]:

# jména úrovní
legislators_by_state_gender_counts.index.names

Out[11]:

FrozenList(['state', 'gender'])

In [12]:

# mohutnost (počet hodnot) jednotlivých úrovní
legislators_by_state_gender_counts.index.levshape

Out[12]:

(58, 2)

In [13]:

# hodnoty v jednotlivých úrovních
legislators_by_state_gender_counts.index.levels

Out[13]:

FrozenList([['AK', 'AL', 'AR', 'AS', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'DK', 'FL', 'GA', 'GU', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OL', 'OR', 'PA', 'PI', 'PR', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VA', 'VI', 'VT', 'WA', 'WI', 'WV', 'WY'], ['F', 'M']])

Víme tedy, že náš (multi) index má dvě úrovně. Abychom dostali konkrétní řádek, musíme tím pádem zadat dvě hodnoty. K tomu nám poslouží tuple (pozor, musí to opravdu být tuple a ne list, tj. musíme použít kulaté a ne hranaté závorky).

In [14]:

legislators_by_state_gender_counts.loc[("WY", "F")]

Out[14]:

last_name     2
first_name    2
birthday      2
type          2
party         2
Name: (WY, F), dtype: int64

Co kdybychom zadali jen polovinu indexu? Dostaneme celou skupinu, v našem případě celý stát.

In [15]:

legislators_by_state_gender_counts.loc["WY"]

Out[15]:

	last_name	first_name	birthday	type	party
gender
F	2	2	2	2	2
M	38	38	38	38	38

Otázka: Jaký je index výsledné tabulky?

Pokud bychom chtěli jedno pohlaví, můžeme indexu změnit pořadí.

In [16]:

swapped_index = legislators_by_state_gender_counts.index.swaplevel(0, 1)
legislators_by_gender_state_counts = legislators_by_state_gender_counts.set_index(swapped_index)
legislators_by_gender_state_counts

Out[16]:

		last_name	first_name	birthday	type	party
gender	state
M	AK	16	16	16	16	14
F	AL	3	3	3	3	3
M	AL	203	203	194	203	203
F	AR	5	5	5	5	5
M	AR	112	112	109	112	110
	...	...	...	...	...	...
	WI	197	197	197	197	197
F	WV	1	1	1	1	1
M	WV	119	119	117	119	119
F	WY	2	2	2	2	2
M	WY	38	38	38	38	38

104 rows × 5 columns

In [17]:

legislators_by_gender_state_counts.loc["F"].head()

Out[17]:

	last_name	first_name	birthday	type	party
state
AL	3	3	3	3	3
AR	5	5	5	5	5
AZ	3	3	3	3	3
CA	24	24	24	24	24
CO	3	3	3	3	3

Více o (pokročileší) práci s indexy a multiindexy najdeš v dokumentaci.

Pokud bychom se chtěli multiindexu "zbavit", můžeme to udělat pomocí .reset_index()

In [18]:

legislators_by_state_gender_counts.reset_index().head(5)

Out[18]:

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

Anebo rovnou použít groupby s as_index=False.

In [19]:

legislators_historical.groupby(["state", "gender"], as_index=False).count().head(5)

Out[19]:

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

Co je ten `DataFrameGroupBy object`?

Na začátku jsme si udělali základní agregaci bez aplikace funkcí a dostali jsme jakýsi objekt. Je možné s ním něco dělat, aniž bychom agregovali? Ukazuje se, že ano.

Než se k tomu dostaneme, zkusme jeden úkol: Rozděl náš dataframe podle stran - tzn. pro každou stranu vytvoř dataframe a ten ulož do zvláštního souboru. Např. Democrat půjde do Democrat.csv atd.

In [ ]:

In [20]:

legislators_historical.groupby('party')

Out[20]:

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x11f860eb0>

Jedna klíčová funkce, kterou nám tento objekt nabízí, je iterace.

In [21]:

groups = legislators_historical.groupby('party')

next(iter(groups)) # timhle ziskame prvni element pri iteraci (for cyklu)

Out[21]:

('Adams',
       last_name first_name   birthday gender type state  party
 994       Mills     Elijah 1776-12-01      M  sen    MA  Adams
 1079      Lloyd      James        NaT      M  sen    MA  Adams
 1122  McIlvaine     Joseph 1769-10-02      M  sen    NJ  Adams
 1145     Thomas      Jesse        NaT      M  sen    IL  Adams
 1152   Van Dyke   Nicholas 1770-12-20      M  sen    DE  Adams
 ...         ...        ...        ...    ...  ...   ...    ...
 1398     Holmes       John 1773-03-14      M  sen    ME  Adams
 1429    Silsbee  Nathaniel 1773-01-14      M  sen    MA  Adams
 1472   Chambers    Ezekiel 1788-02-28      M  sen    MD  Adams
 1501  Hendricks    William 1782-11-12      M  sen    IN  Adams
 2033   Harrison    William 1773-02-09      M  sen    OH  Adams
 
 [100 rows x 7 columns])

K čemu nám to může být? Při agregaci se data drasticky zjednodušují a nemusíme si vždy být jisti, že naše agregace jsou napsané správně. Pomocí iterace nad skupinami si můžeme zobrazit všechna data před agregací.

In [22]:

for party, df in legislators_historical.groupby('party'):
    df.to_csv(party + '.csv')

Tuto funkcionalitu asi tolik neoceníte, když jde jen o jeden sloupec, zde party, tedy alternativa není tak složitá. Ale jakmile začnete agregovat nad více sloupci, začne být iterace čím dál užitečnější.

Další agregační funkce

Dosud jsme agregovali jen pomocí .size nebo .count, ale existuje spousta další agregačních metod, zejm. těch numerických.

Pro snadnější práci s agregacemi budeme používat metodu .agg, která akceptuje slovník. Tento slovník udává, co chceme agregovat (klíč) a jak to chceme agregovat (hodnota). S tím, že způsobů agregace pro jeden sloupec může být více naráz. Ukážeme si.

In [23]:

legislators_historical.groupby('state').agg({'birthday': 'max'}).head()

Out[23]:

	birthday
state
AK	1962-03-30
AL	1967-10-09
AR	1968-08-21
AS	1943-08-15
AZ	1976-11-03

In [24]:

legislators_historical.groupby('state').agg({
    'birthday': ['min', 'max'],
    'party': 'nunique'}
).head()

Out[24]:

	birthday		party
	min	max	nunique
state
AK	1848-09-17	1962-03-30	3
AL	1780-01-30	1967-10-09	8
AR	1788-08-25	1968-08-21	5
AS	1937-03-13	1943-08-15	1
AZ	1816-01-24	1976-11-03	3

Transformace sloupců

Většinu času jsme pracovali s daty, které jsme načetli ze souboru a krom nějakého základního čištění jsme je žádným způsobem neměnili. Teď si ukážeme, jak udělat některé základní transformace.

Může nás například zajímat, které hodnoty máme či nemáme v daném sloupci. K získání takové informace sloužít metody .isnull a .notnull, které jsou navzájem inverzní.

In [25]:

legislators_historical['party'].isnull()

Out[25]:

0        False
1         True
2         True
3         True
4         True
         ...  
11978    False
11979    False
11980    False
11981    False
11982    False
Name: party, Length: 11983, dtype: bool

Series má metodu isnull, která nám vrátí True/False hodnoty podle toho, jestli daná hodnota chybí nebo ne (NULL v SQL). Pro snadnější pochopení je možné použít inverzní metodu notnull.

Může náš též zajímat, zda řádky nabývají některou z vybraných hodnot.

In [26]:

legislators_historical['first_name'].isin(['Richard', 'John'])

Out[26]:

0         True
1        False
2        False
3        False
4        False
         ...  
11978    False
11979    False
11980     True
11981     True
11982    False
Name: first_name, Length: 11983, dtype: bool

... nebo jak se hodnoty liší mezi řádky (dává smysl jen pro číselná data nebo pro sloupce obsahující datum)

In [27]:

legislators_historical['birthday'].diff()

Out[27]:

0              NaT
1       -1108 days
2         452 days
3       -4712 days
4        3159 days
           ...    
11978   11667 days
11979   -6342 days
11980    2276 days
11981   -9373 days
11982   10940 days
Name: birthday, Length: 11983, dtype: timedelta64[ns]

.str a .dt metody

Můžeme též testovat různé vlastnosti stringů a dat (od slova datum). Slouží k tomu .str a .dt.

In [28]:

legislators_historical['first_name'].str.len()

Out[28]:

0         7
1        10
2         7
3         6
4         6
         ..
11978     6
11979     4
11980     4
11981     4
11982     3
Name: first_name, Length: 11983, dtype: int64

Často používanými metodami v rámci .str je contains nebo .lower/upper

In [29]:

names = pd.Series(['JOHN', 'Jean-Luc', 'Mary-Jane', 'Kate', 'John'])
names.str.contains('-')

Out[29]:

0    False
1     True
2     True
3    False
4    False
dtype: bool

In [30]:

names[names.str.contains('-')]

Out[30]:

1     Jean-Luc
2    Mary-Jane
dtype: object

Zatímco .str.contains použijeme zpravidla na filtrování, .lower poslouží třeba na unifikaci dat, která se pak lépe agregují (a deduplikují).

In [31]:

names.value_counts()

Out[31]:

John         1
Mary-Jane    1
Kate         1
Jean-Luc     1
JOHN         1
dtype: int64

In [32]:

names.str.lower().value_counts()

Out[32]:

john         2
jean-luc     1
kate         1
mary-jane    1
dtype: int64

Z .dt si ukážeme jak vytáhnout z data rok.

In [33]:

birth_years = legislators_historical['birthday'].dt.year

birth_years#.value_counts()

Out[33]:

0        1745.0
1        1742.0
2        1743.0
3        1730.0
4        1739.0
          ...  
11978    1976.0
11979    1959.0
11980    1965.0
11981    1940.0
11982    1970.0
Name: birthday, Length: 11983, dtype: float64

Úkol: vyfiltruj politiky narozené v roce 1980 či později.

In [ ]:

Agregace nad nesloupci

Dosud jsme vždy agregovali nad něčím, co jsme měli v DataFramu. Je ale možné agregovat nad daty, které tam vůbec nemáme, alespoň ne explicitně. K tomu budou sloužit transformace, které jsme si právě ukázali.

Kromě názvu sloupce můžeme do groupby vložit nějakou Series (!), která má stejný tvar jako naše sloupce a pandas podle toho bude umět agregovat. Jaká taková Series se nabízí? Nejlépe transformace nějakého existujícího sloupce.

Můžeme tak agregovat data na základě měsíce, kdy se daný člověk narodil. A to aniž bychom tento sloupec přidávali do dataframu. Tato metoda nám tak pomůže dělat kreativní agregace bez nutnosti měnit naše data.

In [34]:

legislators_historical.groupby([
    legislators_historical['birthday'].dt.month,
]).size()

Out[34]:

birthday
1.0     1046
2.0      975
3.0     1030
4.0      894
5.0      886
6.0      854
7.0      858
8.0      970
9.0      995
10.0    1018
11.0     935
12.0     971
dtype: int64

Můžeme samozřejmě přidávat další a další (ne)sloupce.

In [35]:

legislators_historical.groupby([
    legislators_historical['type'],
    legislators_historical['birthday'].dt.month,
]).size()

Out[35]:

type  birthday
rep   1.0         879
      2.0         826
      3.0         885
      4.0         765
      5.0         748
      6.0         742
      7.0         728
      8.0         819
      9.0         830
      10.0        861
      11.0        779
      12.0        800
sen   1.0         167
      2.0         149
      3.0         145
      4.0         129
      5.0         138
      6.0         112
      7.0         130
      8.0         151
      9.0         165
      10.0        157
      11.0        156
      12.0        171
dtype: int64

Měsíce jsou fajn, je jich jen 12, ale co když budeme chtít agregovat nad roky narození?

In [36]:

legislators_historical.groupby([
    legislators_historical['type'],
    legislators_historical['birthday'].dt.year,
]).size().count()

Out[36]:

Dostáváme poněkud velký dataset, který nám toho moc neřekne. S tím nám pomůže další kapitola.

Binning

Sice jsme si vytáhli jednotlivé roky narození, ale přeci jen jich je spousta a moc nám to neřekne, určitě se podle nich nedá dobře agregovat.

In [37]:

birth_years = legislators_historical['birthday'].dt.year.astype('Int16')
legislators_historical = legislators_historical.assign(birth_year=birth_years)

In [38]:

legislators_historical['birth_year'].hist(bins=25)

Out[38]:

<AxesSubplot:>

In [39]:

legislators_historical['birth_year'].value_counts()

Out[39]:

1840    94
1824    94
1870    93
1828    92
1835    91
        ..
1981     1
1977     1
1721     1
1983     1
1987     1
Name: birth_year, Length: 258, dtype: Int64

Ani histogram, ani value_counts nám žádné moc hodnotné informace nepřinesl. Budeme muset data trochu seskupit. Na to v pandas existuje několik možností.

První z nich je nám již známý .value_counts, kterému můžeme přihodit argument bins, který znamená, že nechceme frekvence jednotlivých hodnot, ale že chceme seskupit data do několika intervalů.

In [40]:

legislators_historical['birth_year'].value_counts(bins=10)

Out[40]:

(1827.4, 1854.0]      2077
(1800.8, 1827.4]      2059
(1854.0, 1880.6]      1839
(1880.6, 1907.2]      1345
(1774.2, 1800.8]      1245
(1907.2, 1933.8]      1021
(1933.8, 1960.4]       938
(1747.6, 1774.2]       648
(1960.4, 1987.0]       147
(1720.733, 1747.6]     113
Name: birth_year, dtype: int64

Co když nám takové samorozdělení nestačí? Na to je pandas.cut, resp. pd.cut. Má spoustu možností, doporučujeme projít dokumentaci.

In [41]:

bins = [1700, 1750, 1800, 1850, 1900, 1950]
pd.cut(legislators_historical['birth_year'], bins)

Out[41]:

0        (1700.0, 1750.0]
1        (1700.0, 1750.0]
2        (1700.0, 1750.0]
3        (1700.0, 1750.0]
4        (1700.0, 1750.0]
               ...       
11978                 NaN
11979                 NaN
11980                 NaN
11981    (1900.0, 1950.0]
11982                 NaN
Name: birth_year, Length: 11983, dtype: category
Categories (5, interval[int64]): [(1700, 1750] < (1750, 1800] < (1800, 1850] < (1850, 1900] < (1900, 1950]]

In [42]:

pd.cut(legislators_historical['birth_year'], bins).value_counts()

Out[42]:

(1800, 1850]    3839
(1850, 1900]    3159
(1900, 1950]    2002
(1750, 1800]    1857
(1700, 1750]     149
Name: birth_year, dtype: int64

Nevýhodou pd.cut je, že intervaly jsou určeny uživatelem a může chvíli trvat, než je člověk odladí. Více automatická je možnost určit intervaly pomocí statistického rozložení dat, k tomu slouží pd.qcut, ten místo hranic intervalů bere kvantily.

In [43]:

pd.qcut(legislators_historical['birth_year'], [0, .1, .5, .9, 1]).value_counts()

Out[43]:

(1784.0, 1849.0]      4616
(1849.0, 1932.0]      4545
(1720.999, 1784.0]    1156
(1932.0, 1987.0]      1115
Name: birth_year, dtype: int64

Samozřejmostí tohoto seskupování je, že tyto transformované sloupce opět můžeme použít pro agregaci.

Úkol: Kolik bylo dohromady poslanců a kolik bylo senátorů, rozděleno podle století, kdy byli narozeni. (Např. mezi lety 1900 a 2000 bylo narozeno 200 senátorů a 800 poslanců atd.)

In [ ]:

Kontingenční tabulky

Pokud budeme agregovat nad několika sloupci, může se nám stát, že z DataFramu se nám stane jedna dlouhá nudle. V tom se nedá moc dobře vyznat. Pokud jste s takovými daty někdy pracovali v Excelu, možná vám bude povědomá funkce kontigenčních tabulek, v angličtině pivot tables.

Než začneme pivotovat, vytvořme si malý dataset - bude to jednoduchá agregace na základě typu angažmá z parlamentu a pohlaví.

In [44]:

summary = legislators_historical.groupby(['type', 'gender'], as_index=False)[['last_name']].count()
summary = summary.rename(columns={'last_name': 'count'})
summary

Out[44]:

	type	gender	count
0	rep	F	204
1	rep	M	9949
2	sen	F	31
3	sen	M	1799

Součástí každého pivotu jsou tři faktory - specifikace,

který se sloupců chceme v indexu
který bude ve sloupcích
který sloupec se přiřadí do hodnot v DataFramu

Hezky je to vidět na tomto diagramu.

In [45]:

summary.pivot(index='gender', columns='type', values='count')

Out[45]:

type	rep	sen
gender
F	204	31
M	9949	1799

Omezením metody pivot je to, že umí jen otáčet DataFrame, ale pokud některému z políček odpovídá více hodnot, vyhodí vám chybu, protože neví, jak je má agregovat. Pivot je opravdu jen pro otáčení.

Na komplexnější agregace tu je podobně pojmenovaný pivot_table.

In [46]:

summary = legislators_historical.groupby(['type', 'state', 'gender'], as_index=False)[['last_name']].count()
summary = summary.rename(columns={'last_name': 'count'})
summary

Out[46]:

	type	state	gender	count
0	rep	AK	M	10
1	rep	AL	F	1
2	rep	AL	M	166
3	rep	AR	F	3
4	rep	AR	M	81
...	...	...	...	...
167	sen	VT	M	36
168	sen	WA	M	20
169	sen	WI	M	26
170	sen	WV	M	31
171	sen	WY	M	19

172 rows × 4 columns

pivot_table nabízí možnost přiřadit do některé z dimenzí (do indexu či sloupců) vícero sloupců, a následně pak vytvoří víceúrovňový index. Jde též specifikovat, jaká funkce se aplikuje, pokud na buňku připadá více hodnot (jako v Excelu).

Více detailů najdete v dokumentaci.

In [47]:

wide = summary.pivot_table(index='state', columns=['type', 'gender'], values='count', fill_value='')

wide.head(10)

Out[47]:

type	rep		sen
gender	F	M	F	M
state
AK		10.0		6
AL	1	166.0	2	37
AR	3	81.0	2	31
AS		2.0
AZ	3	34.0		11
CA	23	298.0	1	41
CO	3	53.0		34
CT	6	183.0		51
DC		2.0
DE		48.0		49

Kdyby ti přišlo matoucí, že tu jsou dvě podobné funkce na kontigenční tabulky, tak tě ještě víc zmateme, protože existuje ještě pd.crosstab. Do detailů zde už zacházet nebudeme, doporučujeme dokumentaci.

Inverzní kontigenční tabulky

Zatímco na kontigenční tabulky mnozí narazili, jejich inverzní funkcionalita je celkem neznámá, a zajímavá. Funguje přesně tak, jak píšeme - vezme se široká tabulka, ve které je jedna z dimenzí ve sloupcích, a zúží a prodlouží se tím, že se ony názvy sloupcí překonvertují do samotného sloupce. Příklad bude názornější.

V pandas se na tuto inverzní operaci používá metoda melt. Její delší výčet argumentů je tradičně v dokumentaci.

Mějme dataset, kde je výkon v různých regionech fiktivní země. Nevýhodou je, že nemůžeme úplně dívat na časové řady, protože roky, ke kterým údaje platí, jsou ve sloupcích, ne v řádcích. Takto široké tabulky jsou celkem populární třeba u dat o počasí.

In [48]:

df = pd.DataFrame({
    'region': ['North', 'South', 'East', 'West'],
    '2000': [200, 100, 50, 1000],
    '2005': [450, 10, 510, 1040],
    '2010': [10, 500, 950, 500],
    '2015': [550, 20, 50, 10],
    '2020': [1, 1, 5, 10],
})
df

Out[48]:

	region	2000	2005	2010	2015	2020
0	North	200	450	10	550	1
1	South	100	10	500	20	1
2	East	50	510	950	50	5
3	West	1000	1040	500	10	10

pd.melt zajímá, který ze sloupců nějak identifikuje dané řádky (id_vars) a které sloupce obsahují hodnoty (value_vars). Zbylé dva argumenty slouží jen k přejmenování sloupců (var_name, value_name).

In [49]:

long = df.melt(id_vars=['region'], value_vars=['2000', '2005', '2010', '2015', '2020'],
        var_name='year', value_name='output')

long

Out[49]:

	region	year	output
0	North	2000	200
1	South	2000	100
2	East	2000	50
3	West	2000	1000
4	North	2005	450
5	South	2005	10
6	East	2005	510
7	West	2005	1040
8	North	2010	10
9	South	2010	500
10	East	2010	950
11	West	2010	500
12	North	2015	550
13	South	2015	20
14	East	2015	50
15	West	2015	10
16	North	2020	1
17	South	2020	1
18	East	2020	5
19	West	2020	10

Úkol: vem tento dlouhý dataset a udělej z něj ten původní, široký. (Neřeš, pokud máš někde index, kde před tím nebyl.)

In [ ]:

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	type	state	gender	count
0	rep	AK	M	10
1	rep	AL	F	1
2	rep	AL	M	166
3	rep	AR	F	3
4	rep	AR	M	81
...	...	...	...	...
167	sen	VT	M	36
168	sen	WA	M	20
169	sen	WI	M	26
170	sen	WV	M	31
171	sen	WY	M	19

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	type	state	gender	count
0	rep	AK	M	10
1	rep	AL	F	1
2	rep	AL	M	166
3	rep	AR	F	3
4	rep	AR	M	81
...	...	...	...	...
167	sen	VT	M	36
168	sen	WA	M	20
169	sen	WI	M	26
170	sen	WV	M	31
171	sen	WY	M	19

EDA 5: Pokročilejší manipulace a agregace

Analýza dat po skupinách

Krok 1: Split

Krok 2 + 3: Apply + Combine

Práce s MultiIndex

Co je ten DataFrameGroupBy object?

Další agregační funkce

Transformace sloupců

.str a .dt metody

Agregace nad nesloupci

Binning

Kontingenční tabulky

Inverzní kontigenční tabulky

Co je ten `DataFrameGroupBy object`?

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	state	gender	last_name	first_name	birthday	type	party
0	AK	M	16	16	16	16	14
1	AL	F	3	3	3	3	3
2	AL	M	203	203	194	203	203
3	AR	F	5	5	5	5	5
4	AR	M	112	112	109	112	110

	type	state	gender	count
0	rep	AK	M	10
1	rep	AL	F	1
2	rep	AL	M	166
3	rep	AR	F	3
4	rep	AR	M	81
...	...	...	...	...
167	sen	VT	M	36
168	sen	WA	M	20
169	sen	WI	M	26
170	sen	WV	M	31
171	sen	WY	M	19