.. _seance5approchefonctionnelleenoncerst:

==========================================
Données, approches fonctionnelles - énoncé
==========================================


.. only:: html

    **Links:** :download:`notebook <seance5_approche_fonctionnelle_enonce.ipynb>`, :downloadlink:`html <seance5_approche_fonctionnelle_enonce2html.html>`, :download:`PDF <seance5_approche_fonctionnelle_enonce.pdf>`, :download:`python <seance5_approche_fonctionnelle_enonce.py>`, :downloadlink:`slides <seance5_approche_fonctionnelle_enonce.slides.html>`, :githublink:`GitHub|_doc/notebooks/sessions/seance5_approche_fonctionnelle_enonce.ipynb|*`


L’approche fonctionnelle est une façon de traiter les données en ne
conservant qu’une petite partie en mémoire. D’une manière générale, cela
s’applique à tous les calculs qu’on peut faire avec le langage
`SQL <https://fr.wikipedia.org/wiki/Structured_Query_Language>`__. Le
notebook utilisera des données issues d’une table de mortalité extraite
de `table de mortalité de 1960 à
2010 <http://www.data-publica.com/opendata/7098--population-et-conditions-sociales-table-de-mortalite-de-1960-a-2010>`__
(*le lien est cassé car data-publica ne fournit plus ces données, le
notebook récupère une copie*) qu’on récupère à l’aide de la fonction
`table_mortalite_euro_stat <http://www.xavierdupre.fr/app/actuariat_python/helpsphinx/actuariat_python/data/population.html#actuariat_python.data.population.table_mortalite_euro_stat>`__.

.. code:: ipython3

    %matplotlib inline
    import matplotlib.pyplot as plt
    plt.style.use('ggplot')
    import pyensae
    from pyquickhelper.helpgen import NbImage
    from jyquickhelper import add_notebook_menu
    add_notebook_menu()


.. parsed-literal::
    Populating the interactive namespace from numpy and matplotlib






.. contents::
    :local:





.. code:: ipython3

    from actuariat_python.data import table_mortalite_euro_stat 
    table_mortalite_euro_stat()
    import pandas
    df = pandas.read_csv("mortalite.txt", sep="\t", encoding="utf8", low_memory=False)
    df.head()






.. raw:: html

    <div>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>annee</th>
          <th>valeur</th>
          <th>age</th>
          <th>age_num</th>
          <th>indicateur</th>
          <th>genre</th>
          <th>pays</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>0</th>
          <td>2012</td>
          <td>0.00000</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AD</td>
        </tr>
        <tr>
          <th>1</th>
          <td>2014</td>
          <td>0.00042</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AL</td>
        </tr>
        <tr>
          <th>2</th>
          <td>2009</td>
          <td>0.00080</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>3</th>
          <td>2008</td>
          <td>0.00067</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>4</th>
          <td>2007</td>
          <td>0.00052</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
      </tbody>
    </table>
    </div>



Itérateur, Générateur
~~~~~~~~~~~~~~~~~~~~~

itérateur
^^^^^^^^^

La notion
d’\ `itérateur <https://fr.wikipedia.org/wiki/It%C3%A9rateur>`__ est
incournable dans ce genre d’approche fonctionnelle. Un itérateur
parcourt les éléments d’un ensemble. C’est le cas de la fonction
`range <https://docs.python.org/3.4/library/functions.html#func-range>`__.

.. code:: ipython3

    it = iter([0,1,2,3,4,5,6,7,8])
    print(it, type(it))


.. parsed-literal::
    <list_iterator object at 0x000001A50784C358> <class 'list_iterator'>


Il faut le dissocier d’une
`liste <https://docs.python.org/3.4/tutorial/datastructures.html#more-on-lists>`__
qui est un
`conteneur <https://docs.python.org/3/library/collections.html>`__.

.. code:: ipython3

    [0,1,2,3,4,5,6,7,8]




.. parsed-literal::
    [0, 1, 2, 3, 4, 5, 6, 7, 8]



Pour s’en convaincre, on compare la taille d’un itérateur avec celui
d’une liste : la taille de l’itérateur ne change pas quelque soit la
liste, la taille de la liste croît avec le nombre d’éléments qu’elle
contient.

.. code:: ipython3

    import sys
    print(sys.getsizeof(iter([0,1,2,3,4,5,6,7,8])))
    print(sys.getsizeof(iter([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])))
    print(sys.getsizeof([0,1,2,3,4,5,6,7,8]))
    print(sys.getsizeof([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]))


.. parsed-literal::
    56
    56
    136
    184


