Pandas et Numpy sont
essentiels pour manipuler les données.
Néanmoins, il est nécessaire de ne pas faire l’impasse sur les fondements
du langage Python. Une bonne compréhension des éléments structurants le
langage entraîne une plus grande productivité et liberté.
Ce chapitre est inspiré du matériel qui était proposé par Xavier Dupré, le précédent professeur de ce cours.
Voir aussi Essential Cheat Sheets for Machine Learning and Deep Learning Engineers.
1 Les quelques règles de Python
Python est un peu susceptible et protocolaire, plus formaliste que ne l’est R.
Il y a ainsi quelques règles à respecter :
Règle 1: L’indentation est primordiale : un code mal indenté provoque une erreur. L’indentation indique à l’interpréteur où se trouvent les séparations entre des blocs d’instructions. Un peu comme des points dans un texte.
Si les lignes ne sont pas bien alignées, l’interpréteur ne sait plus à quel
bloc associer la ligne. Par exemple, le corps d’une fonction doit être indenté
d’un niveau ; les éléments dans une clause logique (if, else, etc.) également.
Règle 2: On commence à compter à 0, comme dans beaucoup de langages
(C++, java…). Python diffère dans ce domaine de R où on commence
à compter à 1.
Le premier élément d’une liste est ainsi, en Python, le 0-ème.
Règle 3: Comme dans une langue naturelle, les marques de ponctuation sont importantes :
- Pour une liste :
[] - Pour un dictionnaire :
{} - Pour un tuple :
() - Pour séparer des éléments
:, - Pour commenter un bout de code :
# - Pour aller à la ligne dans un bloc d’instructions :
\ - Les majuscules et minuscules sont importantes
- Par contre l’usage des
'ou des"est indifférent. Il faut juste avoir les mêmes début et fin. - Pour documenter une fonction ou une classe ““” mon texte de documentation “““
2 Les outputs de Python : l’opération, le print et le return
Quand Python réalise des opérations, il faut lui préciser ce qu’il doit en faire :
- est-ce qu’il doit juste faire l’opération,
- afficher le résultat de l’opération,
- créer un objet avec le résultat de l’opération ?
Note
Dans l’environnement Jupyter Notebook, le dernier élement d’une cellule
est automatiquement affiché (print), qu’on lui demande ou non de le faire.
Ce comportement est particulièrement pratique pour afficher des figures
générées via matplotlib ou seaborn.
Ce comportement
n’est pas le cas dans un éditeur classique comme VisualStudio,
Spyder ou PyCharm. Pour afficher un résultat dans la console,
il faut utiliser
print ou la commande consacrée (par exemple plt.show()
pour afficher la dernière figure générée par matplotlib)
2.1 Le print
# on calcule : dans le cas d'une opération par exemple une somme
2 + 3 # Python calcule le résultat mais n'affiche rien dans la sortie
# le print : on affiche
print(2 + 3) # Python calcule et on lui demande juste de l'afficher
# le résultat est en dessous du code5# le print dans une fonction
def addition_v1(a, b):
print(a + b)
resultat_print = addition_v1(2, 0)
print(type(resultat_print))
# dans la sortie on a l'affichage du résultat, car la sortie de la fonction est un print
# en plus on lui demande quel est le type du résultat. Un print ne renvoie aucun type, ce n'est ni un numérique,
# ni une chaine de charactères, le résultat d'un print n'est pas un format utilisable2
<class 'NoneType'>Le résultat de l’addition est affiché
car la fonction addition_v1 effectue un print
Par contre, l’objet créé n’a pas de type, il n’est pas un chiffre, ce n’est qu’un affichage.
2.2 Le return
Pour créer un objet avec le résultat de la fonction, il faut utiliser return
# le return dans une fonction
def addition_v2(a, b):
return a + b
resultat_return = addition_v2(2, 5) #
print(type(resultat_return))
## là on a bien un résultat qui est du type "entier"<class 'int'>Le résultat de addition_v2 n’est pas affiché comme dans addition_v1
Par contre, la fonction addition_v2 permet d’avoir un objet de type int,
un entier donc.
3 Les types de base : variables, listes, dictionnaires…
Python permet de manipuler différents types de base. Nous en
verrons des extensions dans la suite du cours (np.array par exemple)
qui, d’une manière ou d’une autre, s’appuient sur ces types de base.
On distingue deux types de variables : les immuables (immutables) qui ne peuvent être modifiés et les modifiables (mutables)
3.1 Les variables immuables
Les variables immuables ne peuvent être modifiées
None: ce type est une convention de programmation pour dire que la valeur n’est pas calculéebool: un booléenint: un entierfloat: un réelstr: une chaine de caractèrestuple: un vecteur
i = 3 # entier = type numérique (type int)
r = 3.3 # réel = type numérique (type float)
s = "exemple" # chaîne de caractères = type str
n = None # None signifie que la variable existe mais qu'elle ne contient rien
# elle est souvent utilisée pour signifier qu'il n'y a pas de résultat
a = (1, 2) # tuple
print(i, r, s, n, a)3 3.3 exemple None (1, 2)Si on essaie de changer le premier élément de la chaine de caractères s on va avoir un peu de mal.
Par exemple si on voulait mettre une majuscule à “exemple”,
on aurait envie d’écrire que le premier élément de la chaine s est “E” majuscule
Mais Python ne va pas nous laisser faire, il nous dit que les objets “chaine de caractère” ne peuvent être modifiés
s[0] = "E" # déclenche une exceptionTypeError: 'str' object does not support item assignmentTout ce qu’on peut faire avec une variable immuable, c’est la réaffecter à une autre valeur : elle ne peut pas être modifiée.
Pour s’en convaincre, utilisons la fonction id() qui donne un identifiant à chaque objet.
print(s)
id(s)exemple140082658693296s = "autre_mot"
id(s)140082658690544On voit bien que s a changé d’identifiant : il peut avoir le même nom, ce n’est plus le même objet
3.2 Les types modifiable : listes et dictionnaires
Heureusement, il existe des variables modifiables comme les listes et les dictionnaires.
3.2.1 Les listes - elles s’écrivent entre [ ]
Les listes sont des élements très utiles, notamment quand vous souhaitez faire des boucles.
Pour faire appel aux élements d’une liste, on donne leur position dans la liste : le 1er est le 0, le 2ème est le 1 …
ma_liste = [1, 2, 3, 4]
print("La longueur de ma liste est de", len(ma_liste))
print("Le premier élément de ma liste est :", ma_liste[0])
print("Le dernier élément de ma liste est :", ma_liste[3])
print("Le dernier élément de ma liste est :", ma_liste[-1])La longueur de ma liste est de 4
Le premier élément de ma liste est : 1
Le dernier élément de ma liste est : 4
Le dernier élément de ma liste est : 4Pour effectuer des boucles sur les listes, la méthode la plus lisible
est d’utiliser les list comprehension. Cette approche consiste
à itérer les éléments d’une liste à la volée.
Par exemple, si on reprend cet exemple,
un code qui repose sur les list comprehension sera le suivant :
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x for x in fruits if "a" in x]
print(newlist)['apple', 'banana', 'mango']Le même code, ne reposant pas sur les compréhensions de liste, sera beaucoup moins concis et ainsi inutilement verbeux:
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
for x in fruits:
if "a" in x:
newlist.append(x)
print(newlist)['apple', 'banana', 'mango']3.2.2 Les dictionnaires - ils s’écrivent entre accolades {}
Un dictionnaire associe à une clé un autre élément, appelé une valeur : un chiffre, un nom, une liste, un autre dictionnaire etc.
Le format d’un dictionnaire est le suivant : {Clé : valeur}. Il s’agit
d’un objet très pratique pour la recherche, beaucoup plus que les listes
qui ne permettent pas de stocker de l’information diverse de manière
hiérarchisée.
3.2.3 Dictionnaire avec des valeurs int
On peut par exemple associer à un nom, un nombre
mon_dictionnaire_notes = {"Nicolas": 18, "Pimprenelle": 15}
# un dictionnaire qui à chaque nom associe un nombre
# à Nicolas, on associe 18
print(mon_dictionnaire_notes){'Nicolas': 18, 'Pimprenelle': 15}3.2.4 Dictionnaire avec des valeurs qui sont des listes
Pour chaque clé d’un dictionnaire, il ne faut pas forcément garder la même forme de valeur
Dans l’exemple, la valeur de la clé “Nicolas” est une liste, alors que celle de “Philou” est une liste de liste
mon_dictionnaire_loisirs = {
"Nicolas": ["Rugby", "Pastis", "Belote"],
"Pimprenelle": ["Gin Rami", "Tisane", "Tara Jarmon", "Barcelone", "Mickey Mouse"],
"Philou": [["Maths", "Jeux"], ["Guillaume", "Jeanne", "Thimothée", "Adrien"]],
}Pour accéder à un élément du dictionnaire, on fait appel à la clé et non plus à la position, comme c’était le cas dans les listes. C’est beaucoup plus pratique pour rechercher de l’information:
print(mon_dictionnaire_loisirs["Nicolas"]) # on affiche une liste['Rugby', 'Pastis', 'Belote']print(mon_dictionnaire_loisirs["Philou"]) # on affiche une liste de listes[['Maths', 'Jeux'], ['Guillaume', 'Jeanne', 'Thimothée', 'Adrien']]Si on ne veut avoir que la première liste des loisirs de Philou, on demande le premier élément de la liste
print(mon_dictionnaire_loisirs["Philou"][0]) # on affiche alors juste la première liste['Maths', 'Jeux']On peut aussi avoir des valeurs qui sont des int et des list
mon_dictionnaire_patchwork_good = {
"Nicolas": ["Rugby", "Pastis", "Belote"],
"Pimprenelle": 18,
}3.3 A retenir
- L’indentation du code est importante (4 espaces et pas une tabulation)
- Une liste est entre [] et on peut appeler les positions par leur place
- Un dictionnaire, clé x valeur, s’écrit entre {} et on appelle un élément en fonction de la clé
4 Questions pratiques :
Exercice
- Quelle est la position de 7 dans la liste suivante
liste_nombres = [1, 2, 7, 5, 3]- Combien de clés a ce dictionnaire ?
dictionnaire_evangile = {
"Marc": "Lion",
"Matthieu": ["Ange", "Homme ailé"],
"Jean": "Aigle",
"Luc": "Taureau",
}- Que faut-il écrire pour obtenir “Ange” en résultat à partir du
dictionnaire_evangile?
5 Effectuer des opérations sur les objets de base Python
Maintenant qu’on a vu quels objets existent en Python,
nous allons
voir comment nous en servir.
Pour comprendre comment modifier un objet, il convient
de distinguer deux concepts, développés plus amplement
dans le chapitre dédié : les attributs et les méthodes :
- Les attributs décrivent la structure interne d’un objet. Par exemple, la taille d’un objet, sa langue, etc. Nous n’allons pas trop développer ce concept ici. Le chapitre dédié au sujet permettra de plus développer ce concept.
- Les méthodes correspondent à des actions qui s’appliqueront à l’objet et s’adaptent à sa structure.
La même méthode (par exemple
append) fonctionnera ainsi de manière différente selon le type d’objet.
5.1 Premiers exemples de méthodes
Avec les éléments définis dans la partie 1 (les listes, les dictionnaires) on peut faire appel à des méthodes qui sont directement liées à ces objets.
5.1.1 Une méthode pour les listes
Pour ajouter un élément (item) dans une liste : on va utiliser la méthode .append()
ma_liste = ["Nicolas", "Michel", "Bernard"]
ma_liste.append("Philippe")
print(ma_liste)['Nicolas', 'Michel', 'Bernard', 'Philippe']5.1.2 Une méthode pour les dictionnaires
Pour connaitre l’ensemble des clés d’un dictionnaire, on appelle la méthode .keys()
mon_dictionnaire = {
"Marc": "Lion",
"Matthieu": ["Ange", "Homme ailé"],
"Jean": "Aigle",
"Luc": "Taureau",
}
print(mon_dictionnaire.keys())dict_keys(['Marc', 'Matthieu', 'Jean', 'Luc'])5.2 Connaitre les méthodes d’un objet
Pour savoir quelles sont les méthodes d’un objet vous pouvez :
- taper
help(mon_objet)oumon_objet?dans la consolePython - taper mon_objet. + touche tabulation dans la console
Pythonou dans leNotebook.Pythonpermet la complétion, c’est-à-dire que vous pouvez faire appaître la liste des méthodes possibles.
6 Les opérations et méthodes classiques des listes
6.1 Créer une liste
Pour créer un objet de la classe list, il suffit de le déclarer. Ici on affecte à x une liste
x = [4, 5] # création d’une liste composée de deux entiers
x = ["un", 1, "deux", 2] # création d’une liste composée de 2 chaînes de caractères
# et de deux entiers, l’ordre d’écriture est important
x = [3] # création d’une liste d’un élément, sans la virgule,
x = [] # crée une liste vide
x = list() # crée une liste vide6.2 Un premier test sur les listes
Si on veut tester la présence d’un élément dans une liste, on l’écrit de la manière suivante :
# Exemple
x = "Marcel"
l = ["Marcel", "Edith", "Maurice", "Jean"]
print(x in l)
# vrai si x est un des éléments de lTrue6.3 +: une méthode pour concaténer deux listes
On utilise le symbole +
t = ["Antoine", "David"]
print(l + t) # concaténation de l et t['Marcel', 'Edith', 'Maurice', 'Jean', 'Antoine', 'David']6.4 Pour trouver certains éléments d’une liste
Pour chercher des élements dans une liste, on utilise la position dans la liste.
l[1] # donne l'élément qui est en 2ème position de la liste'Edith'l[1:3] # donne les éléments de la 2ème position de la liste à la 4ème exclue['Edith', 'Maurice']6.5 Quelques fonctions des listes
Les listes embarquent ainsi nativement un certain nombre de méthodes qui sont pratiques. Cependant, pour avoir certaines informations sur une liste, il faut parfois plutôt passer par des fonctions natives comme les suivantes :
longueur = len(l) # nombre d’éléments de l
minimum = min(l) # plus petit élément de l, ici par ordre alphabétique
maximum = max(l) # plus grand élément de l, ici par ordre alphabétique
print(longueur, minimum, maximum)4 Edith Mauricedel l[0:2] # supprime les éléments entre la position 0 et 2 exclue
print(l)['Maurice', 'Jean']6.6 Les méthodes des listes
On les trouve dans l’aide de la liste. On distingue les méthodes et les méthodes spéciales : visuellement, les méthodes spéciales sont celles qui précédées et suivis de deux caractères de soulignement, les autres sont des méthodes classiques.
help(l)Help on list object:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
6.7 A retenir et questions
A retenir :
- Chaque objet
Pythona des attributs et des méthodes - Vous pouvez créer des classes avec des attributs et des méthodes
- Les méthodes des listes et des dictionnaires qui sont les plus utilisées :
list.count()list.sort()list.append()dict.keys()dict.items()dict.values()
Exercice 2
- Définir la liste allant de 1 à 10, puis effectuez les actions suivantes :
- triez et affichez la liste
- ajoutez l’élément 11 à la liste et affichez la liste
- renversez et affichez la liste
- affichez l’élément d’indice 7
- enlevez l’élément 9 et affichez la liste
- affichez la sous-liste du 2e au 3e éléments inclus ;
- affichez la sous-liste du début au 2e élément inclus ;
- affichez la sous-liste du 3e élément à la fin de la liste ;
- Construire le dictionnaire des 6 premiers mois de l’année avec comme valeurs le nombre de jours respectif.
- Renvoyer la liste des mois
- Renvoyer la liste des jours
- Ajoutez la clé du mois de Juillet
7 Passer des listes et dictionnaires à Pandas
Supposons que la variable data est une liste qui contient nos données.
Une observation correspond à un dictionnaire qui contient le nom, le type, l’ambiance et la note d’un restaurant.
Il est aisé de transformer cette liste en dataframe grâce à la fonction ‘DataFrame’.
import pandas
data = [
{"nom": "Little Pub", "type": "Bar", "ambiance": 9, "note": 7},
{"nom": "Le Corse", "type": "Sandwicherie", "ambiance": 2, "note": 8},
{"nom": "Café Caumartin", "type": "Bar", "ambiance": 1},
]
df = pandas.DataFrame(data)
print(data)
df[{'nom': 'Little Pub', 'type': 'Bar', 'ambiance': 9, 'note': 7}, {'nom': 'Le Corse', 'type': 'Sandwicherie', 'ambiance': 2, 'note': 8}, {'nom': 'Café Caumartin', 'type': 'Bar', 'ambiance': 1}]| nom | type | ambiance | note | |
|---|---|---|---|---|
| 0 | Little Pub | Bar | 9 | 7.0 |
| 1 | Le Corse | Sandwicherie | 2 | 8.0 |
| 2 | Café Caumartin | Bar | 1 | NaN |
Informations additionnelles
environment files have been tested on.
Latest built version: 2024-04-27
Python version used:
'3.11.6 | packaged by conda-forge | (main, Oct 3 2023, 10:40:35) [GCC 12.3.0]'| Package | Version |
|---|---|
| affine | 2.4.0 |
| aiobotocore | 2.12.2 |
| aiohttp | 3.9.3 |
| aioitertools | 0.11.0 |
| aiosignal | 1.3.1 |
| alembic | 1.13.1 |
| aniso8601 | 9.0.1 |
| annotated-types | 0.6.0 |
| appdirs | 1.4.4 |
| archspec | 0.2.3 |
| astroid | 3.1.0 |
| asttokens | 2.4.1 |
| attrs | 23.2.0 |
| Babel | 2.14.0 |
| bcrypt | 4.1.2 |
| beautifulsoup4 | 4.12.3 |
| black | 24.4.2 |
| blinker | 1.7.0 |
| blis | 0.7.11 |
| bokeh | 3.4.0 |
| boltons | 23.1.1 |
| boto3 | 1.34.51 |
| botocore | 1.34.51 |
| branca | 0.7.1 |
| Brotli | 1.1.0 |
| cachetools | 5.3.3 |
| cartiflette | 0.0.2 |
| Cartopy | 0.23.0 |
| catalogue | 2.0.10 |
| cattrs | 23.2.3 |
| certifi | 2024.2.2 |
| cffi | 1.16.0 |
| charset-normalizer | 3.3.2 |
| click | 8.1.7 |
| click-plugins | 1.1.1 |
| cligj | 0.7.2 |
| cloudpathlib | 0.16.0 |
| cloudpickle | 3.0.0 |
| colorama | 0.4.6 |
| comm | 0.2.2 |
| commonmark | 0.9.1 |
| conda | 24.3.0 |
| conda-libmamba-solver | 24.1.0 |
| conda-package-handling | 2.2.0 |
| conda_package_streaming | 0.9.0 |
| confection | 0.1.4 |
| contextily | 1.6.0 |
| contourpy | 1.2.1 |
| cryptography | 42.0.5 |
| cycler | 0.12.1 |
| cymem | 2.0.8 |
| cytoolz | 0.12.3 |
| dask | 2024.4.1 |
| dask-expr | 1.0.10 |
| debugpy | 1.8.1 |
| decorator | 5.1.1 |
| dill | 0.3.8 |
| distributed | 2024.4.1 |
| distro | 1.9.0 |
| docker | 7.0.0 |
| duckdb | 0.10.1 |
| en-core-web-sm | 3.7.1 |
| entrypoints | 0.4 |
| et-xmlfile | 1.1.0 |
| exceptiongroup | 1.2.0 |
| executing | 2.0.1 |
| fastjsonschema | 2.19.1 |
| fiona | 1.9.6 |
| flake8 | 7.0.0 |
| Flask | 3.0.2 |
| folium | 0.16.0 |
| fontawesomefree | 6.5.1 |
| fonttools | 4.51.0 |
| frozenlist | 1.4.1 |
| fsspec | 2023.12.2 |
| GDAL | 3.8.4 |
| gensim | 4.3.2 |
| geographiclib | 2.0 |
| geopandas | 0.12.2 |
| geoplot | 0.5.1 |
| geopy | 2.4.1 |
| gitdb | 4.0.11 |
| GitPython | 3.1.43 |
| google-auth | 2.29.0 |
| graphene | 3.3 |
| graphql-core | 3.2.3 |
| graphql-relay | 3.2.0 |
| graphviz | 0.20.3 |
| great-tables | 0.5.0 |
| greenlet | 3.0.3 |
| gunicorn | 21.2.0 |
| htmltools | 0.5.1 |
| hvac | 2.1.0 |
| idna | 3.6 |
| imageio | 2.34.1 |
| importlib_metadata | 7.1.0 |
| importlib_resources | 6.4.0 |
| inflate64 | 1.0.0 |
| ipykernel | 6.29.3 |
| ipython | 8.22.2 |
| ipywidgets | 8.1.2 |
| isort | 5.13.2 |
| itsdangerous | 2.1.2 |
| jedi | 0.19.1 |
| Jinja2 | 3.1.3 |
| jmespath | 1.0.1 |
| joblib | 1.3.2 |
| jsonpatch | 1.33 |
| jsonpointer | 2.4 |
| jsonschema | 4.21.1 |
| jsonschema-specifications | 2023.12.1 |
| jupyter-cache | 1.0.0 |
| jupyter_client | 8.6.1 |
| jupyter_core | 5.7.2 |
| jupyterlab_widgets | 3.0.10 |
| kaleido | 0.2.1 |
| kiwisolver | 1.4.5 |
| kubernetes | 29.0.0 |
| langcodes | 3.4.0 |
| language_data | 1.2.0 |
| lazy_loader | 0.4 |
| libmambapy | 1.5.7 |
| llvmlite | 0.42.0 |
| locket | 1.0.0 |
| lxml | 5.2.1 |
| lz4 | 4.3.3 |
| Mako | 1.3.2 |
| mamba | 1.5.7 |
| mapclassify | 2.6.1 |
| marisa-trie | 1.1.0 |
| Markdown | 3.6 |
| MarkupSafe | 2.1.5 |
| matplotlib | 3.8.3 |
| matplotlib-inline | 0.1.6 |
| mccabe | 0.7.0 |
| menuinst | 2.0.2 |
| mercantile | 1.2.1 |
| mizani | 0.11.2 |
| mlflow | 2.11.3 |
| mlflow-skinny | 2.11.3 |
| msgpack | 1.0.7 |
| multidict | 6.0.5 |
| multivolumefile | 0.2.3 |
| munkres | 1.1.4 |
| murmurhash | 1.0.10 |
| mypy | 1.9.0 |
| mypy-extensions | 1.0.0 |
| nbclient | 0.10.0 |
| nbformat | 5.10.4 |
| nest_asyncio | 1.6.0 |
| networkx | 3.3 |
| nltk | 3.8.1 |
| numba | 0.59.1 |
| numpy | 1.26.4 |
| oauthlib | 3.2.2 |
| opencv-python-headless | 4.9.0.80 |
| openpyxl | 3.1.2 |
| OWSLib | 0.28.1 |
| packaging | 23.2 |
| pandas | 2.2.1 |
| paramiko | 3.4.0 |
| parso | 0.8.4 |
| partd | 1.4.1 |
| pathspec | 0.12.1 |
| patsy | 0.5.6 |
| Pebble | 5.0.7 |
| pexpect | 4.9.0 |
| pickleshare | 0.7.5 |
| pillow | 10.3.0 |
| pip | 24.0 |
| pkgutil_resolve_name | 1.3.10 |
| platformdirs | 4.2.0 |
| plotly | 5.19.0 |
| plotnine | 0.13.5 |
| pluggy | 1.4.0 |
| polars | 0.20.18 |
| preshed | 3.0.9 |
| prometheus_client | 0.20.0 |
| prometheus-flask-exporter | 0.23.0 |
| prompt-toolkit | 3.0.42 |
| protobuf | 4.25.3 |
| psutil | 5.9.8 |
| ptyprocess | 0.7.0 |
| pure-eval | 0.2.2 |
| py7zr | 0.20.8 |
| pyarrow | 15.0.0 |
| pyarrow-hotfix | 0.6 |
| pyasn1 | 0.5.1 |
| pyasn1-modules | 0.3.0 |
| pybcj | 1.0.2 |
| pycodestyle | 2.11.1 |
| pycosat | 0.6.6 |
| pycparser | 2.21 |
| pycryptodomex | 3.20.0 |
| pydantic | 2.7.1 |
| pydantic_core | 2.18.2 |
| pyflakes | 3.2.0 |
| Pygments | 2.17.2 |
| PyJWT | 2.8.0 |
| pylint | 3.1.0 |
| PyNaCl | 1.5.0 |
| pynsee | 0.1.7 |
| pyOpenSSL | 24.0.0 |
| pyparsing | 3.1.2 |
| pyppmd | 1.1.0 |
| pyproj | 3.6.1 |
| 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.0 |
| PyYAML | 6.0.1 |
| pyzmq | 25.1.2 |
| pyzstd | 0.15.10 |
| QtPy | 2.4.1 |
| querystring-parser | 1.2.4 |
| rasterio | 1.3.10 |
| referencing | 0.34.0 |
| regex | 2023.12.25 |
| requests | 2.31.0 |
| requests-cache | 1.2.0 |
| requests-oauthlib | 2.0.0 |
| rpds-py | 0.18.0 |
| rsa | 4.9 |
| Rtree | 1.2.0 |
| ruamel.yaml | 0.18.6 |
| ruamel.yaml.clib | 0.2.8 |
| s3fs | 2023.12.2 |
| s3transfer | 0.10.1 |
| scikit-image | 0.23.2 |
| scikit-learn | 1.4.1.post1 |
| scipy | 1.13.0 |
| seaborn | 0.13.2 |
| setuptools | 69.2.0 |
| shapely | 2.0.3 |
| six | 1.16.0 |
| smart-open | 6.4.0 |
| smmap | 5.0.0 |
| snuggs | 1.4.7 |
| sortedcontainers | 2.4.0 |
| soupsieve | 2.5 |
| spacy | 3.7.4 |
| spacy-legacy | 3.0.12 |
| spacy-loggers | 1.0.5 |
| SQLAlchemy | 2.0.29 |
| sqlparse | 0.4.4 |
| srsly | 2.4.8 |
| stack-data | 0.6.2 |
| statsmodels | 0.14.1 |
| tabulate | 0.9.0 |
| tblib | 3.0.0 |
| tenacity | 8.2.3 |
| texttable | 1.7.0 |
| thinc | 8.2.3 |
| threadpoolctl | 3.4.0 |
| tifffile | 2024.4.24 |
| tomli | 2.0.1 |
| tomlkit | 0.12.4 |
| toolz | 0.12.1 |
| topojson | 1.8 |
| tornado | 6.4 |
| tqdm | 4.66.2 |
| traitlets | 5.14.2 |
| truststore | 0.8.0 |
| typer | 0.9.4 |
| typing_extensions | 4.11.0 |
| tzdata | 2024.1 |
| Unidecode | 1.3.8 |
| url-normalize | 1.4.3 |
| urllib3 | 1.26.18 |
| wasabi | 1.1.2 |
| wcwidth | 0.2.13 |
| weasel | 0.3.4 |
| webcolors | 1.13 |
| webdriver-manager | 4.0.1 |
| websocket-client | 1.7.0 |
| Werkzeug | 3.0.2 |
| wheel | 0.43.0 |
| widgetsnbextension | 4.0.10 |
| wordcloud | 1.9.3 |
| wrapt | 1.16.0 |
| xgboost | 2.0.3 |
| xlrd | 2.0.1 |
| xyzservices | 2024.4.0 |
| yarl | 1.9.4 |
| yellowbrick | 1.5 |
| zict | 3.0.0 |
| zipp | 3.17.0 |
| zstandard | 0.22.0 |
View file history
| SHA | Date | Author | Description |
|---|---|---|---|
| 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) |
| 4c1c22d | 2023-12-10 11:50:56 | Lino Galiana | Badge en javascript plutôt (#469) |
| 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) |
| 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) |
| 6178ebe | 2023-09-26 14:18:34 | Lino Galiana | Change quarto project type (#409) |
| 3bdf3b0 | 2023-08-25 11:23:02 | Lino Galiana | Simplification de la structure 🤓 (#393) |
| 78ea2cb | 2023-07-20 20:27:31 | Lino Galiana | Change titles levels (#381) |
| 2dbf853 | 2023-07-05 11:21:40 | Lino Galiana | Add nice featured images (#368) |
| b2d4823 | 2022-09-21 17:36:29 | Lino Galiana | Relec KA 21/09 (#273) |
| f10815b | 2022-08-25 16:00:03 | Lino Galiana | Notebooks should now look more beautiful (#260) |
| d201e3c | 2022-08-03 15:50:34 | Lino Galiana | Pimp la homepage ✨ (#249) |
| 12965ba | 2022-05-25 15:53:27 | Lino Galiana | :launch: Bascule vers quarto (#226) |
| 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) |
| 2fa78c9 | 2021-09-27 11:24:19 | Lino Galiana | Relecture de la partie numpy/pandas (#152) |
| a1b8aaf | 2021-09-20 09:05:55 | Lino Galiana | Badges de telechargement dans les premiers TP (#146) |
| 85ba119 | 2021-09-16 11:27:56 | Lino Galiana | Relectures des TP KA avant 1er cours (#142) |
| aeb3995 | 2021-07-06 11:11:03 | avouacr | Relecture et ajouts sur anaconda + jupyter (#116) |
| 4cdb759 | 2021-05-12 10:37:23 | Lino Galiana | :sparkles: :star2: Nouveau thème hugo :snake: :fire: (#105) |
| 4c9ebb8 | 2020-09-17 14:09:07 | Lino Galiana | Corrige typo incrémentation |
| 913047d | 2020-09-08 14:44:41 | Lino Galiana | Harmonisation des niveaux de titre (#17) |
| 56f8532 | 2020-09-08 10:40:03 | Lino Galiana | Reprise des éléments de la première séance dans le site web (#14) |
Citation
BibTeX 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 = {en}
}
For attribution, please cite this work as:
Galiana, Lino. 2023. Python Pour La Data Science. https://doi.org/10.5281/zenodo.8229676.