Python pour la data science

Lino Galiana

doi:10.5281/zenodo.8229676

Pour essayer les exemples présents dans ce tutoriel :

1 Introduction

Ce chapitre constitue une introduction à Numpy pour s’assurer que les bases du calcul vectoriel avec Python soient maîtrisées. La première partie du chapitre présente des petits exercices pour pratiquer quelques fonctions basiques de Numpy. La fin du chapitre présente des exercices pratiques d’utilisation de Numpy plus approfondis.

Il est recommandé de régulièrement se référer à la cheatsheet numpy et à la doc officielle en cas de doute sur une fonction.

Dans ce chapitre, on ne dérogera pas à la convention qui s’est imposée d’importer Numpy de la manière suivante :

import numpy as np

Nous allons également fixer la racine du générateur aléatoire de nombres afin d’avoir des résultats reproductibles :

np.random.seed(12345)

Note

Les auteurs de numpy préconisent désormais de privilégier l’utilisation de générateurs via la fonction default_rng() plutôt que la simple utilisation de numpy.random.

Afin d’être en phase avec les codes qu’on peut trouver partout sur internet, nous conservons encore np.random.seed mais cela peut être amené à évoluer.

Note

The authors of numpy now recommend using generators via the default_rng() function rather than simply using numpy.random.

To stay consistent with the codes found everywhere on the internet, we still use np.random.seed, but this may change in the future.

2 Le concept d’array

Dans le monde de la science des données, comme cela sera évoqué plus en profondeur dans les prochains chapitres, l’objet central est le tableau à deux dimensions de données. La première correspond aux lignes et la seconde aux colonnes. Si on ne se préoccupe que d’une dimension, on se rapporte à une variable (une colonne) de notre tableau de données. Il est donc naturel de faire le lien entre les tableaux de données et l’objet mathématique que sont les matrices et les vecteurs.

NumPy (Numerical Python) est la brique de base pour traiter des listes numériques ou des chaines de textes comme des matrices. NumPy intervient pour proposer ce type d’objets, et les opérations standardisées associées qui n’existent pas dans le langage Python de base.

L’objet central de NumPy est l’array qui est un tableau de données multidimensionnel. L’array Numpy peut être unidimensionnel et s’apparenter à un vecteur (1d-array), bidimensionnel et ainsi s’apparenter à une matrice (2d-array) ou, de manière plus générale, prendre la forme d’un objet multidimensionnel (Nd-array), sorte de tableau emboîté.

Les tableaux simples (uni ou bi-dimensionnels) sont faciles à se représenter et représentent la majorité des besoins liés à Numpy. Nous découvrirons lors du chapitre suivant, sur Pandas, qu’en pratique on manipule rarement directement Numpy qui est une librairie bas niveau. Un DataFrame Pandas sera construit à partir d’une collection d’array uni-dimensionnels (les variables de la table), ce qui permettra d’effectuer des opérations cohérentes (et optimisées) avec le type de la variable. Avoir quelques notions Numpy est utile pour comprendre la logique de manipulation vectorielle rendant les traitements sur des données plus lisibles, plus efficaces et plus fiables.

Par rapport à une liste,

un array ne peut contenir qu’un type de données (integer, string, etc.), contrairement à une liste.
les opérations implémentées par Numpy seront plus efficaces et demanderont moins de mémoire

Les données géographiques constitueront une construction un peu plus complexe qu’un DataFrame traditionnel. La dimension géographique prend la forme d’un tableau plus profond, au moins bidimensionnel (coordonnées d’un point). Néanmoins, les librairies de manipulation de données géographiques permettront de ne pas se préoccuper de cette complexité accrue.

2.1 Créer un array

On peut créer un array de plusieurs manières. Pour créer un array à partir d’une liste, il suffit d’utiliser la méthode array:

np.array([1,2,5])

array([1, 2, 5])

Il est possible d’ajouter un argument dtype pour contraindre le type du array :

np.array([["a","z","e"],["r","t"],["y"]], dtype="object")

array([list(['a', 'z', 'e']), list(['r', 't']), list(['y'])], dtype=object)

Il existe aussi des méthodes pratiques pour créer des array:

séquences logiques : np.arange (suite) ou np.linspace (interpolation linéaire entre deux bornes)
séquences ordonnées : array rempli de zéros, de 1 ou d’un nombre désiré : np.zeros, np.ones ou np.full
séquences aléatoires : fonctions de génération de nombres aléatoires : np.rand.uniform, np.rand.normal, etc.
tableau sous forme de matrice identité : np.eye

Ceci donne ainsi, pour les séquences logiques:

