import numpy as np
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 :
Nous allons également fixer la racine du générateur aléatoire de nombres afin d’avoir des résultats reproductibles :
12345) np.random.seed(
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.
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
:
1, 2, 5]) np.array([
array([1, 2, 5])
Il est possible d’ajouter un argument dtype
pour contraindre le type du array :
"a", "z", "e"], ["r", "t"], ["y"]], dtype="object") np.array([[
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) ounp.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
ounp.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:
0, 10) np.arange(
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
0, 10, 3) np.arange(
array([0, 3, 6, 9])
0, 1, 5) np.linspace(
array([0. , 0.25, 0.5 , 0.75, 1. ])
Pour un array initialisé à 0:
10, dtype=int) np.zeros(
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
ou initialisé à 1:
3, 5), dtype=float) np.ones((
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
ou encore initialisé à 3.14:
3, 5), 3.14) np.full((
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\):
3) np.eye(
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 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:
= np.arange(10)
x 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:
- 1)] x[: (K
En l’occurrence, on sélectionne le K\(^{eme}\) élément en utilisant
- 1] x[K
Pour sélectionner uniquement un élément, on fera ainsi:
= np.arange(10)
x 2] x[
2
Les syntaxes qui permettent de sélectionner des indices particuliers d’une liste fonctionnent également avec les arrays.
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
10) np.arange(
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[:2, :2].copy() x_sub_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 :
= np.arange(10)
x = np.array([[-1, 1, -2], [-3, 2, 0]])
x2 print(x)
print(x2)
[0 1 2 3 4 5 6 7 8 9]
[[-1 1 -2]
[-3 2 0]]
== 2
x < 0 x2
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
Soit
= np.random.normal(size=10000) x
- 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
ouall
, notamment avec l’argumentaxis
;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.
= np.random.normal(0, size=(3, 4))
x = np.array([np.nan, 0, 1]) y
- Utiliser
count_nonzero
sury
- Utiliser
isnan
sury
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)
= np.random.normal(size=10) x
Pour ordonner un array, on utilise np.sort
= np.array([7, 2, 3, 1, 6, 5, 4])
x
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
:
3) np.partition(x,
array([2, 1, 3, 4, 6, 5, 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
= np.random.normal(0, size=(3, 4)) x
- 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 surx
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:
= np.array([0, 1, 2])
a = np.array([5, 5, 5])
b
+ b
a + 5 a
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
- 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 nomplt
. Utiliserplt.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 denp.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
0], X[:, 1], s=100)
plt.scatter(X[:,
# draw lines from each point to its two nearest neighbors
= 2
K
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:
*zip(X[j], X[i]), color="black") plt.plot(
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
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’appelerM
:
\[ \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 fonctiondraw
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: 2024-10-12
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 |
appdirs | 1.4.4 |
archspec | 0.2.3 |
asttokens | 2.4.1 |
attrs | 24.2.0 |
babel | 2.16.0 |
bcrypt | 4.2.0 |
beautifulsoup4 | 4.12.3 |
black | 24.8.0 |
blinker | 1.8.2 |
blis | 0.7.11 |
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.0.2 |
Cartopy | 0.24.1 |
catalogue | 2.0.10 |
cattrs | 24.1.2 |
certifi | 2024.8.30 |
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.19.0 |
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.8 |
cytoolz | 1.0.0 |
dask | 2024.9.1 |
dask-expr | 1.1.15 |
databricks-sdk | 0.33.0 |
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 | 0.10.1 |
en-core-web-sm | 3.7.1 |
entrypoints | 0.4 |
et-xmlfile | 1.1.0 |
exceptiongroup | 1.2.2 |
executing | 2.1.0 |
fastexcel | 0.11.6 |
fastjsonschema | 2.20.0 |
fiona | 1.10.1 |
Flask | 3.0.3 |
folium | 0.17.0 |
fontawesomefree | 6.6.0 |
fonttools | 4.54.1 |
fr-core-news-sm | 3.7.0 |
frozendict | 2.4.4 |
frozenlist | 1.4.1 |
fsspec | 2023.12.2 |
funcy | 2.0 |
gensim | 4.3.2 |
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.14.0 |
h2 | 4.1.0 |
hpack | 4.0.0 |
htmltools | 0.5.3 |
hyperframe | 6.0.1 |
idna | 3.10 |
imageio | 2.35.1 |
importlib_metadata | 8.5.0 |
importlib_resources | 6.4.5 |
inflate64 | 1.0.0 |
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 | 2024.10.1 |
jupyter-cache | 1.0.0 |
jupyter_client | 8.6.3 |
jupyter_core | 5.7.2 |
kaleido | 0.2.1 |
kiwisolver | 1.4.7 |
langcodes | 3.4.1 |
language_data | 1.2.0 |
lazy_loader | 0.4 |
libmambapy | 1.5.9 |
locket | 1.0.0 |
lxml | 5.3.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 |
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.10 |
mypy-extensions | 1.0.0 |
narwhals | 1.9.3 |
nbclient | 0.10.0 |
nbformat | 5.10.4 |
nest_asyncio | 1.6.0 |
networkx | 3.3 |
nltk | 3.9.1 |
numexpr | 2.10.1 |
numpy | 1.26.4 |
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 |
outcome | 1.3.0.post0 |
OWSLib | 0.28.1 |
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.0.7 |
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.9 |
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.20.8 |
pyarrow | 17.0.0 |
pyarrow-hotfix | 0.6 |
pyasn1 | 0.6.1 |
pyasn1_modules | 0.4.1 |
pybcj | 1.0.2 |
pycosat | 0.6.6 |
pycparser | 2.22 |
pycryptodomex | 3.21.0 |
pydantic | 2.9.2 |
pydantic_core | 2.23.4 |
Pygments | 2.18.0 |
pyLDAvis | 3.4.1 |
PyNaCl | 1.5.0 |
pynsee | 0.1.8 |
pyogrio | 0.10.0 |
pyOpenSSL | 24.2.1 |
pyparsing | 3.1.4 |
pyppmd | 1.1.0 |
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.1 |
referencing | 0.35.1 |
regex | 2024.9.11 |
requests | 2.32.3 |
requests-cache | 1.2.1 |
retrying | 1.3.4 |
rich | 13.9.2 |
rpds-py | 0.20.0 |
rsa | 4.9 |
Rtree | 1.3.0 |
ruamel.yaml | 0.18.6 |
ruamel.yaml.clib | 0.2.8 |
s3fs | 2023.12.2 |
s3transfer | 0.10.2 |
scikit-image | 0.24.0 |
scikit-learn | 1.5.2 |
scipy | 1.13.0 |
seaborn | 0.13.2 |
selenium | 4.25.0 |
setuptools | 74.1.2 |
shapely | 2.0.6 |
shellingham | 1.5.4 |
six | 1.16.0 |
smart-open | 7.0.5 |
smmap | 5.0.0 |
sniffio | 1.3.1 |
sortedcontainers | 2.4.0 |
soupsieve | 2.5 |
spacy | 3.7.5 |
spacy-legacy | 3.0.12 |
spacy-loggers | 1.0.5 |
SQLAlchemy | 2.0.35 |
sqlparse | 0.5.1 |
srsly | 2.4.8 |
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.2.5 |
threadpoolctl | 3.5.0 |
tifffile | 2024.9.20 |
toolz | 1.0.0 |
topojson | 1.9 |
tornado | 6.4.1 |
tqdm | 4.66.5 |
traitlets | 5.14.3 |
trio | 0.26.2 |
trio-websocket | 0.11.1 |
truststore | 0.9.2 |
typer | 0.12.5 |
typing_extensions | 4.12.2 |
tzdata | 2024.2 |
Unidecode | 1.3.8 |
url-normalize | 1.4.3 |
urllib3 | 1.26.20 |
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
SHA | Date | Author | Description |
---|---|---|---|
488780a | 2024-09-25 14:32:16 | Lino Galiana | Change badge (#556) |
4640e6d | 2024-09-18 11:53:05 | linogaliana | corrections |
88b030e | 2024-08-08 17:45:56 | Lino Galiana | Replace by English metadata when relevant (#535) |
580cba7 | 2024-08-07 18:59:35 | Lino Galiana | Multilingual version as quarto profile (#533) |
72f42bb | 2024-07-25 19:06:38 | Lino Galiana | Language message on notebooks (#529) |
195dc9e | 2024-07-25 11:59:19 | linogaliana | Switch language button |
6bf883d | 2024-07-08 15:09:21 | Lino Galiana | Rename files (#518) |
56b6442 | 2024-07-08 15:05:57 | Lino Galiana | Version anglaise du chapitre numpy (#516) |
065b0ab | 2024-07-08 11:19:43 | Lino Galiana | Nouveaux callout dans la partie manipulation (#513) |
d75641d | 2024-04-22 18:59:01 | Lino Galiana | Editorialisation des chapitres de manipulation de données (#491) |
005d89b | 2023-12-20 17:23:04 | Lino Galiana | Finalise l’affichage des statistiques Git (#478) |
1684220 | 2023-12-02 12:06:40 | Antoine Palazzolo | Première partie de relecture de fin du cours (#467) |
1f23de2 | 2023-12-01 17:25:36 | Lino Galiana | Stockage des images sur S3 (#466) |
a06a268 | 2023-11-23 18:23:28 | Antoine Palazzolo | 2ème relectures chapitres ML (#457) |
889a71b | 2023-11-10 11:40:51 | Antoine Palazzolo | Modification TP 3 (#443) |
a771183 | 2023-10-09 11:27:45 | Antoine Palazzolo | Relecture TD2 par Antoine (#418) |
a63319a | 2023-10-04 15:29:04 | Lino Galiana | Correction du TP numpy (#419) |
e8d0062 | 2023-09-26 15:54:49 | Kim A | Relecture KA 25/09/2023 (#412) |
154f09e | 2023-09-26 14:59:11 | Antoine Palazzolo | Des typos corrigées par Antoine (#411) |
a8f90c2 | 2023-08-28 09:26:12 | Lino Galiana | Update featured paths (#396) |
8082302 | 2023-08-25 17:48:36 | Lino Galiana | Mise à jour des scripts de construction des notebooks (#395) |
3bdf3b0 | 2023-08-25 11:23:02 | Lino Galiana | Simplification de la structure 🤓 (#393) |
9e1e6e4 | 2023-07-20 02:27:22 | Lino Galiana | Change launch script (#379) |
130ed71 | 2023-07-18 19:37:11 | Lino Galiana | Restructure les titres (#374) |
ef28fef | 2023-07-07 08:14:42 | Lino Galiana | Listing pour la première partie (#369) |
f21a24d | 2023-07-02 10:58:15 | Lino Galiana | Pipeline Quarto & Pages 🚀 (#365) |
7e15843 | 2023-02-13 18:57:28 | Lino Galiana | from_numpy_array no longer in networkx 3.0 (#353) |
a408cc9 | 2023-02-01 09:07:27 | Lino Galiana | Ajoute bouton suggérer modification (#347) |
3c880d5 | 2022-12-27 17:34:59 | Lino Galiana | Chapitre regex + Change les boites dans plusieurs chapitres (#339) |
e2b53ac | 2022-09-28 17:09:31 | Lino Galiana | Retouche les chapitres pandas (#287) |
d068cb6 | 2022-09-24 14:58:07 | Lino Galiana | Corrections avec echo true (#279) |
b2d4823 | 2022-09-21 17:36:29 | Lino Galiana | Relec KA 21/09 (#273) |
a56dd45 | 2022-09-20 15:27:56 | Lino Galiana | Fix SSPCloud links (#270) |
f10815b | 2022-08-25 16:00:03 | Lino Galiana | Notebooks should now look more beautiful (#260) |
494a85a | 2022-08-05 14:49:56 | Lino Galiana | Images featured ✨ (#252) |
d201e3c | 2022-08-03 15:50:34 | Lino Galiana | Pimp la homepage ✨ (#249) |
1ca1a8a | 2022-05-31 11:44:23 | Lino Galiana | Retour du chapitre API (#228) |
4fc58e5 | 2022-05-25 18:29:25 | Lino Galiana | Change deployment on SSP Cloud with new filesystem organization (#227) |
12965ba | 2022-05-25 15:53:27 | Lino Galiana | :launch: Bascule vers quarto (#226) |
9c71d6e | 2022-03-08 10:34:26 | Lino Galiana | Plus d’éléments sur S3 (#218) |
6777f03 | 2021-10-29 09:38:09 | Lino Galiana | Notebooks corrections (#171) |
2a8809f | 2021-10-27 12:05:34 | Lino Galiana | Simplification des hooks pour gagner en flexibilité et clarté (#166) |
26ea709 | 2021-09-27 19:11:00 | Lino Galiana | Règle quelques problèmes np (#154) |
2fa78c9 | 2021-09-27 11:24:19 | Lino Galiana | Relecture de la partie numpy/pandas (#152) |
85ba119 | 2021-09-16 11:27:56 | Lino Galiana | Relectures des TP KA avant 1er cours (#142) |
2e4d586 | 2021-09-02 12:03:39 | Lino Galiana | Simplify badges generation (#130) |
2f7b52d | 2021-07-20 17:37:03 | Lino Galiana | Improve notebooks automatic creation (#120) |
80877d2 | 2021-06-28 11:34:24 | Lino Galiana | Ajout d’un exercice de NLP à partir openfood database (#98) |
6729a72 | 2021-06-22 18:07:05 | Lino Galiana | Mise à jour badge onyxia (#115) |
4cdb759 | 2021-05-12 10:37:23 | Lino Galiana | :sparkles: :star2: Nouveau thème hugo :snake: :fire: (#105) |
7f9f97b | 2021-04-30 21:44:04 | Lino Galiana | 🐳 + 🐍 New workflow (docker 🐳) and new dataset for modelization (2020 🇺🇸 elections) (#99) |
0a0d034 | 2021-03-26 20:16:22 | Lino Galiana | Ajout d’une section sur S3 (#97) |
6d010fa | 2020-09-29 18:45:34 | Lino Galiana | Simplifie l’arborescence du site, partie 1 (#57) |
66f9f87 | 2020-09-24 19:23:04 | Lino Galiana | Introduction des figures générées par python dans le site (#52) |
edca391 | 2020-09-21 19:31:02 | Lino Galiana | Change np.is_nan to np.isnan |
f9f00cc | 2020-09-15 21:05:54 | Lino Galiana | enlève quelques TO DO |
4677769 | 2020-09-15 18:19:24 | Lino Galiana | Nettoyage des coquilles pour premiers TP (#37) |
d48e68f | 2020-09-08 18:35:07 | Lino Galiana | Continuer la partie pandas (#13) |
913047d | 2020-09-08 14:44:41 | Lino Galiana | Harmonisation des niveaux de titre (#17) |
c452b83 | 2020-07-28 17:32:06 | Lino Galiana | TP Numpy (#9) |
200b6c1 | 2020-07-27 12:50:33 | Lino Galiana | Encore une coquille |
5041b28 | 2020-07-27 12:44:10 | Lino Galiana | Une coquille à cause d’un bloc jupyter |
e8db4cf | 2020-07-24 12:56:38 | Lino Galiana | modif des markdown |
b24a1fe | 2020-07-23 18:20:09 | Lino Galiana | Add notebook |
4f8f1ca | 2020-07-23 18:19:28 | Lino Galiana | fix typo |
434d20e | 2020-07-23 18:18:46 | Lino Galiana | Essai de yaml header |
5ac02ef | 2020-07-23 18:05:12 | Lino Galiana | Essai de md généré avec jupytext |
Citation
@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}
}