L’itérateur ne sait faire qu’une chose : passer à l’élément suivant et
lancer une exception
`StopIteration <https://docs.python.org/3.4/library/exceptions.html#StopIteration>`__
lorsqu’il arrive à la fin.

.. code:: ipython3

    it = iter([0,1,2,3,4,5,6,7,8])
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))


.. parsed-literal::
    0
    1
    2
    3
    4
    5
    6
    7
    8


::


    ---------------------------------------------------------------------------

    StopIteration                             Traceback (most recent call last)

    <ipython-input-6-3260960c0f0b> in <module>()
          9 print(next(it))
         10 print(next(it))
    ---> 11 print(next(it))
    

    StopIteration: 


générateur
^^^^^^^^^^

Un `générateur <https://wiki.python.org/moin/Generators>`__ se comporte
comme un itérateur, il retourne des éléments les uns à la suite des
autres que ces éléments soit dans un container ou pas.

.. code:: ipython3

    def genere_nombre_pair(n):
        for i in range(0,n):
            yield 2*i
            
    genere_nombre_pair(5)




.. parsed-literal::
    <generator object genere_nombre_pair at 0x000001A507A81FC0>



Appelé comme suit, un générateur ne fait rien. On s’en convaint en
insérant une instruction ``print`` dans la fonction :

.. code:: ipython3

    def genere_nombre_pair(n):
        for i in range(0,n):
            print("je passe par là", i, n)
            yield 2*i
            
    genere_nombre_pair(5)




.. parsed-literal::
    <generator object genere_nombre_pair at 0x000001A507A81F68>



Mais si on construit une liste avec tout ces nombres, on vérifie que la
fonction ``genere_nombre_pair`` est bien executée :

.. code:: ipython3

    list(genere_nombre_pair(5))


.. parsed-literal::
    je passe par là 0 5
    je passe par là 1 5
    je passe par là 2 5
    je passe par là 3 5
    je passe par là 4 5




.. parsed-literal::

    [0, 2, 4, 6, 8]



L’instruction ``next`` fonctionne de la même façon :

.. code:: ipython3

    def genere_nombre_pair(n):
        for i in range(0,n):
            yield 2*i
            
    it = genere_nombre_pair(5)
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))


.. parsed-literal::
    0
    2
    4
    6
    8


::


    ---------------------------------------------------------------------------

    StopIteration                             Traceback (most recent call last)

    <ipython-input-10-cb3bdd50dd95> in <module>()
          9 print(next(it))
         10 print(next(it))
    ---> 11 print(next(it))
    

    StopIteration: 


Le moyen le plus simple de parcourir les éléments retournés par un
itérateur ou un générateur est une boucle ``for`` :

.. code:: ipython3

    it = genere_nombre_pair(5)
    for nombre in it:
        print(nombre)


.. parsed-literal::
    0
    2
    4
    6
    8


On peut combiner les générateurs :

.. code:: ipython3

    def genere_nombre_pair(n):
        for i in range(0,n):
            print("pair", i)
            yield 2*i
            
    def genere_multiple_six(n):
        for pair in genere_nombre_pair(n):
            print("six", pair)
            yield 3*pair
            
    print(genere_multiple_six)


.. parsed-literal::
    <function genere_multiple_six at 0x000001A507A94EA0>


.. code:: ipython3

    for i in genere_multiple_six(3):
        print(i)


.. parsed-literal::
    pair 0
    six 0
    0
    pair 1
    six 2
    6
    pair 2
    six 4
    12


intérêt
^^^^^^^


-  Les itérateurs et les générateurs sont des fonctions qui parcourent
   des ensembles d’éléments ou donne cette illusion.
-  Ils ne servent qu’à passer à l’élément suivant.
-  Ils ne le font que si on le demande explicitement avec une boucle
   ``for`` par exemple. C’est pour cela qu’on parle d’évaluation
   paresseuse ou **lazy evaluation**.
-  On peut combiner les itérateurs / générateurs.

Il faut voir les itérateurs et générateurs comme des flux, une ou
plusieurs entrées d’éléments, une sortie d’éléments, rien ne se passe
tant qu’on n’envoie pas de l’eau pour faire tourner la roue.

lambda fonction
^^^^^^^^^^^^^^^

Une fonction
`lambda <http://sametmax.com/fonctions-anonymes-en-python-ou-lambda/>`__
est une fonction plus courte d’écrire des fonctions très simples.

.. code:: ipython3

    def addition(x, y):
        return x + y
    addition(1, 3)




.. parsed-literal::
    4



.. code:: ipython3

    additionl = lambda x,y : x+y
    additionl(1, 3)




.. parsed-literal::
    4