np.arange(0,10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(0,10,3)

array([0, 3, 6, 9])

np.linspace(0, 1, 5)

array([0.  , 0.25, 0.5 , 0.75, 1.  ])

Pour un array initialisé à 0:

np.zeros(10, dtype=int)

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

ou initialisé à 1:

np.ones((3, 5), dtype=float)

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

ou encore initialisé à 3.14:

np.full((3, 5), 3.14)

array([[3.14, 3.14, 3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14, 3.14, 3.14]])

Enfin, pour créer la matrice \(I_3\):

np.eye(3)

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Exercice 1

Générer:

\(X\) une variable aléatoire, 1000 répétitions d’une loi \(U(0,1)\)
\(Y\) une variable aléatoire, 1000 répétitions d’une loi normale de moyenne nulle et de variance égale à 2
Vérifier la variance de \(Y\) avec np.var

3 Indexation et slicing

3.1 Logique dans le cas d’un array unidimensionnel

La structure la plus simple est l’array unidimensionnel:

x = np.arange(10)
print(x)

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

L’indexation est dans ce cas similaire à celle d’une liste:

le premier élément est 0
le énième élément est accessible à la position \(n-1\)

La logique d’accès aux éléments est ainsi la suivante :

x[start:stop:step]

Avec un array unidimensionnel, l’opération de slicing (garder une coupe du array) est très simple. Par exemple, pour garder les K premiers éléments d’un array, on fera:

x[:(K-1)]

En l’occurrence, on sélectionne le K\(^{eme}\) élément en utilisant

x[K-1]

Pour sélectionner uniquement un élément, on fera ainsi:

x = np.arange(10)
x[2]

np.int64(2)

Les syntaxes qui permettent de sélectionner des indices particuliers d’une liste fonctionnent également avec les arrays.

Exercice 2

Prenez x = np.arange(10) et…

Sélectionner les éléments 0, 3, 5 de x
Sélectionner les éléments pairs
Sélectionner tous les éléments sauf le premier
Sélectionner les 5 premiers éléments

np.arange(10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

3.2 Sur la performance

Un élément déterminant dans la performance de Numpy par rapport aux listes, lorsqu’il est question de slicing est qu’un array ne renvoie pas une copie de l’élément en question (copie qui coûte de la mémoire et du temps) mais simplement une vue de celui-ci.

Lorsqu’il est nécessaire d’effectuer une copie, par exemple pour ne pas altérer l’array sous-jacent, on peut utiliser la méthode copy:

x_sub_copy = x[:2, :2].copy()

3.3 Filtres logiques

Il est également possible, et plus pratique, de sélectionner des données à partir de conditions logiques (opération qu’on appelle un boolean mask). Cette fonctionalité servira principalement à effectuer des opérations de filtre sur les données.

Pour des opérations de comparaison simples, les comparateurs logiques peuvent être suffisants. Ces comparaisons fonctionnent aussi sur les tableaux multidimensionnels grâce au broadcasting sur lequel nous reviendrons :

x = np.arange(10)
x2 = np.array([[-1,1,-2],[-3,2,0]])
print(x)
print(x2)

[0 1 2 3 4 5 6 7 8 9]
[[-1  1 -2]
 [-3  2  0]]

x==2
x2<0

array([[ True, False,  True],
       [ True, False, False]])

Pour sélectionner les observations relatives à la condition logique, il suffit d’utiliser la logique de slicing de numpy qui fonctionne avec les conditions logiques

Exercice 3

Soit

x = np.random.normal(size=10000)

Ne conserver que les valeurs dont la valeur absolue est supérieure à 1.96
Compter le nombre de valeurs supérieures à 1.96 en valeur absolue et leur proportion dans l’ensemble
Sommer les valeurs absolues de toutes les observations supérieures (en valeur absolue) à 1.96 et rapportez les à la somme des valeurs de x (en valeur absolue)

Lorsque c’est possible, il est recommandé d’utiliser les fonctions logiques de numpy (optimisées et qui gèrent bien la dimension). Parmi elles, on peut retrouver:

count_nonzero ;
isnan ;
any ou all, notamment avec l’argument axis ;
np.array_equal pour vérifier, élément par élément, l’égalité.

Soient x un array multidimensionnel et y un array unidimensionnel présentant une valeur manquante.

x = np.random.normal(0, size=(3, 4))
y = np.array([np.nan, 0, 1])

Exercice 4

Utiliser count_nonzero sur y
Utiliser isnan sur y et compter le nombre de valeurs non NaN
Vérifier que x comporte au moins une valeur positive dans son ensemble, en parcourant les lignes puis les colonnes.

Aide

Jetez un oeil au paramètre axis en vous documentant sur internet. Par exemple ici.

4 Manipuler un array

4.1 Fonctions de manipulation

Numpy propose des méthodes ou des fonctions standardisées pour modifier un array, voici un tableau en présentant quelques-unes:

Opération	Implémentation
Aplatir un array	`x.flatten()` (méthode)
Transposer un array	`x.T` (méthode) ou `np.transpose(x)` (fonction)
Ajouter des éléments à la fin	`np.append(x, [1,2])`
Ajouter des éléments à un endroit donné (aux positions 1 et 2)	`np.insert(x, [1,2], 3)`
Supprimer des éléments (aux positions 0 et 3)	`np.delete(x, [0,3])`

Pour combiner des array, on peut utiliser, selon les cas, les fonctions np.concatenate, np.vstack ou la méthode .r_ (concaténation rowwise). np.hstack ou la méthode .column_stack ou .c_ (concaténation column-wise)

x = np.random.normal(size = 10)

Pour ordonner un array, on utilise np.sort

x = np.array([7, 2, 3, 1, 6, 5, 4])

np.sort(x)

array([1, 2, 3, 4, 5, 6, 7])

Si on désire faire un ré-ordonnement partiel pour trouver les k valeurs les plus petites d’un array sans les ordonner, on utilise partition:

np.partition(x, 3)

array([1, 2, 3, 4, 5, 6, 7])

4.2 Statistiques sur un array

Pour les statistiques descriptives classiques, Numpy propose un certain nombre de fonctions déjà implémentées, qui peuvent être combinées avec l’argument axis

x = np.random.normal(0, size=(3, 4))

Exercice 5

Faire la somme de tous les éléments d’un array, des éléments en ligne et des éléments en colonne. Vérifier la cohérence.
Ecrire une fonction statdesc pour renvoyer les valeurs suivantes : moyenne, médiane, écart-type, minimum et maximum. L’appliquer sur x en jouant avec l’argument axis

5 Broadcasting

Le broadcasting désigne un ensemble de règles permettant d’appliquer des opérations sur des tableaux de dimensions différentes. En pratique, cela consiste généralement à appliquer une seule opération à l’ensemble des membres d’un tableau numpy.

La différence peut être comprise à partir de l’exemple suivant. Le broadcasting permet de transformer le scalaire 5 en array de dimension 3:

a = np.array([0, 1, 2])
b = np.array([5, 5, 5])

a + b
a + 5

array([5, 6, 7])

Le broadcasting peut être très pratique pour effectuer de manière efficace des opérations sur des données à la structure complexe. Pour plus de détails, se rendre ici ou ici.

5.1 Une application: programmer ses propres k-nearest neighbors

Exercice (un peu plus corsé)

Créer X un tableau à deux dimensions (i.e. une matrice) comportant 10 lignes et 2 colonnes. Les nombres dans le tableau sont aléatoires.
Importer le module matplotlib.pyplot sous le nom plt. Utiliser plt.scatter pour représenter les données sous forme de nuage de points.
Constuire une matrice 10x10 stockant, à l’élément \((i,j)\), la distance euclidienne entre les points \(X[i,]\) et \(X[j,]\). Pour cela, il va falloir jouer avec les dimensions en créant des tableaux emboîtés à partir par des appels à np.newaxis :

En premier lieu, utiliser X1 = X[:, np.newaxis, :] pour transformer la matrice en tableau emboîté. Vérifier les dimensions
Créer X2 de dimension (1, 10, 2) à partir de la même logique
En déduire, pour chaque point, la distance avec les autres points pour chaque coordonnées. Elever celle-ci au carré
A ce stade, vous devriez avoir un tableau de dimension (10, 10, 2). La réduction à une matrice s’obtient en sommant sur le dernier axe. Regarder dans l’aide de np.sum comme effectuer une somme sur le dernier axe.
Enfin, appliquer la racine carrée pour obtenir une distance euclidienne en bonne et due forme.

Vérifier que les termes diagonaux sont bien nuls (distance d’un point à lui-même…)
Il s’agit maintenant de classer, pour chaque point, les points dont les valeurs sont les plus similaires. Utiliser np.argsort pour obtenir, pour chaque ligne, le classement des points les plus proches
On va s’intéresser aux k-plus proches voisins. Pour le moment, fixons k=2. Utiliser argpartition pour réordonner chaque ligne de manière à avoir les 2 plus proches voisins de chaque point d’abord et le reste de la ligne ensuite
Utiliser le morceau de code ci-dessous

Un indice pour représenter graphiquement les plus proches voisins

plt.scatter(X[:, 0], X[:, 1], s=100)

# draw lines from each point to its two nearest neighbors
K = 2

for i in range(X.shape[0]):
    for j in nearest_partition[i, :K+1]:
        # plot a line from X[i] to X[j]
        # use some zip magic to make it happen:
        plt.plot(*zip(X[j], X[i]), color='black')

Pour la question 2, vous devriez obtenir un graphique ayant cet aspect

For question 2, you should get a graph that looks like this:

Le résultat de la question 7 est le suivant :

Ai-je inventé cet exercice corsé ? Pas du tout, il vient de l’ouvrage Python Data Science Handbook. Mais, si je vous l’avais indiqué immédiatement, auriez-vous cherché à répondre aux questions ?

Par ailleurs, il ne serait pas une bonne idée de généraliser cet algorithme à de grosses données. La complexité de notre approche est \(O(N^2)\). L’algorithme implémenté par Scikit-Learn est en \(O[NlogN]\).

De plus, le calcul de distances matricielles en utilisant la puissance des cartes graphiques serait plus rapide. A cet égard, la librairie faiss ou les frameworks spécialisés dans le calcul de distance entre des vecteurs à haute dimension comme ChromaDB offrent des performances beaucoup plus satisfaisantes que celles que permettraient Numpy sur ce problème précis.

6 Exercices supplémentaires

Comprendre le principe de l’algorithme PageRank

Google est devenu célèbre grâce à son algorithme PageRank. Celui-ci permet, à partir de liens entre sites web, de donner un score d’importance à un site web qui va être utilisé pour évaluer sa centralité dans un réseau. L’objectif de cet exercice est d’utiliser Numpy pour mettre en oeuvre un tel algorithme à partir d’une matrice d’adjacence qui relie les sites entre eux.

Créer la matrice suivante avec numpy. L’appeler M:

\[ \begin{bmatrix} 0 & 0 & 0 & 0 & 1 \\ 0.5 & 0 & 0 & 0 & 0 \\ 0.5 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0.5 & 0 & 0 \\ 0 & 0 & 0.5 & 1 & 0 \end{bmatrix} \]

Pour représenter visuellement ce web minimaliste, convertir en objet networkx (une librairie spécialisée dans l’analyse de réseau) et utiliser la fonction draw de ce package.

Il s’agit de la transposée de la matrice d’adjacence qui permet de relier les sites entre eux. Par exemple, le site 1 (première colonne) est référencé par les sites 2 et 3. Celui-ci ne référence que le site 5.

A partir de la page wikipedia anglaise de PageRank, tester sur votre matrice.

Le site 1 est assez central car il est référencé 2 fois. Le site 5 est lui également central puisqu’il est référencé par le site 1.

array([[0.25419178],
       [0.13803151],
       [0.13803151],
       [0.20599017],
       [0.26375504]])

Informations additionnelles

environment files have been tested on.

Latest built version: 2025-05-26

Python version used:

'3.12.6 | packaged by conda-forge | (main, Sep 30 2024, 18:08:52) [GCC 13.3.0]'

Package	Version
affine	2.4.0
aiobotocore	2.15.1
aiohappyeyeballs	2.4.3
aiohttp	3.10.8
aioitertools	0.12.0
aiosignal	1.3.1
alembic	1.13.3
altair	5.4.1
aniso8601	9.0.1
annotated-types	0.7.0
anyio	4.9.0
appdirs	1.4.4
archspec	0.2.3
asttokens	2.4.1
attrs	24.2.0
babel	2.17.0
bcrypt	4.2.0
beautifulsoup4	4.12.3
black	24.8.0
blinker	1.8.2
blis	1.3.0
bokeh	3.5.2
boltons	24.0.0
boto3	1.35.23
botocore	1.35.23
branca	0.7.2
Brotli	1.1.0
bs4	0.0.2
cachetools	5.5.0
cartiflette	0.1.9
Cartopy	0.24.1
catalogue	2.0.10
cattrs	24.1.3
certifi	2025.4.26
cffi	1.17.1
charset-normalizer	3.3.2
chromedriver-autoinstaller	0.6.4
click	8.1.7
click-plugins	1.1.1
cligj	0.7.2
cloudpathlib	0.21.1
cloudpickle	3.0.0
colorama	0.4.6
comm	0.2.2
commonmark	0.9.1
conda	24.9.1
conda-libmamba-solver	24.7.0
conda-package-handling	2.3.0
conda_package_streaming	0.10.0
confection	0.1.5
contextily	1.6.2
contourpy	1.3.0
cryptography	43.0.1
cycler	0.12.1
cymem	2.0.11
cytoolz	1.0.0
dask	2024.9.1
dask-expr	1.1.15
databricks-sdk	0.33.0
dataclasses-json	0.6.7
debugpy	1.8.6
decorator	5.1.1
Deprecated	1.2.14
diskcache	5.6.3
distributed	2024.9.1
distro	1.9.0
docker	7.1.0
duckdb	1.1.1
en_core_web_sm	3.8.0
entrypoints	0.4
et_xmlfile	2.0.0
exceptiongroup	1.2.2
executing	2.1.0
fastexcel	0.14.0
fastjsonschema	2.21.1
fiona	1.10.1
Flask	3.0.3
folium	0.19.6
fontawesomefree	6.6.0
fonttools	4.54.1
fr_core_news_sm	3.8.0
frozendict	2.4.4
frozenlist	1.4.1
fsspec	2024.9.0
geographiclib	2.0
geopandas	1.0.1
geoplot	0.5.1
geopy	2.4.1
gitdb	4.0.11
GitPython	3.1.43
google-auth	2.35.0
graphene	3.3
graphql-core	3.2.4
graphql-relay	3.2.0
graphviz	0.20.3
great-tables	0.12.0
greenlet	3.1.1
gunicorn	22.0.0
h11	0.16.0
h2	4.1.0
hpack	4.0.0
htmltools	0.6.0
httpcore	1.0.9
httpx	0.28.1
httpx-sse	0.4.0
hyperframe	6.0.1
idna	3.10
imageio	2.37.0
importlib_metadata	8.5.0
importlib_resources	6.4.5
inflate64	1.0.1
ipykernel	6.29.5
ipython	8.28.0
itsdangerous	2.2.0
jedi	0.19.1
Jinja2	3.1.4
jmespath	1.0.1
joblib	1.4.2
jsonpatch	1.33
jsonpointer	3.0.0
jsonschema	4.23.0
jsonschema-specifications	2025.4.1
jupyter-cache	1.0.0
jupyter_client	8.6.3
jupyter_core	5.7.2
kaleido	0.2.1
kiwisolver	1.4.7
langchain	0.3.25
langchain-community	0.3.9
langchain-core	0.3.61
langchain-text-splitters	0.3.8
langcodes	3.5.0
langsmith	0.1.147
language_data	1.3.0
lazy_loader	0.4
libmambapy	1.5.9
locket	1.0.0
loguru	0.7.3
lxml	5.4.0
lz4	4.3.3
Mako	1.3.5
mamba	1.5.9
mapclassify	2.8.1
marisa-trie	1.2.1
Markdown	3.6
markdown-it-py	3.0.0
MarkupSafe	2.1.5
marshmallow	3.26.1
matplotlib	3.9.2
matplotlib-inline	0.1.7
mdurl	0.1.2
menuinst	2.1.2
mercantile	1.2.1
mizani	0.11.4
mlflow	2.16.2
mlflow-skinny	2.16.2
msgpack	1.1.0
multidict	6.1.0
multivolumefile	0.2.3
munkres	1.1.4
murmurhash	1.0.13
mypy_extensions	1.1.0
narwhals	1.41.0
nbclient	0.10.0
nbformat	5.10.4
nest_asyncio	1.6.0
networkx	3.3
nltk	3.9.1
numpy	2.1.2
opencv-python-headless	4.10.0.84
openpyxl	3.1.5
opentelemetry-api	1.16.0
opentelemetry-sdk	1.16.0
opentelemetry-semantic-conventions	0.37b0
orjson	3.10.18
outcome	1.3.0.post0
OWSLib	0.33.0
packaging	24.1
pandas	2.2.3
paramiko	3.5.0
parso	0.8.4
partd	1.4.2
pathspec	0.12.1
patsy	0.5.6
Pebble	5.1.1
pexpect	4.9.0
pickleshare	0.7.5
pillow	10.4.0
pip	24.2
platformdirs	4.3.6
plotly	5.24.1
plotnine	0.13.6
pluggy	1.5.0
polars	1.8.2
preshed	3.0.10
prometheus_client	0.21.0
prometheus_flask_exporter	0.23.1
prompt_toolkit	3.0.48
protobuf	4.25.3
psutil	6.0.0
ptyprocess	0.7.0
pure_eval	0.2.3
py7zr	0.22.0
pyarrow	17.0.0
pyarrow-hotfix	0.6
pyasn1	0.6.1
pyasn1_modules	0.4.1
pybcj	1.0.6
pycosat	0.6.6
pycparser	2.22
pycryptodomex	3.23.0
pydantic	2.11.5
pydantic_core	2.33.2
pydantic-settings	2.9.1
Pygments	2.18.0
PyNaCl	1.5.0
pynsee	0.1.8
pyogrio	0.10.0
pyOpenSSL	24.2.1
pyparsing	3.1.4
pyppmd	1.1.1
pyproj	3.7.0
pyshp	2.3.1
PySocks	1.7.1
python-dateutil	2.9.0
python-dotenv	1.0.1
python-magic	0.4.27
pytz	2024.1
pyu2f	0.1.5
pywaffle	1.1.1
PyYAML	6.0.2
pyzmq	26.2.0
pyzstd	0.16.2
querystring_parser	1.2.4
rasterio	1.4.3
referencing	0.36.2
regex	2024.9.11
requests	2.32.3
requests-cache	1.2.1
requests-toolbelt	1.0.0
retrying	1.3.4
rich	14.0.0
rpds-py	0.25.1
rsa	4.9
rtree	1.4.0
ruamel.yaml	0.18.6
ruamel.yaml.clib	0.2.8
s3fs	2024.9.0
s3transfer	0.10.2
scikit-image	0.24.0
scikit-learn	1.5.2
scipy	1.13.0
seaborn	0.13.2
selenium	4.33.0
setuptools	74.1.2
shapely	2.0.6
shellingham	1.5.4
six	1.16.0
smart-open	7.1.0
smmap	5.0.0
sniffio	1.3.1
sortedcontainers	2.4.0
soupsieve	2.5
spacy	3.8.4
spacy-legacy	3.0.12
spacy-loggers	1.0.5
SQLAlchemy	2.0.35
sqlparse	0.5.1
srsly	2.5.1
stack-data	0.6.2
statsmodels	0.14.4
tabulate	0.9.0
tblib	3.0.0
tenacity	9.0.0
texttable	1.7.0
thinc	8.3.6
threadpoolctl	3.5.0
tifffile	2025.5.24
toolz	1.0.0
topojson	1.9
tornado	6.4.1
tqdm	4.67.1
traitlets	5.14.3
trio	0.30.0
trio-websocket	0.12.2
truststore	0.9.2
typer	0.16.0
typing_extensions	4.13.2
typing-inspect	0.9.0
typing-inspection	0.4.1
tzdata	2024.2
Unidecode	1.4.0
url-normalize	2.2.1
urllib3	2.4.0
uv	0.7.8
wasabi	1.1.3
wcwidth	0.2.13
weasel	0.4.1
webdriver-manager	4.0.2
websocket-client	1.8.0
Werkzeug	3.0.4
wheel	0.44.0
wordcloud	1.9.3
wrapt	1.16.0
wsproto	1.2.0
xgboost	2.1.1
xlrd	2.0.1
xyzservices	2024.9.0
yarl	1.13.1
yellowbrick	1.5
zict	3.0.0
zipp	3.20.2
zstandard	0.23.0

View file history

md`Ce fichier a été modifié __${table_commit.length}__ fois depuis sa création le ${creation_string} (dernière modification le ${last_modification_string})`

creation = d3.min(
  table_commit.map(d => new Date(d.Date))
)

last_modification = d3.max(
  table_commit.map(d => new Date(d.Date))
)

creation_string = creation.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

last_modification_string = last_modification.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

html`<div>${git_history_table}</div>`

html`<div>${git_history_plot}</div>`

SHA	Date	Author	Description
488780a4	2024-09-25 14:32:16	Lino Galiana	Change badge (#556)
4640e6da	2024-09-18 11:53:05	linogaliana	corrections
88b030e8	2024-08-08 17:45:56	Lino Galiana	Replace by English metadata when relevant (#535)
580cba77	2024-08-07 18:59:35	Lino Galiana	Multilingual version as quarto profile (#533)
72f42bb7	2024-07-25 19:06:38	Lino Galiana	Language message on notebooks (#529)
195dc9e9	2024-07-25 11:59:19	linogaliana	Switch language button
6bf883d9	2024-07-08 15:09:21	Lino Galiana	Rename files (#518)
56b6442d	2024-07-08 15:05:57	Lino Galiana	Version anglaise du chapitre numpy (#516)
065b0abd	2024-07-08 11:19:43	Lino Galiana	Nouveaux callout dans la partie manipulation (#513)
d75641d7	2024-04-22 18:59:01	Lino Galiana	Editorialisation des chapitres de manipulation de données (#491)
005d89b8	2023-12-20 17:23:04	Lino Galiana	Finalise l’affichage des statistiques Git (#478)
16842200	2023-12-02 12:06:40	Antoine Palazzolo	Première partie de relecture de fin du cours (#467)
1f23de28	2023-12-01 17:25:36	Lino Galiana	Stockage des images sur S3 (#466)
a06a2689	2023-11-23 18:23:28	Antoine Palazzolo	2ème relectures chapitres ML (#457)
889a71ba	2023-11-10 11:40:51	Antoine Palazzolo	Modification TP 3 (#443)
a7711832	2023-10-09 11:27:45	Antoine Palazzolo	Relecture TD2 par Antoine (#418)
a63319ad	2023-10-04 15:29:04	Lino Galiana	Correction du TP numpy (#419)
e8d0062d	2023-09-26 15:54:49	Kim A	Relecture KA 25/09/2023 (#412)
154f09e4	2023-09-26 14:59:11	Antoine Palazzolo	Des typos corrigées par Antoine (#411)
a8f90c2f	2023-08-28 09:26:12	Lino Galiana	Update featured paths (#396)
80823022	2023-08-25 17:48:36	Lino Galiana	Mise à jour des scripts de construction des notebooks (#395)
3bdf3b06	2023-08-25 11:23:02	Lino Galiana	Simplification de la structure 🤓 (#393)
9e1e6e41	2023-07-20 02:27:22	Lino Galiana	Change launch script (#379)
130ed717	2023-07-18 19:37:11	Lino Galiana	Restructure les titres (#374)
ef28fefd	2023-07-07 08:14:42	Lino Galiana	Listing pour la première partie (#369)
f21a24d3	2023-07-02 10:58:15	Lino Galiana	Pipeline Quarto & Pages 🚀 (#365)
7e15843a	2023-02-13 18:57:28	Lino Galiana	from_numpy_array no longer in networkx 3.0 (#353)
a408cc96	2023-02-01 09:07:27	Lino Galiana	Ajoute bouton suggérer modification (#347)
3c880d59	2022-12-27 17:34:59	Lino Galiana	Chapitre regex + Change les boites dans plusieurs chapitres (#339)
e2b53ac9	2022-09-28 17:09:31	Lino Galiana	Retouche les chapitres pandas (#287)
d068cb6d	2022-09-24 14:58:07	Lino Galiana	Corrections avec echo true (#279)
b2d48237	2022-09-21 17:36:29	Lino Galiana	Relec KA 21/09 (#273)
a56dd451	2022-09-20 15:27:56	Lino Galiana	Fix SSPCloud links (#270)
f10815b5	2022-08-25 16:00:03	Lino Galiana	Notebooks should now look more beautiful (#260)
494a85ae	2022-08-05 14:49:56	Lino Galiana	Images featured ✨ (#252)
d201e3cd	2022-08-03 15:50:34	Lino Galiana	Pimp la homepage ✨ (#249)
1ca1a8a7	2022-05-31 11:44:23	Lino Galiana	Retour du chapitre API (#228)
4fc58e52	2022-05-25 18:29:25	Lino Galiana	Change deployment on SSP Cloud with new filesystem organization (#227)
12965bac	2022-05-25 15:53:27	Lino Galiana	:launch: Bascule vers quarto (#226)
9c71d6e7	2022-03-08 10:34:26	Lino Galiana	Plus d’éléments sur S3 (#218)
6777f038	2021-10-29 09:38:09	Lino Galiana	Notebooks corrections (#171)
2a8809fb	2021-10-27 12:05:34	Lino Galiana	Simplification des hooks pour gagner en flexibilité et clarté (#166)
26ea709d	2021-09-27 19:11:00	Lino Galiana	Règle quelques problèmes np (#154)
2fa78c9f	2021-09-27 11:24:19	Lino Galiana	Relecture de la partie numpy/pandas (#152)
85ba1194	2021-09-16 11:27:56	Lino Galiana	Relectures des TP KA avant 1er cours (#142)
2e4d5862	2021-09-02 12:03:39	Lino Galiana	Simplify badges generation (#130)
2f7b52d9	2021-07-20 17:37:03	Lino Galiana	Improve notebooks automatic creation (#120)
80877d20	2021-06-28 11:34:24	Lino Galiana	Ajout d’un exercice de NLP à partir openfood database (#98)
6729a724	2021-06-22 18:07:05	Lino Galiana	Mise à jour badge onyxia (#115)
4cdb759c	2021-05-12 10:37:23	Lino Galiana	:sparkles: :star2: Nouveau thème hugo :snake: :fire: (#105)
7f9f97bc	2021-04-30 21:44:04	Lino Galiana	🐳 + 🐍 New workflow (docker 🐳) and new dataset for modelization (2020 🇺🇸 elections) (#99)
0a0d0348	2021-03-26 20:16:22	Lino Galiana	Ajout d’une section sur S3 (#97)
6d010fa2	2020-09-29 18:45:34	Lino Galiana	Simplifie l’arborescence du site, partie 1 (#57)
66f9f87a	2020-09-24 19:23:04	Lino Galiana	Introduction des figures générées par python dans le site (#52)
edca3916	2020-09-21 19:31:02	Lino Galiana	Change np.is_nan to np.isnan
f9f00cc0	2020-09-15 21:05:54	Lino Galiana	enlève quelques TO DO
4677769b	2020-09-15 18:19:24	Lino Galiana	Nettoyage des coquilles pour premiers TP (#37)
d48e68fa	2020-09-08 18:35:07	Lino Galiana	Continuer la partie pandas (#13)
913047d3	2020-09-08 14:44:41	Lino Galiana	Harmonisation des niveaux de titre (#17)
c452b832	2020-07-28 17:32:06	Lino Galiana	TP Numpy (#9)
200b6c1f	2020-07-27 12:50:33	Lino Galiana	Encore une coquille
5041b280	2020-07-27 12:44:10	Lino Galiana	Une coquille à cause d’un bloc jupyter
e8db4cf0	2020-07-24 12:56:38	Lino Galiana	modif des markdown
b24a1fe7	2020-07-23 18:20:09	Lino Galiana	Add notebook
4f8f1caa	2020-07-23 18:19:28	Lino Galiana	fix typo
434d20e8	2020-07-23 18:18:46	Lino Galiana	Essai de yaml header
5ac02efd	2020-07-23 18:05:12	Lino Galiana	Essai de md généré avec jupytext

git_history_table = Inputs.table(
  table_commit,
  {
    format: {
      SHA: x => md`[${x}](${github_repo}/commit/${x})`,
      Description: x => md`${replacePullRequestPattern(x, github_repo)}`,
      /*Date: x => x.toLocaleString("fr", {
        "month": "numeric",
        "day": "numeric",
        "year": "numeric"
        })
      */
    }
  }
)

git_history_plot = Plot.plot({
  marks: [
    Plot.ruleY([0], {stroke: "royalblue"}),
    Plot.dot(
          table_commit,
          Plot.pointerX({x: (d) => new Date(d.date), y: 0, stroke: "red"})),
    Plot.dot(table_commit, {x: (d) => new Date(d.Date), y: 0, fill: "royalblue"})
  ]
})

function replacePullRequestPattern(inputString, githubRepo) {
    // Use a regular expression to match the pattern #digit
    var pattern = /#(\d+)/g;

    // Replace the pattern with ${github_repo}/pull/#digit
    var replacedString = inputString.replace(pattern, '[#$1](' + githubRepo + '/pull/$1)');

    return replacedString;
}

github_repo = "https://github.com/linogaliana/python-datascientist"

table_commit = {

// Get the HTML table by its class name
var table = document.querySelector('.commit-table');

// Check if the table exists
if (table) {
    // Initialize an array to store the table data
    var dataArray = [];

    // Extract headers from the first row
    var headers = [];
    for (var i = 0; i < table.rows[0].cells.length; i++) {
        headers.push(table.rows[0].cells[i].textContent.trim());
    }

    // Iterate through the rows, starting from the second row
    for (var i = 1; i < table.rows.length; i++) {
        var row = table.rows[i];
        var rowData = {};

        // Iterate through the cells in the row
        for (var j = 0; j < row.cells.length; j++) {
            // Use headers as keys and cell content as values
            rowData[headers[j]] = row.cells[j].textContent.trim();
        }

        // Push the rowData object to the dataArray
        dataArray.push(rowData);
    }
  }

  return dataArray

}

// Get the element with class 'git-details'
{
  var gitDetails = document.querySelector('.commit-table');

  // Check if the element exists
  if (gitDetails) {
      // Hide the element
      gitDetails.style.display = 'none';
  }
}

Plot = require('@observablehq/plot@0.6.12/dist/plot.umd.min.js')

Retour au sommet

Citation

BibTeX

@book{galiana2023,
  author = {Galiana, Lino},
  title = {Python pour la data science},
  date = {2023},
  url = {https://pythonds.linogaliana.fr/},
  doi = {10.5281/zenodo.8229676},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

Galiana, Lino. 2023. Python pour la data science. https://doi.org/10.5281/zenodo.8229676.