Exercice 1 : application aux grandes bases de données
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Imaginons qu’on a une base de données de 10 milliards de lignes. On doit
lui appliquer deux traitements : ``f1``, ``f2``. On a deux options
possibles :


-  Appliquer la fonction ``f1`` sur tous les éléments, puis appliquer
   ``f2`` sur tous les éléments transformés par ``f1``.
-  Application la combinaison des générateurs ``f1``, ``f2`` sur chaque
   ligne de la base de données.

Que se passe-t-il si on a fait une erreur d’implémentation dans la
fonction ``f2`` ?


Map/Reduce, approche fonctionnelle avec cytoolz
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

On a vu les fonctions
`iter <https://docs.python.org/3/library/functions.html#iter>`__ et
`next <https://docs.python.org/3/library/functions.html#next>`__ mais on
ne les utilise quasiment jamais. La programmation fonctionnelle consiste
le plus souvent à combiner des itérateurs et générateurs pour ne les
utiliser qu’au sein d’une boucle. C’est cette boucle qui appelle
implicitement les deux fonctions
`iter <https://docs.python.org/3/library/functions.html#iter>`__ et
`next <https://docs.python.org/3/library/functions.html#next>`__.

La combinaison d’itérateurs fait sans cesse appel aux mêmes schémas
logiques. Python implémente quelques schémas qu’on complète par un
module tel que `cytoolz <https://pypi.python.org/pypi/cytoolz>`__. Les
deux modules `toolz <https://pypi.python.org/pypi/toolz>`__ et
`cytoolz <https://pypi.python.org/pypi/cytoolz>`__ sont deux
implémentations du même ensemble de fonctions décrit par la
documentation : `pytoolz <http://toolz.readthedocs.org/en/latest/>`__.
`toolz <https://pypi.python.org/pypi/toolz>`__ est une implémentation
purement Python. `cytoolz <https://pypi.python.org/pypi/cytoolz>`__
s’appuie sur le langage C++, elle est plus rapide.

Par défault, les éléments entrent et sortent dans le même ordre. La
liste qui suit n’est pas exhaustive (voir
`itertoolz <http://toolz.readthedocs.org/en/latest/api.html#itertoolz>`__).

**schémas simples:**


-  `filter <https://docs.python.org/3/library/functions.html#filter>`__
   : sélectionner des éléments, :math:`n` qui entrent, :math:`<n` qui
   sortent.
-  `map <https://docs.python.org/3/library/functions.html#map>`__ :
   transformer les éléments, :math:`n` qui entrent, :math:`n` qui
   sortent.
-  `take <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.take>`__
   : prendre les :math:`k` premiers éléments, :math:`n` qui entrent,
   :math:`k <= n` qui sortent.
-  `drop <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.drop>`__
   : passer les :math:`k` premiers éléments, :math:`n` qui entrent,
   :math:`n-k` qui sortent.
-  `sorted <https://docs.python.org/3.4/library/functions.html#sorted>`__
   : tri les éléments, :math:`n` qui entrent, :math:`n` qui sortent dans
   un ordre différent.
-  `reduce <https://docs.python.org/3.4/library/functools.html?highlight=reduce#functools.reduce>`__
   : aggréger (au sens de sommer) les éléments, :math:`n` qui entrent, 1
   qui sort.
-  `concat <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.concat>`__
   : fusionner deux séquences d’éléments définies par deux itérateurs,
   :math:`n` et :math:`m` qui entrent, :math:`n+m` qui sortent.

**schémas complexes**

Certains schémas sont la combinaison de schémas simples mais il est plus
efficace d’utiliser la version combinée.


-  `join <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.join>`__
   : associe deux séquences, :math:`n` et :math:`m` qui entrent, au pire
   :math:`nm` qui sortent.
-  `groupby <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.groupby>`__
   : classe les éléments, :math:`n` qui entrent, :math:`p<=n` groupes
   d’éléments qui sortent.
-  `reduceby <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.reduceby>`__
   : combinaison (*groupby*, *reduce*), :math:`n` qui entrent,
   :math:`p<=n` qui sortent.

**schéma qui retourne un seul élément**


-  `all <https://docs.python.org/3/library/functions.html#all>`__ : vrai
   si tous les éléments sont vrais.
-  `any <https://docs.python.org/3/library/functions.html#any>`__ : vrai
   si un éléments est vrai.
-  `first <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.first>`__
   : premier élément qui entre.
-  `last <http://toolz.readthedocs.org/en/latest/api.html#toolz.itertoolz.last>`__
   : dernier élément qui sort.
-  min, max, sum, len…

**schéma qui aggrège**


-  `add <https://docs.python.org/3.4/library/operator.html#operator.add>`__
   : utilisé avec la fonction *reduce* pour aggréger les éléments et
   n’en retourner qu’un.

`API PyToolz <http://toolz.readthedocs.org/en/latest/api.html>`__ décrit
l’ensemble des fonctions disponibles.

Exercice 2 : cytoolz
~~~~~~~~~~~~~~~~~~~~

La note d’un candidat à un concours de patinage artistique fait la
moyenne de trois moyennes parmi cinq, les deux extrêmes n’étant pas
prises en compte. Il faut calculer cette somme pour un ensemble de
candidats avec `cytoolz <https://pypi.python.org/pypi/cytoolz>`__.

.. code:: ipython3

    notes = [dict(nom="A", juge=1, note=8),
            dict(nom="A", juge=2, note=9),
            dict(nom="A", juge=3, note=7),
            dict(nom="A", juge=4, note=4),
            dict(nom="A", juge=5, note=5),
            dict(nom="B", juge=1, note=7),
            dict(nom="B", juge=2, note=4),
            dict(nom="B", juge=3, note=7),
            dict(nom="B", juge=4, note=9),
            dict(nom="B", juge=1, note=10),
            dict(nom="C", juge=2, note=0),
            dict(nom="C", juge=3, note=10),
            dict(nom="C", juge=4, note=8),
            dict(nom="C", juge=5, note=8),        
            dict(nom="C", juge=5, note=8),        
            ]
    
    import pandas
    pandas.DataFrame(notes)






.. raw:: html

    <div>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>juge</th>
          <th>nom</th>
          <th>note</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>0</th>
          <td>1</td>
          <td>A</td>
          <td>8</td>
        </tr>
        <tr>
          <th>1</th>
          <td>2</td>
          <td>A</td>
          <td>9</td>
        </tr>
        <tr>
          <th>2</th>
          <td>3</td>
          <td>A</td>
          <td>7</td>
        </tr>
        <tr>
          <th>3</th>
          <td>4</td>
          <td>A</td>
          <td>4</td>
        </tr>
        <tr>
          <th>4</th>
          <td>5</td>
          <td>A</td>
          <td>5</td>
        </tr>
        <tr>
          <th>5</th>
          <td>1</td>
          <td>B</td>
          <td>7</td>
        </tr>
        <tr>
          <th>6</th>
          <td>2</td>
          <td>B</td>
          <td>4</td>
        </tr>
        <tr>
          <th>7</th>
          <td>3</td>
          <td>B</td>
          <td>7</td>
        </tr>
        <tr>
          <th>8</th>
          <td>4</td>
          <td>B</td>
          <td>9</td>
        </tr>
        <tr>
          <th>9</th>
          <td>1</td>
          <td>B</td>
          <td>10</td>
        </tr>
        <tr>
          <th>10</th>
          <td>2</td>
          <td>C</td>
          <td>0</td>
        </tr>
        <tr>
          <th>11</th>
          <td>3</td>
          <td>C</td>
          <td>10</td>
        </tr>
        <tr>
          <th>12</th>
          <td>4</td>
          <td>C</td>
          <td>8</td>
        </tr>
        <tr>
          <th>13</th>
          <td>5</td>
          <td>C</td>
          <td>8</td>
        </tr>
        <tr>
          <th>14</th>
          <td>5</td>
          <td>C</td>
          <td>8</td>
        </tr>
      </tbody>
    </table>
    </div>



.. code:: ipython3

    import cytoolz.itertoolz as itz
    import cytoolz.dicttoolz as dtz
    from functools import reduce
    from operator import add


Blaze, odo : interfaces communes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

`Blaze <http://blaze.pydata.org/en/latest/>`__ fournit une interface
commune, proche de celle des Dataframe, pour de nombreux modules comme
`bcolz <http://bcolz.blosc.org/>`__\ …
`odo <https://odo.readthedocs.io/en/latest/>`__ propose des outils de
conversions dans de nombreux formats.


-  `Pandas to
   Blaze <http://blaze.pydata.org/en/latest/rosetta-pandas.html>`__

Ils sont présentés dans un autre notebook. On reproduit ce qui se fait
une une ligne avec `odo <https://odo.readthedocs.io/en/latest/>`__.

.. code:: ipython3

    df.to_csv("mortalite_compresse.csv", index=False)

.. code:: ipython3

    from pyquickhelper.filehelper import gzip_files
    gzip_files("mortalite_compresse.csv.gz", ["mortalite_compresse.csv"], encoding="utf-8")

Parallélisation avec dask
~~~~~~~~~~~~~~~~~~~~~~~~~

-  `dask <http://dask.pydata.org/en/latest/>`__

*dask* propose de paralléliser les opérations usuelles qu’on applique à
un dataframe.

L’opération suivante est très rapide, signifiant que *dask* attend de
savoir quoi faire avant de charger les données :

.. code:: ipython3

    import dask.dataframe as dd
    fd = dd.read_csv('mortalite_compresse*.csv.gz', compression='gzip', blocksize=None)
    #fd = dd.read_csv('mortalite_compresse.csv', blocksize=None)

Extraire les premières lignes prend très peu de temps car *dask* ne
décompresse que le début :

.. code:: ipython3

    fd.head()






.. raw:: html

    <div>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>annee</th>
          <th>valeur</th>
          <th>age</th>
          <th>age_num</th>
          <th>indicateur</th>
          <th>genre</th>
          <th>pays</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>0</th>
          <td>2012</td>
          <td>0.00000</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AD</td>
        </tr>
        <tr>
          <th>1</th>
          <td>2014</td>
          <td>0.00042</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AL</td>
        </tr>
        <tr>
          <th>2</th>
          <td>2009</td>
          <td>0.00080</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>3</th>
          <td>2008</td>
          <td>0.00067</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>4</th>
          <td>2007</td>
          <td>0.00052</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>DEATHRATE</td>
          <td>F</td>
          <td>AM</td>
        </tr>
      </tbody>
    </table>
    </div>



.. code:: ipython3

    fd.npartitions




.. parsed-literal::
    1



.. code:: ipython3

    fd.divisions




.. parsed-literal::
    (None, None)



.. code:: ipython3

    s = fd.sample(frac=0.01)

.. code:: ipython3

    s.head()






.. raw:: html

    <div>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>annee</th>
          <th>valeur</th>
          <th>age</th>
          <th>age_num</th>
          <th>indicateur</th>
          <th>genre</th>
          <th>pays</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>2514555</th>
          <td>2012</td>
          <td>1.061787e+06</td>
          <td>NaN</td>
          <td>NaN</td>
          <td>TOTPYLIVED</td>
          <td>F</td>
          <td>AD</td>
        </tr>
        <tr>
          <th>1812522</th>
          <td>2006</td>
          <td>7.691800e+04</td>
          <td>Y61</td>
          <td>61.0</td>
          <td>PYLIVED</td>
          <td>M</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>2352885</th>
          <td>2008</td>
          <td>7.170500e+04</td>
          <td>Y68</td>
          <td>68.0</td>
          <td>SURVIVORS</td>
          <td>T</td>
          <td>RO</td>
        </tr>
        <tr>
          <th>1018976</th>
          <td>2013</td>
          <td>1.162000e-02</td>
          <td>Y62</td>
          <td>62.0</td>
          <td>PROBDEATH</td>
          <td>M</td>
          <td>MT</td>
        </tr>
        <tr>
          <th>1960726</th>
          <td>1999</td>
          <td>7.475100e+04</td>
          <td>Y70</td>
          <td>70.0</td>
          <td>PYLIVED</td>
          <td>T</td>
          <td>IE</td>
        </tr>
      </tbody>
    </table>
    </div>



.. code:: ipython3

    life = fd[fd.indicateur=='LIFEXP']
    life




.. parsed-literal::
    dd.DataFrame<getitem..., npartitions=1>



.. code:: ipython3

    life.head()






.. raw:: html

    <div>
    <table border="1" class="dataframe">
      <thead>
        <tr style="text-align: right;">
          <th></th>
          <th>annee</th>
          <th>valeur</th>
          <th>age</th>
          <th>age_num</th>
          <th>indicateur</th>
          <th>genre</th>
          <th>pays</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <th>398874</th>
          <td>2012</td>
          <td>91.3</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>LIFEXP</td>
          <td>F</td>
          <td>AD</td>
        </tr>
        <tr>
          <th>398875</th>
          <td>2014</td>
          <td>79.9</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>LIFEXP</td>
          <td>F</td>
          <td>AL</td>
        </tr>
        <tr>
          <th>398876</th>
          <td>2009</td>
          <td>76.5</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>LIFEXP</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>398877</th>
          <td>2008</td>
          <td>76.4</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>LIFEXP</td>
          <td>F</td>
          <td>AM</td>
        </tr>
        <tr>
          <th>398878</th>
          <td>2007</td>
          <td>76.5</td>
          <td>Y01</td>
          <td>1.0</td>
          <td>LIFEXP</td>
          <td>F</td>
          <td>AM</td>
        </tr>
      </tbody>
    </table>
    </div>