DataScienceAvecPython Ed2018

44444444444.
EUGENIA BAHIT
SCIENCE DES DONNÉES

AVEC PYTHON
MATÉRIEL D'ÉTUDE
Information et inscription :
Cours : http://escuela.eugeniabahit.com | Certifications : http://python.laeci.org
Introduction à la science des données avec Python - Escuela de Informática Eugenia Bahit
RÉSUMÉ
MÉTHODES DE MANIPULATION DES VARIABLES.......................................................................................5
MANIPULATION DE CHAÎNES DE CARACTÈRES..........................................................................................5
LES MÉTHODES DE FORMATAGE.................................................................................................................5
MAJUSCULE À LA PREMIÈRE LETTRE.....................................................................................................5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MINUSCULES.........................................................5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MAJUSCULES.........................................................6
CONVERTIR LES MAJUSCULES EN MINUSCULES ET VICE VERSA..................................................6
CONVERTIR UNE CHAÎNE AU FORMAT TITRE......................................................................................6
CENTRER UN TEXTE.....................................................................................................................................6
ALIGNER LE TEXTE À GAUCHE.................................................................................................................6
ALIGNER LE TEXTE À DROITE...................................................................................................................7
REMPLIR UN TEXTE EN LE FAISANT PRÉCÉDER DE ZÉROS..............................................................7
LES MÉTHODES DE RECHERCHE..................................................................................................................7
COMPTER LE NOMBRE D'OCCURRENCES D'UNE SOUS-CHAÎNE......................................................7
RECHERCHE D'UNE SOUS-CHAÎNE DANS UNE CHAÎNE......................................................................7
LES MÉTHODES DE VALIDATION.................................................................................................................8
POUR SAVOIR SI UNE CHAÎNE COMMENCE PAR UNE SOUS-CHAÎNE DONNÉE............................8
POUR SAVOIR SI UNE CHAÎNE SE TERMINE PAR UNE SOUS-CHAÎNE DONNÉE...........................8
POUR SAVOIR SI UNE CHAÎNE EST ALPHANUMÉRIQUE.....................................................................8
POUR SAVOIR SI UNE CHAÎNE EST ALPHABÉTIQUE...........................................................................8
POUR SAVOIR SI UNE CHAÎNE EST NUMÉRIQUE..................................................................................9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MINUSCULES.....................................................9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MAJUSCULES.....................................................9
POUR SAVOIR SI UNE CHAÎNE DE CARACTÈRES NE CONTIENT QUE DES BLANCS..................10
SI UNE CHAÎNE DE CARACTÈRES EST AU FORMAT TITRE..............................................................10
LES MÉTHODES DE SUBSTITUTION...........................................................................................................10
FORMATAGE D'UNE CHAÎNE DE CARACTÈRES, REMPLACEMENT DYNAMIQUE DU TEXTE..10
REMPLACER UN TEXTE DANS UNE CHAÎNE DE CARACTÈRES......................................................11
SUPPRIMER LES CARACTÈRES À GAUCHE ET À DROITE D'UNE CHAÎNE DE CARACTÈRES...11
SUPPRIMER LES CARACTÈRES À GAUCHE D'UNE CHAÎNE DE CARACTÈRES............................11
SUPPRIMER LES CARACTÈRES À DROITE D'UNE CHAÎNE DE CARACTÈRES..............................11
LES MÉTHODES D'ASSEMBLAGE ET DE FENDAGE................................................................................11
RELIER ITÉRATIVEMENT UNE CHAÎNE.................................................................................................11
-2-
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

4.0
DIVISER UNE CHAÎNE DE CARACTÈRES EN TROIS PARTIES, EN UTILISANT UN SÉPARATEUR

.........................................................................................................................................................................12
DIVISER UNE CHAÎNE DE CARACTÈRES EN PLUSIEURS PARTIES, EN UTILISANT UN
SÉPARATEUR................................................................................................................................................12
DIVISER UNE CHAÎNE DE CARACTÈRES EN LIGNES.........................................................................12
MANIPULATION DE LISTES ET DE TUPLES..................................................................................................14
LES MÉTHODES D'AGRÉGATION................................................................................................................14
AJOUTER UN ÉLÉMENT À LA FIN DE LA LISTE...................................................................................14
AJOUTER PLUSIEURS ÉLÉMENTS À LA FIN DE LA LISTE.................................................................14
AJOUTER UN ÉLÉMENT À UNE POSITION DONNÉE...........................................................................14
LES MÉTHODES D'ÉLIMINATION................................................................................................................14
SUPPRIMER LE DERNIER ÉLÉMENT DE LA LISTE...............................................................................14
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SON INDEX................................................................15
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SA VALEUR................................................................15
MÉTHODES DE COMMANDE........................................................................................................................15
TRIER UNE LISTE EN SENS INVERSE (ORDRE INVERSE)...................................................................15
TRIER UNE LISTE PAR ORDRE CROISSANT..........................................................................................15
TRIER UNE LISTE PAR ORDRE DÉCROISSANT.....................................................................................15
LES MÉTHODES DE RECHERCHE................................................................................................................15
COUNT NOMBRE D'OCCURRENCES ÉLÉMENTS..................................................................................15
OBTENIR LE NUMÉRO D'INDEX...............................................................................................................16
ANNEXE SUR LES LISTES ET LES TUPLES................................................................................................16
CONVERSION DE TYPE..............................................................................................................................16
CONCATÉNATION DE COLLECTIONS.....................................................................................................17
VALEUR MAXIMALE ET MINIMALE.......................................................................................................20
COMPTER LES ÉLÉMENTS.........................................................................................................................20
MANIPULATION DU DICTIONNAIRE..............................................................................................................22
LES MÉTHODES D'ÉLIMINATION................................................................................................................22
VIDER UN DICTIONNAIRE.........................................................................................................................22
MÉTHODES D'AGRÉGATION ET DE CRÉATION.......................................................................................22
COPIER UN DICTIONNAIRE.......................................................................................................................22
POUR CRÉER UN NOUVEAU DICTIONNAIRE À PARTIR DES CLÉS D'UN.......................................23
SEQUENCE.....................................................................................................................................................23
CONCATÉNER DES DICTIONNAIRES......................................................................................................23
DÉFINIR UNE CLÉ ET UNE VALEUR PAR DÉFAUT..............................................................................23
MÉTHODES DE RETOUR................................................................................................................................24
OBTENIR LA VALEUR D'UNE CLÉ...........................................................................................................24
-3-

POUR SAVOIR SI UNE CLÉ EXISTE DANS LE DICTIONNAIRE..........................................................24

OBTENIR LES CLÉS ET LES VALEURS D'UN DICTIONNAIRE............................................................24
OBTENIR LES CLÉS D'UN DICTIONNAIRE.............................................................................................24
OBTENIR LES VALEURS D'UN DICTIONNAIRE.....................................................................................25
OBTENIR LE NOMBRE D'ÉLÉMENTS D'UN DICTIONNAIRE...............................................................25
LA MANIPULATION DES FICHIERS................................................................................................................27
LES FAÇONS D'OUVRIR UN FICHIER..........................................................................................................27
CERTAINES MÉTHODES DE L'OBJET FICHIER.........................................................................................29
TRAITEMENT DES FICHIERS CSV...................................................................................................................30
QUELQUES EXEMPLES DE FICHIERS CSV................................................................................................30
TRAVAILLER AVEC DES FICHIERS CSV DEPUIS PYTHON....................................................................32
LECTURE DE FICHIERS CSV......................................................................................................................32
ÉCRITURE DE FICHIERS CSV....................................................................................................................37
PROBABILITÉS ET STATISTIQUES AVEC PYTHON.....................................................................................40
PROBABILITÉ D'ÉVÉNEMENTS SIMPLES ET COMPOSÉS MUTUELLEMENT EXCLUSIFS EN
PYTHON.............................................................................................................................................................40
ESPACE D'ÉCHANTILLON..........................................................................................................................40
ÉVÉNEMENTS SIMPLES ET COMPOSÉS.................................................................................................40
RÉPARTITION DES PROBABILITÉS.........................................................................................................41
DES ÉVÉNEMENTS SIMPLES QUI S'EXCLUENT MUTUELLEMENT..............................................41
DES ÉVÉNEMENTS COMPOSÉS D'ÉVÉNEMENTS UNIQUES S'EXCLUANT MUTUELLEMENT
......................................................................................................................................................................42
FONCTIONS...................................................................................................................................................43
PROBABILITÉ CONDITIONNELLE EN PYTHON........................................................................................43
FONCTIONS...................................................................................................................................................44
ÉVÉNEMENTS DÉPENDANTS....................................................................................................................44
THÉORIE DES ENSEMBLES EN PYTHON............................................................................................46
ÉVÉNEMENTS INDÉPENDANTS...............................................................................................................46
THÉORÈME DE BAYES EN PYTHON...........................................................................................................47
THÉORÈME DE BAYES ET PROBABILITÉ DES CAUSES.....................................................................47
DONNÉES : ÉTUDE DE CAS....................................................................................................................47
ANALYSE...................................................................................................................................................48
PROCEDURE..............................................................................................................................................49
FONCTIONS...................................................................................................................................................54
BIBLIOGRAPHIE COMPLÉMENTAIRE.....................................................................................................54
ANNEXE I : CALCULS COMPLEXES................................................................................................................60
STATISTIQUES SUR LA POPULATION ET L'ÉCHANTILLON : CALCUL DES......................................60
-4-

VARIANCE ET ÉCART-TYPE.........................................................................................................................60
PRODUIT SCALAIRE DE DEUX VECTEURS...............................................................................................61
LES CALCULS DE FRÉQUENCES RELATIVES, ABSOLUES ET CUMULÉES........................................61
ANNEXE II : CRÉATION D'UN MENU D'OPTIONS.........................................................................................63
MÉTHODES DE MANIPULATION DES VARIABLES

En Python, chaque variable est considérée comme un objet. Chaque objet peut faire l'objet de différents types
d'actions appelées méthodes. Les méthodes sont des fonctions, mais elles sont dérivées d'une variable. Par
conséquent, ces fonctions sont accessibles à l'aide de la syntaxe :
variable.function()
Dans certains cas, ces méthodes (fonctions d'un objet) acceptent des paramètres comme n'importe quelle autre
fonction.
variable.function(parameter)
MANIPULATION DE CHAÎNES DE CARACTÈRES

Les principales méthodes pouvant être appliquées à une chaîne de texte, classées par catégorie, sont présentées
ci-dessous.
LES MÉTHODES DE FORMATAGE
MAJUSCULE À LA PREMIÈRE LETTRE

Méthode : capitalize()
Retourne : une copie de la chaîne avec la première lettre en majuscule.
> >> string = "welcome to my application".
> >> result = string.capitalize()
> >> résultat
Bienvenue sur mon application
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MINUSCULES

Méthode : lower()
Retourne : une copie de la chaîne en minuscules
> >> string = "Hello World
> >> string.lower()
-5-

Bonjour le monde
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MAJUSCULES

Méthode : upper()
Retourne : une copie de la chaîne en majuscules
> >> string.upper()
HELLO WORLD
CONVERTIR LES MAJUSCULES EN MINUSCULES ET VICE VERSA

Méthode : swapcase()
Retourne : une copie de la chaîne convertie de majuscules en minuscules et vice versa.
> >> string.swapcase()
hOLA mUNDO
CONVERTIR UNE CHAÎNE AU FORMAT TITRE

Méthode : title()
Retour : une copie de la chaîne convertie
> >> string = "hello world
> >> string.title()
Bonjour le monde
CENTRER UN TEXTE
Méthode : centre(length[, "fill character"])
Retourne : une copie de la chaîne centrée
> >> string = "welcome to my application".capitalize()
> >> string.center(50, "=")
===========Bienvenue dans mon application============
> >> string.center(50, " ")

ALIGNER LE TEXTE À GAUCHE

Méthode : ljust(length[, "fill character"])
Retourne : une copie de la chaîne alignée à gauche
>>> string.ljust(50, "=")
Bienvenue dans mon application=======================
-6-

4.0
ALIGNER LE TEXTE À DROITE

Méthode : rjust(length[, "fill character"])
Retourne : une copie de la chaîne alignée à droite
>>> string = "welcome to my application".capitalize()
>>> string.rjust(50, "=")
=======================Bienvenue dans mon application
>>> string.rjust(50, " ")

REMPLIR UN TEXTE EN LE FAISANT PRÉCÉDER DE ZÉROS

Méthode : zfill(length)
Renvoie : une copie de la chaîne de caractères complétée par des zéros jusqu'à ce que la longueur finale
spécifiée soit atteinte.
>>> Numéro de facture = 1575
>>> str(invoice_number).zfill(12)
000000001575
LES MÉTHODES DE RECHERCHE
COMPTER LE NOMBRE D'OCCURRENCES D'UNE SOUS-CHAÎNE

Méthode : count("substring"[, start_position, end_position])
Résultats : un nombre entier représentant le nombre d'occurrences de la sous-chaîne dans la chaîne.
>>> string.count("a")
3
RECHERCHE D'UNE SOUS-CHAÎNE DANS UNE CHAÎNE

Méthode : find("substring"[, start_position, end_position])
Retourne : un entier représentant la position où la sous-chaîne commence à l'intérieur de
chaîne. Si elle n'est pas trouvée, elle renvoie -1
>>> string.find("my")
13
>>> string.find("mon", 0, 10)
-1
-7-

4.0
LES MÉTHODES DE VALIDATION
POUR SAVOIR SI UNE CHAÎNE COMMENCE PAR UNE SOUS-CHAÎNE DONNÉE

Méthode : startswith("substring"[, start_position, end_position])
Renvoie : Vrai ou Faux
> >> string.startswith("Bienvenue")
Vrai
> >> string.startswith("application")
Faux
> >> string.startswith("application", 16)
Vrai
POUR SAVOIR SI UNE CHAÎNE SE TERMINE PAR UNE SOUS-CHAÎNE DONNÉE

Méthode : endswith("substring"[, start_position, end_position])
> >> string.endswith("application")
Vrai
> >> string.endswith("Welcome")
Faux
> >> string.endswith("Welcome", 0, 10)
Vrai
POUR SAVOIR SI UNE CHAÎNE EST ALPHANUMÉRIQUE

Méthode : isalnum()
> >> string = "pepegrillo 75".
> >> string.isalnum()
Faux
> >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne =
"pepegrillo
Vrai
> >> string = "pepegrillo75".
Vrai
POUR SAVOIR SI UNE CHAÎNE EST ALPHABÉTIQUE

Méthode : isalpha()
> >> string.isalpha()
Faux
-8-

4.0
> >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne = "pepegrillo" >> chaîne =
"pepegrillo
Vrai
Faux
POUR SAVOIR SI UNE CHAÎNE EST NUMÉRIQUE

Méthode : isdigit()
> >> string.isdigit()
Faux
> >> chaîne de caractères = "7584" >> chaîne de caractères = "7584" >> chaîne de caractères = "7584" >> chaîne de
caractères = "7584
Vrai
> >> string = "75 84"
Faux
> >> chaîne de caractères = "75.84" >> chaîne de caractères = "75.84" >> chaîne de caractères = "75.84" >> chaîne de
caractères = "75.84"
Faux
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MINUSCULES

Méthode : islower()
> >> chaîne de caractères = "cricket jiminy cricket" >> chaîne de caractères = "cricket jiminy" >> chaîne de caractères =
"cricket jiminy
> >> string.islower()
Vrai
> >> string = "Jiminy Cricket
Faux
> >> chaîne de caractères = "Pepegrillo" >> chaîne de caractères = "Pepegrillo" >> chaîne de caractères = "Pepegrillo
Faux
Vrai
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MAJUSCULES

Méthode : isupper()
> >> string = "PEPE GRILLO".
> >> string.isupper()
Vrai
Faux
-9-

4.0
> >> chaîne de caractères = "Pepegrillo" >> chaîne de caractères = "Pepegrillo" >> chaîne de caractères = "Pepegrillo
Faux
> >> string = "PEPEGRILLO".
Vrai
POUR SAVOIR SI UNE CHAÎNE DE CARACTÈRES NE CONTIENT QUE DES BLANCS

Méthode : isspace()
> >> chaîne de caractères = "cricket jiminy cricket" >> chaîne de caractères = "cricket jiminy" >> chaîne de caractères =
"cricket jiminy
> >> string.isspace()
Faux
> >> string = " "
> >> string.isspace()
Vrai
SI UNE CHAÎNE DE CARACTÈRES EST AU FORMAT TITRE

Méthode : istitle()
> >> string.istitle()
Vrai
> >> string.istitle()
Faux
LES MÉTHODES DE SUBSTITUTION
FORMATAGE D'UNE CHAÎNE DE CARACTÈRES, REMPLACEMENT DYNAMIQUE DU TEXTE

Méthode : format(*args, **kwargs)
Retourne : la chaîne formatée
> >> string = "welcome to my application {0}" >> string = "welcome to my application {0}".
> >> string.format("en Python")
Bienvenue sur mon application Python
> >> string = "Montant brut : ${0} + TVA : ${1} = Montant net : {2}"
> >> string.format(100, 21, 121)
Montant brut : 100 $ + TVA : 21 $ = Montant net : 121
> >> string = "Montant brut : ${gross} + TVA : ${vat} = Montant net : {net}"
> >> string.format(gross=100, vat=21, net=121)
> >> string.format(gross=100, vat=100 * 21 / 100, net=100 * 21 / 100 + 100)

- 10 -

4.0
REMPLACER UN TEXTE DANS UNE CHAÎNE DE CARACTÈRES

Méthode : replace("substring to search for", "substring to replace with")
Retourne : la chaîne remplacée
> >> recherche = "nom prénom" >> recherche = "nom prénom" >> recherche = "nom prénom" >> recherche = "nom
prénom
> >> replace_by = "John Smith" >> replace_by = "John Smith" >> replace_by = "John Smith" >> replace_by = "John
Smith" >> replace_by = "John Smith
> >> "Cher Monsieur prénom nom :".replace(search, replace_by) Cher Monsieur Jean Dupont :
SUPPRIMER LES CARACTÈRES À GAUCHE ET À DROITE D'UNE CHAÎNE DE CARACTÈRES

Méthode : strip(["caractère"])
Retourne : la chaîne substituée
> >> string = " www.eugeniabahit.com "
> >> string.strip()
www.eugeniabahit.com
> >> string.strip(' ')
SUPPRIMER LES CARACTÈRES À GAUCHE D'UNE CHAÎNE DE CARACTÈRES

Méthode : lstrip(["caractère"])
> >> string ="www.eugeniabahit.com"
> >> string.lstrip("w." )
eugeniabahit.com
> >> string = " www.eugeniabahit.com"

> >> string.lstrip()
SUPPRIMER LES CARACTÈRES À DROITE D'UNE CHAÎNE DE CARACTÈRES

Méthode : rstrip(["caractère"])
> >> string ="www.eugeniabahit.com "
> >> string.rstrip( )
LES MÉTHODES D'ASSEMBLAGE ET DE FENDAGE
RELIER ITÉRATIVEMENT UNE CHAÎNE

Méthode : join(iterable)
Retourne : la chaîne de caractères jointe à la table itérative (la chaîne est séparée par chacun des éléments de la
table itérative).
>>> invoice_number_format = ("No. 0000-0", "-0000 (ID : ", ")")
- 11 -

4.0
>>> nombre = "275

> >> numéro_de_la_facture = number.join(numéro_de_la_facture_format)
> >> numéro de la facture
NO 0000-0275-0000 (ID : 275)

Méthode : partition("separator")
Retourne : un tuple de trois éléments dont le premier est le contenu de la chaîne avant le séparateur, le deuxième
est le séparateur lui-même et le troisième est le contenu de la chaîne après le séparateur.
> >> tuple = "http://www.eugeniabahit.com".partition("www.")
> >> tuple
('http://', 'www.', 'eugeniabahit.com')
> >> protocole, séparateur, domaine = tuple

>>>> "Protocole : {0} Domaine : {1}".format(protocol, domain) Protocole : http://
Domaine : eugeniabahit.com

SÉPARATEUR
Méthode : split("separator")
Résultats : une liste contenant tous les éléments trouvés en divisant la chaîne par un séparateur.
>>> mots-clés = "python, guide, cours, tutoriel".split(", ")
> >> mots-clés
['python', 'guide', 'cours', 'tutoriel' ]
DIVISER UNE CHAÎNE DE CARACTÈRES EN LIGNES

Méthode : splitlines()
Retourne : une liste dont chaque élément est une fraction de la chaîne divisée en lignes.
>>> texte = """Ligne 1
Ligne 2
Ligne 3
Ligne 4 """
> >> texte.splitlines()
["Ligne 1", "Ligne 2", "Ligne 3", "Ligne 4"].
> >> texte = "Ligne 1 Ligne 2 Ligne 3".

> >> texte.splitlines()
["Ligne 1", "Ligne 2", "Ligne 3"].
- 12 -

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution 4.0
MANIPULATION DE LISTES ET DE TUPLES
Dans ce chapitre, vous verrez les méthodes de l'objet liste. Certaines d'entre elles sont également
disponibles pour les tuples.
LES MÉTHODES D'AGRÉGATION
AJOUTER UN ÉLÉMENT À LA FIN DE LA LISTE

Méthode : append("new element")
> >> noms_mâles = ["Alvaro", "Jacinto", "Miguel", "Edgardo", "David"].
> >> noms_masculins.append("Jose")
> >> noms_mâles
[Alvaro', 'David', 'Edgardo', 'Jacinto', 'Jose', 'Ricky', 'Jose'].
AJOUTER PLUSIEURS ÉLÉMENTS À LA FIN DE LA LISTE

Méthode : extend(other_list)
> >> male_names.extend(["Jose", "Gerardo"])
> >> noms_mâles
[Alvaro', 'David', 'Edgardo', 'Jacinto', 'Jose', 'Ricky', 'Jose', 'Jose', 'Gerardo'].
AJOUTER UN ÉLÉMENT À UNE POSITION DONNÉE

Méthode : insert(position, "new element")
> >> male_names.insert(0, "Ricky")
> >> noms_mâles
[Ricky', 'Alvaro', 'David', 'Edgardo', 'Jacinto', 'Jose', 'Ricky', 'Jose', 'Jose', 'Jose', 'Gerardo'].
LES MÉTHODES D'ÉLIMINATION
SUPPRIMER LE DERNIER ÉLÉMENT DE LA LISTE

Méthode : pop()
Résultats : l'élément supprimé
> >> noms_masculins.pop()
Gérard
> >> noms_mâles
['Ricky', 'Alvaro', 'David', 'Edgardo', 'Jacinto', 'Jose', 'Ricky', 'Jose', 'Jose', 'Jose'].

4.0
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SON INDEX

Méthode : pop(index)
Résultats : l'élément supprimé
>>> noms_masculins.pop(3)
Edgardo
>>> noms_mâles
['Ricky', 'Alvaro', 'David', 'Jacinto', 'Jose', 'Ricky', 'Jose', 'Jose', 'Jose'].
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SA VALEUR

Méthode : remove("value")
>>> noms_masculins.remove("Jose")
>>> noms_mâles
['Ricky', 'Alvaro', 'David', 'Jacinto', 'Ricky', 'Jose', 'Jose'].
MÉTHODES DE COMMANDE
TRIER UNE LISTE EN SENS INVERSE (ORDRE INVERSE)

Méthode : reverse()
>>> male_names.reverse()
>>> noms_mâles
[Jose', 'Jose', 'Ricky', 'Jacinto', 'David', 'Alvaro', 'Ricky'].
TRIER UNE LISTE PAR ORDRE CROISSANT

Méthode : sort()
>>> noms_masculins.sort()
>>> noms_mâles
[Alvaro', 'David', 'Jacinto', 'Jose', 'Jose', 'Ricky', 'Ricky'].
TRIER UNE LISTE PAR ORDRE DÉCROISSANT

Méthode : sort(reverse=True)
>>> male_names.sort(reverse=True)
>>> noms_mâles
[Ricky", "Ricky", "Jose", "Jose", "Jacinto", "David", "Alvaro"].
LES MÉTHODES DE RECHERCHE
COUNT NOMBRE D'OCCURRENCES ÉLÉMENTS

Méthode : count(element)
>>> male_names = ["Alvaro", "Miguel", "Edgardo", "David", "Miguel"].
- 15 -

>>> male_names.count("Miguel") 2 >>> male_names = ("Alvaro", "Miguel", "Edgardo", "David", "Miguel")

>>> noms_masculins.count("Miguel")
2
OBTENIR LE NUMÉRO D'INDEX

Méthode : index(element[, start_index, end_index])
>>> noms_masculins.index("Miguel") 1
>>> noms_masculins.index("Miguel", 2, 5) 4
ANNEXE SUR LES LISTES ET LES TUPLES
CONVERSION DE TYPE
Dans l'ensemble des fonctions intégrées de Python, il est possible de trouver deux fonctions qui permettent de
convertir des listes en tuples, et vice versa. Ces fonctions sont list et tuple, pour convertir respectivement les
tuples en listes et les listes en tuples.
L'une des utilisations les plus fréquentes est la conversion de tuples en listes, qui doivent être modifiées. C'est
souvent le cas des résultats obtenus à partir d'une requête dans une base de données.
>>> tuple = (1, 2, 3, 4)

>>> tuple (1, 2, 3, 4)
>>> list(tuple)
[1, 2, 3, 4]
>>> liste = [1, 2, 3, 4].

>>> liste [1, 2, 3, 4].
>>> tuple(list)
(1, 2, 3, 4)
- 16 -

4.0
CONCATÉNATION DE COLLECTIONS
Vous pouvez concaténer (ou joindre) deux ou plusieurs listes ou deux ou plusieurs tuples, en utilisant le signe +.
Il n'est pas possible de joindre une liste à un tuple. Les collections à joindre doivent être du même type.
>>> list1 = [1, 2, 3, 4].

> >> list2 = [3, 4, 5, 6, 7, 8]
> >> liste3 = liste1 + liste2
> >> liste3
[1, 2, 3, 4, 3, 4, 5, 6, 7, 8]
MÉTHODES DE MANIPULATION DES VARIABLES 5

MANIPULATION DE CHAÎNES DE CARACTÈRES 5
LES MÉTHODES DE FORMATAGE 5
MAJUSCULE À LA PREMIÈRE LETTRE 5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MINUSCULES 5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MAJUSCULES 6
CONVERTIR LES MAJUSCULES EN MINUSCULES ET VICE VERSA 6
CONVERTIR UNE CHAÎNE AU FORMAT TITRE 6
CENTRER UN TEXTE 6
ALIGNER LE TEXTE À GAUCHE 6
ALIGNER LE TEXTE À DROITE 7
REMPLIR UN TEXTE EN LE FAISANT PRÉCÉDER DE ZÉROS 7
LES MÉTHODES DE RECHERCHE 7
COMPTER LE NOMBRE D'OCCURRENCES D'UNE SOUS-CHAÎNE 7
RECHERCHE D'UNE SOUS-CHAÎNE DANS UNE CHAÎNE 7
LES MÉTHODES DE VALIDATION 8
POUR SAVOIR SI UNE CHAÎNE COMMENCE PAR UNE SOUS-CHAÎNE DONNÉE 8
POUR SAVOIR SI UNE CHAÎNE SE TERMINE PAR UNE SOUS-CHAÎNE DONNÉE 8
POUR SAVOIR SI UNE CHAÎNE EST ALPHANUMÉRIQUE 8
POUR SAVOIR SI UNE CHAÎNE EST ALPHABÉTIQUE 8
POUR SAVOIR SI UNE CHAÎNE EST NUMÉRIQUE 9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MINUSCULES 9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MAJUSCULES 9
POUR SAVOIR SI UNE CHAÎNE DE CARACTÈRES NE CONTIENT QUE DES BLANCS 10
SI UNE CHAÎNE DE CARACTÈRES EST AU FORMAT TITRE 10
LES MÉTHODES DE SUBSTITUTION 10
FORMATAGE D'UNE CHAÎNE DE CARACTÈRES, REMPLACEMENT DYNAMIQUE DU TEXTE 10
REMPLACER UN TEXTE DANS UNE CHAÎNE DE CARACTÈRES 11
SUPPRIMER LES CARACTÈRES À GAUCHE ET À DROITE D'UNE CHAÎNE DE CARACTÈRES 11
- 17 -

SUPPRIMER LES CARACTÈRES À GAUCHE D'UNE CHAÎNE DE CARACTÈRES 11

SUPPRIMER LES CARACTÈRES À DROITE D'UNE CHAÎNE DE CARACTÈRES 11
LES MÉTHODES D'ASSEMBLAGE ET DE FENDAGE 11
RELIER ITÉRATIVEMENT UNE CHAÎNE 11
12
SÉPARATEUR 12
DIVISER UNE CHAÎNE DE CARACTÈRES EN LIGNES 12
MANIPULATION DE LISTES ET DE TUPLES 14
LES MÉTHODES D'AGRÉGATION 14
AJOUTER UN ÉLÉMENT À LA FIN DE LA LISTE 14
AJOUTER PLUSIEURS ÉLÉMENTS À LA FIN DE LA LISTE 14
AJOUTER UN ÉLÉMENT À UNE POSITION DONNÉE 14
LES MÉTHODES D'ÉLIMINATION 14
SUPPRIMER LE DERNIER ÉLÉMENT DE LA LISTE 14
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SON INDEX 15
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SA VALEUR 15
MÉTHODES DE COMMANDE 15
TRIER UNE LISTE EN SENS INVERSE (ORDRE INVERSE) 15
TRIER UNE LISTE PAR ORDRE CROISSANT 15
TRIER UNE LISTE PAR ORDRE DÉCROISSANT 15
COUNT NOMBRE D'OCCURRENCES ÉLÉMENTS 15
OBTENIR LE NUMÉRO D'INDEX 16
ANNEXE SUR LES LISTES ET LES TUPLES 16
CONVERSION DE TYPE 16
CONCATÉNATION DE COLLECTIONS 17
VALEUR MAXIMALE ET MINIMALE 20
COMPTER LES ÉLÉMENTS 20
MANIPULATION DU DICTIONNAIRE 22
VIDER UN DICTIONNAIRE 22
MÉTHODES D'AGRÉGATION ET DE CRÉATION 22
COPIER UN DICTIONNAIRE 22
POUR CRÉER UN NOUVEAU DICTIONNAIRE À PARTIR DES CLÉS D'UN 23
SEQUENCE 23
- 18 -

4.0
CONCATÉNER DES DICTIONNAIRES 23

DÉFINIR UNE CLÉ ET UNE VALEUR PAR DÉFAUT 23
MÉTHODES DE RETOUR 24
OBTENIR LA VALEUR D'UNE CLÉ 24
POUR SAVOIR SI UNE CLÉ EXISTE DANS LE DICTIONNAIRE 24
OBTENIR LES CLÉS ET LES VALEURS D'UN DICTIONNAIRE 24
OBTENIR LES CLÉS D'UN DICTIONNAIRE 24
OBTENIR LES VALEURS D'UN DICTIONNAIRE 25
OBTENIR LE NOMBRE D'ÉLÉMENTS D'UN DICTIONNAIRE 25
LA MANIPULATION DES FICHIERS 27
LES FAÇONS D'OUVRIR UN FICHIER 27
CERTAINES MÉTHODES DE L'OBJET FICHIER 29
TRAITEMENT DES FICHIERS CSV 30
QUELQUES EXEMPLES DE FICHIERS CSV 30
TRAVAILLER AVEC DES FICHIERS CSV DEPUIS PYTHON 32
LECTURE DE FICHIERS CSV 32
ÉCRITURE DE FICHIERS CSV 37
PROBABILITÉS ET STATISTIQUES AVEC PYTHON 40
PROBABILITÉ D'ÉVÉNEMENTS SIMPLES ET COMPOSÉS MUTUELLEMENT EXCLUSIFS EN
PYTHON 40
ESPACE D'ÉCHANTILLON 40
ÉVÉNEMENTS SIMPLES ET COMPOSÉS 40
RÉPARTITION DES PROBABILITÉS 41
DES ÉVÉNEMENTS SIMPLES QUI S'EXCLUENT MUTUELLEMENT 41
DES ÉVÉNEMENTS COMPOSÉS D'ÉVÉNEMENTS UNIQUES S'EXCLUANT MUTUELLEMENT
42
FONCTIONS 43
PROBABILITÉ CONDITIONNELLE EN PYTHON 43
FONCTIONS 44
ÉVÉNEMENTS DÉPENDANTS 44
THÉORIE DES ENSEMBLES EN PYTHON 46
ÉVÉNEMENTS INDÉPENDANTS 46
THÉORÈME DE BAYES EN PYTHON 47
THÉORÈME DE BAYES ET PROBABILITÉ DES CAUSES 47
DONNÉES : ÉTUDE DE CAS 47
ANALYSE 48
PROCEDURE 49
- 19 -

FONCTIONS 54
BIBLIOGRAPHIE COMPLÉMENTAIRE 54
ANNEXE I : CALCULS COMPLEXES 60
STATISTIQUES SUR LA POPULATION ET L'ÉCHANTILLON : CALCUL DES 60
VARIANCE ET ÉCART-TYPE 60
PRODUIT SCALAIRE DE DEUX VECTEURS 61
LES CALCULS DE FRÉQUENCES RELATIVES, ABSOLUES ET CUMULÉES 61
ANNEXE II : CRÉATION D'UN MENU D'OPTIONS 63
>
> >> tuple4 = tuple1 + tuple2 + tuple3
> >> tuple4
(1, 2, 3, 4, 5, 4, 6, 8, 10, 3, 5, 7, 9)
VALEUR MAXIMALE ET MINIMALE

Les valeurs maximale et minimale des listes et des tuples peuvent être obtenues :
> >> max(tuple4)

10
> >> max(tuple1)
5
> >> min(tuple1)
1
> >> max(list3)
8
> >> min(list1)
1
COMPTER LES ÉLÉMENTS

La fonction len() est utilisée pour compter les éléments d'une liste ou d'un tuple, ainsi que les caractères d'une
chaîne de texte :
> >> len(list3)

10
> >> len(list1)
4
- 20 -

4.0
MANIPULATION DU DICTIONNAIRE
LES MÉTHODES D'ÉLIMINATION
VIDER UN DICTIONNAIRE
Méthode : clear()
>>> dictionnaire = {"couleur" : "violet", "taille" : "XS", "prix" : 174.25}
> >> dictionnaire
{couleur : 'violet', 'prix' : 174.25, 'taille' : 'XS' }
> >> dictionnaire.clear()

> >> dictionnaire
{}
MÉTHODES D'AGRÉGATION ET DE CRÉATION
COPIER UN DICTIONNAIRE
Méthode : copy()
> >> dictionnaire = {"couleur" : "violet",
> >> t-shirt = dictionnaire.copy()
> >> dictionnaire
{'colour' : 'violet', 'price' : 174.25,
> >> t-shirt {'color' : 'violet', 'price' :
> >> dictionnaire.clear()

"taille" : "XS", "prix" : 174.25}
> >> dictionnaire {}
> >> T-shirt

taille : 'XS'}
{"couleur" : "violet", "prix" :
> >> musculosa = T-shirt

> >> T-shirt 174.25, taille : 'XS'}
{"couleur" : "violet", "prix" :
> >> musculosa {"couleur" : "violet",

"prix" :
>>> remera.clear()
>>> T-shirt {} >>> T-shirt {} 174.25, taille : 'XS'}
174.25, taille : 'XS'}
174.25, taille : 'XS'}

4.0
POUR CRÉER UN NOUVEAU DICTIONNAIRE À PARTIR DES CLÉS D'UN

SEQUENCE
Méthode : dict.fromkeys(sequence[, default value])
>>> séquence = ["couleur", "taille", "marque"]
>>> dictionnaire1 = dict.fromkeys(séquence)
>>> dictionnaire1
{"couleur" : Aucune, "marque" : Aucune, "taille" : Aucune}
>>> dictionnaire2 = dict.fromkeys(sequence, 'default')

>>> dictionnaire2
{'colour' : 'default x value', 'brand' : 'default x value', 'size' : 'default x value' }
CONCATÉNER DES DICTIONNAIRES

Méthode : update(dictionnaire)
>>> dictionnaire1 = {"couleur" : "vert", "prix" : 45}
>>> dictionnaire2 = {"taille" : "M", "marque" : "Lacoste"}
>>> dictionnaire1.update(dictionnaire2)
>>> dictionnaire1
{couleur : 'vert', 'prix' : 45, 'marque' : 'Lacoste', 'taille' : 'M' }
DÉFINIR UNE CLÉ ET UNE VALEUR PAR DÉFAUT

Méthode : setdefault("key"[, None|default_value])
Si la clé n'existe pas, elle est créée avec la valeur par défaut. Renvoie toujours la valeur de la clé passée en
paramètre.
>>> T-shirt = {"couleur" : "rose", "marque" : "Zara"}

>>> key = remera.setdefault("talle", "U")
> >> clé
'U'
> >> T-shirt

{couleur : 'rose', marque : 'Zara', taille : 'U' }
> >> t-shirt2 = t-shirt.copy()

> >> t-shirt2
{couleur : 'rose', marque : 'Zara', taille : 'U' }
> >> key = t-shirt2.setdefault("pattern")

> >> clé
> >> t-shirt2
{'colour' : 'pink', 'print' : None, 'brand' : 'Zara', 'size' : 'U'}
> >> key = t-shirt2.setdefault("brand", "Lacoste")

> >> clé
Zara
- 23 -

4.0
>>> t-shirt2
{'colour' : 'pink', 'print' : None, 'brand' : 'Zara', 'size' : 'U'}
MÉTHODES DE RETOUR
OBTENIR LA VALEUR D'UNE CLÉ

Méthode : get(key[, "default x value if key does not exist"])
>>> t-shirt.get("colour")
rose
>>> remera.get("stock")
>>> t-shirt.get("stock", "no stock")
en rupture de stock
POUR SAVOIR SI UNE CLÉ EXISTE DANS LE DICTIONNAIRE

Méthode : "clé" dans le dictionnaire
> >> existe = 'prix' dans t-shirt
> >> il y a
Faux
> >> existe = "couleur" dans t-shirt

> >> il y a
Vrai
OBTENIR LES CLÉS ET LES VALEURS D'UN DICTIONNAIRE

Méthode : items()
dictionary = {'colour' : 'pink', 'brand' : 'Zara', 'size' : 'U'}
pour clé, valeur dans dictionnaire.items():

clé, valeur
Sortie :
("couleur", "rose")
("marque", "Zara")
("taille", "U")
OBTENIR LES CLÉS D'UN DICTIONNAIRE

Méthode : keys()
dictionary = {'colour' : 'pink', 'brand' : 'Zara', 'size' : 'U'} for key in dictionary.keys() :
clé
marque
taille
couleur
Obtenir les clés d'une liste
- 24 -

4.0
> >> dictionnaire = {'couleur' : 'rose', 'marque' : 'Zara', 'taille' : 'U' }

> >> clés = liste(dictionnaire.clés())
> >> clés
["couleur", "marque", "taille"].
OBTENIR LES VALEURS D'UN DICTIONNAIRE

Méthode : values()
dictionary = {'colour' : 'pink', 'brand' : 'Zara', 'size' : 'U'}
pour clé dans dictionnaire.valeurs() :
clé
rose
Zara
'U'
Obtenir des valeurs dans une liste

> >> clés = liste(dictionnaire.valeurs())
OBTENIR LE NOMBRE D'ÉLÉMENTS D'UN DICTIONNAIRE

Pour compter les éléments d'un dictionnaire, comme pour les listes et les tuples, on utilise la fonction intégrée
len().
> >> len(dictionnaire)
3
- 25 -

4.0
LA MANIPULATION DES FICHIERS
Python vous permet de travailler à deux niveaux différents en ce qui concerne le système de fichiers
et de répertoires.
L'une d'entre elles est le module os, qui permet de travailler avec l'ensemble du système de fichiers
et de répertoires au niveau du système d'exploitation lui-même.
Le deuxième niveau est celui qui permet de travailler avec des fichiers en manipulant leur lecture et leur écriture
à partir de l'application ou du script lui-même, en traitant chaque fichier comme un objet.
LES FAÇONS D'OUVRIR UN FICHIER

La manière dont un fichier est ouvert est liée à l'objectif final qui répond à la question"pourquoi cefichier est-il
ouvert ? Les réponses peuvent être multiples : lire, écrire, ou lire et écrire.
Chaque fois qu'un fichier est "ouvert", un pointeur est créé dans la mémoire.
Ce pointeur positionne un curseur (ou point d'accès) à un endroit précis de la mémoire (plus simplement, il
positionne le curseur sur un octet précis du contenu du fichier).
Ce curseur se déplace dans le fichier au fur et à mesure que celui-ci est lu ou écrit.
Lorsqu'un fichier est ouvert en mode lecture, le curseur est positionné à l'octet 0 du fichier (c'est-à-dire au début
du fichier). Une fois le fichier lu, le curseur se déplace jusqu'au dernier octet du fichier (équivalent au nombre
total d'octets du fichier). Il en va de même lorsqu'il est ouvert en mode écriture. Le curseur se déplace au fur et à
mesure de la saisie.

4.0
Lorsque vous souhaitez écrire à la fin d'un fichier non nul, le mode append est utilisé. De cette manière, le fichier
est ouvert avec le curseur à la fin du fichier.
Le symbole + en tant que suffixe de mode ajoute le mode opposé au mode d'ouverture une fois que l'action
d'ouverture est exécutée. Par exemple, le mode r (lecture) avec le suffixe + (r+), ouvre le fichier pour la lecture
et, après la lecture, ramène le curseur à l'octet 0.
Le tableau suivant présente les différentes manières d'ouvrir un fichier :

Indicateur Mode d'ouverture Emplacement du pointeur
r Lire seulement Au début du fichier
rb Lecture seule en mode binaire Au début du fichier
r+ Lire et écrire Au début du fichier

rb+ Lecture et écriture en mode binaire Au début du fichier
Uniquement par écrit.
Remplacer le fichier s'il existe.
w Au début du fichier
Créer le fichier s'il n'existe pas.
Ecriture en mode binaire uniquement.

wb Remplacer le fichier s'il existe. Créer le Au début du fichier
fichier s'il n'existe pas.
L'écriture et la lecture.
w+ Remplacer le fichier s'il existe. Au début du fichier
Créer le fichier s'il n'existe pas.
Écriture et lecture en mode binaire.
wb+ Remplacer le fichier s'il existe. Créer le Au début du fichier
fichier s'il n'existe pas.
Si le fichier existe, à la fin du
Ajouté (ajouter du contenu). fichier.
a Créer le fichier s'il n'existe pas. Si le fichier n'existe pas, au
début.
Ajouté en mode binaire (ajouter du contenu). fichier.
ab Créer le fichier s'il n'existe pas. Si le fichier n'existe pas, au
début.
a+ Ajouté (ajouter du contenu) et lu. Si le fichier existe, à la fin de
- 28 -

4.0
celui-ci.
Créer le fichier s'il n'existe pas. Si le fichier n'existe pas, au
début.
Ajouté (ajout de contenu) et lu en mode fichier.
ab+ binaire. Si le fichier n'existe pas, au
Créer le fichier s'il n'existe pas. début.
CERTAINES MÉTHODES DE L'OBJET FICHIER

L'objet fichier, parmi ses méthodes, possède les suivantes :
Méthode Description
Lit l'intégralité du contenu d'un fichier.
read([bytes]) Si la longueur de l'octet est indiquée, il ne lira que le
contenu jusqu'à la longueur spécifiée.
readlines() Lit toutes les lignes d'un fichier
write(string) Écriture d'une chaîne de caractères dans le fichier

La séquence est un itérable quelconque dont les éléments
lignes d'écriture(séquence)
sont écrits un par ligne.
ACCÈS AUX FICHIERS PAR LA STRUCTURE WITH Avec la structure with et la fonction
open(), vous pouvez ouvrir un fichier dans n'importe quel mode et travailler avec lui, sans avoir à le fermer ou à
détruire le pointeur, puisque la structure with s'en charge.
Lire un fichier :
with open("file.txt", "r") as file : content = file.read()
Écrire dans un fichier :
contenu = """
Ce sera le contenu du nouveau fichier.
Le fichier comportera plusieurs lignes.
- 29 -

4.0
"""
with open("file.txt", "r") as file : file.write(content)
TRAITEMENT DES FICHIERS CSV

Le format CSV tire son nom de "comma separated values" (valeurs séparées par des virgules ), qui est défini
dans la norme RFC 4180. Il s'agit de fichiers de texte brut, destinés au stockage de données en masse. C'est l'un
des formats les plus simples pour l'analyse des données. En fait, de nombreux formats de fichiers non libres (ou
libres mais plus complexes) sont souvent convertis au format CSV pour appliquer une science des données
complexe avec différents langages.
Un fichier CSV se compose d'un en-tête qui définit les noms des colonnes, et les lignes suivantes contiennent les
données correspondant à chaque colonne, séparées par une virgule. Cependant, de nombreux autres symboles
peuvent être utilisés comme séparateurs de cellules. Parmi eux, la tabulation et le point-virgule sont aussi
fréquents que la virgule.
QUELQUES EXEMPLES DE FICHIERS CSV

Données météorologiques (séparées par ;)
ID;DATA;VV;DV;T;HR;PPT;RS;P
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
Scores obtenus par les joueurs dans un tournoi (séparés par ,) nom,montant,année
- 30 -

4.0
Maria,858,1930
Jose,665,1930
Rosa, 591, 1930
Juan Carlos, 522, 1930
Antonio, 509, 1930
Maria Esther,495,1930
Maria Luisa,470,1930
Joan,453,1930
John, 436, 1930
Entreprises enregistrées auprès de l'Inspection générale de la justice d'Argentine (séparées par , et données
entre guillemets)
correlative_number", "company_type", "company_type_description", "company_reason", "deregistration_date",

"deregistration_code", "deregistration_detail", "deregistration_detail", "deregistration_code", "deregistration_detail".
"10", "10", "PARTENARIAT", "A A VALLE Y COMPA¥IA", "S", "42014", "APPARTIENT AU REGISTRE DES ENTITÉS
INACTIVES", "APPARTIENT AU REGISTRE DES ENTITÉS INACTIVES".
"11", "10", "PARTENARIAT", "A LUCERO Y H CARATOLI", "S", "42014", "APPARTIENT À
REGISTRE DES ENTITÉS INACTIVES".
"12", "10", "SOCIEDAD COLECTIVA", "A PUIG E HIJOS", "S", "42014", "PERTENECE A
"13", "10", "PARTENARIAT", "A C I C A", "S", "42014", "APPARTIENT AU REGISTRE
ENTITÉS INACTIVES".
"14", "10", "PARTENARIAT", "A¥ON BEATRIZ S Y CIA", "S", "42014", "APPARTIENT À
"15", "10", "PARTENARIAT", "ABA DIESEL", "S", "42014", "APPARTIENT AU REGISTRE
ENTITÉS INACTIVES".
"16", "10", "PARTENARIAT", "ABADA L JOSE ET JORGE JOSE
ABADAL", "S", "42014", "APPARTIENT AU REGISTRE DES ENTITÉS INACTIVES", "ABADAL", "S", "42014",
"APPARTIENT AU REGISTRE DES ENTITÉS INACTIVES".
"17", "10", "SOCIEDAD COLECTIVA", "ABADAL JOSE E HIJO", "S", "42014", "APPARTIENT AU REGISTRE DES
ENTITÉS INACTIVES", "ABADAL JOSE E HIJO", "S", "42014", "APPARTIENT AU REGISTRE DES ENTITÉS
INACTIVES".
"18", "10", "PARTENARIAT", "ABATE Y MACIAS", "S", "42014", "APPARTIENT À
Il est également possible de trouver des données stockées dans des fichiers texte (TXT) dont le format est très
proche de celui d'un fichier CSV. Il est parfois possible de développer un script de formatage pour corriger ces
fichiers afin de travailler avec un CSV.
Observations météorologiques en TXT
DATE TMAX TMIN NOM

--------------------------------------------------------------------
07122017 28,0 19,0 AEROPARQUE AERO
07122017 26,8 12,4 BLUE AERO
- 31 -

4.0
07122017 29.6 7,8 BAHIA BLANCA AERO

07122017 22.7 6.7 BARILOCHE AERO
07122017 3.0 -8,5 BASE BELGRANO II
07122017 2.4 -0,2 BASE CARLINI (EX JUBANY)
07122017 3.9 -0,6 ESPOIR DE BASE
07122017 0.7 -3,6 MARAMBIO BASE
TRAVAILLER AVEC DES FICHIERS CSV DEPUIS PYTHON

Python fournit son propre module appelé csv, qui facilite l'analyse des données des fichiers CSV, à la fois pour la
lecture et l'écriture.
Ce module est utilisé en combinaison avec la structure with et la fonction open pour lire ou générer le fichier, et
avec le module CSV pour l'analyse.
LECTURE DE FICHIERS CSV
Contenu du fichier .csv
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;
from csv import reader
with open("file.csv", "r") as file : document = reader(file, delimiter=';', for row in document :
' '.join(row) quotechar='"")
Sortie :
'0 2016-03-01 00:00:00 9.9 73

'1 2016-03-01 00:30:00 9.0 67
'2 2016-03-01 01:00:00 8.3 64
'3 2016-03-01 01:30:00 8.0 61
'4 2016-03-01 02:00:00 7.4 62
'5 2016-03-01 02:30:00 8.3 47
'6 2016-03-01 03:00:00 7.7 50
'7 2016-03-01 03:30:00 9.0 39
'8 2016-03-01 04:00:00 8.7 39
- 32 -

4.0
Lorsque le fichier CSV comporte un en-tête, il est nécessaire d'ignorer l'en-tête :
Contenu du fichier .csv
ID;DATA;VV;DV;T;HR;PPT;RS;P
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;
from csv import reader
with open("file.csv", "r") as file : document = reader(file, delimiter=';', headers = next(document)

pour la ligne dans le document : quotechar='"")
' '.join(row)
Sortie :
MÉTHODES DE MANIPULATION DES VARIABLES 5

MANIPULATION DE CHAÎNES DE CARACTÈRES 5
LES MÉTHODES DE FORMATAGE 5
MAJUSCULE À LA PREMIÈRE LETTRE 5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MINUSCULES 5
CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MAJUSCULES 6
CONVERTIR LES MAJUSCULES EN MINUSCULES ET VICE VERSA 6
CONVERTIR UNE CHAÎNE AU FORMAT TITRE 6
CENTRER UN TEXTE 6
ALIGNER LE TEXTE À GAUCHE 6
ALIGNER LE TEXTE À DROITE 7
REMPLIR UN TEXTE EN LE FAISANT PRÉCÉDER DE ZÉROS 7
COMPTER LE NOMBRE D'OCCURRENCES D'UNE SOUS-CHAÎNE 7
RECHERCHE D'UNE SOUS-CHAÎNE DANS UNE CHAÎNE 7
LES MÉTHODES DE VALIDATION 8
POUR SAVOIR SI UNE CHAÎNE COMMENCE PAR UNE SOUS-CHAÎNE DONNÉE 8
POUR SAVOIR SI UNE CHAÎNE SE TERMINE PAR UNE SOUS-CHAÎNE DONNÉE 8
- 33 -

4.0
POUR SAVOIR SI UNE CHAÎNE EST ALPHANUMÉRIQUE 8

POUR SAVOIR SI UNE CHAÎNE EST ALPHABÉTIQUE 8
POUR SAVOIR SI UNE CHAÎNE EST NUMÉRIQUE 9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MINUSCULES 9
SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MAJUSCULES 9
POUR SAVOIR SI UNE CHAÎNE DE CARACTÈRES NE CONTIENT QUE DES BLANCS
10
SI UNE CHAÎNE DE CARACTÈRES EST AU FORMAT TITRE 10
LES MÉTHODES DE SUBSTITUTION 10
FORMATAGE D'UNE CHAÎNE DE CARACTÈRES, REMPLACEMENT DYNAMIQUE
DU TEXTE 10
REMPLACER UN TEXTE DANS UNE CHAÎNE DE CARACTÈRES 11
SUPPRIMER LES CARACTÈRES À GAUCHE ET À DROITE D'UNE CHAÎNE DE
CARACTÈRES 11
SUPPRIMER LES CARACTÈRES À GAUCHE D'UNE CHAÎNE DE CARACTÈRES 11
SUPPRIMER LES CARACTÈRES À DROITE D'UNE CHAÎNE DE CARACTÈRES 11
LES MÉTHODES D'ASSEMBLAGE ET DE FENDAGE 11
RELIER ITÉRATIVEMENT UNE CHAÎNE 11
DIVISER UNE CHAÎNE DE CARACTÈRES EN TROIS PARTIES, EN UTILISANT UN
SÉPARATEUR 12
DIVISER UNE CHAÎNE DE CARACTÈRES EN PLUSIEURS PARTIES, EN UTILISANT
UN SÉPARATEUR 12
DIVISER UNE CHAÎNE DE CARACTÈRES EN LIGNES 12
MANIPULATION DE LISTES ET DE TUPLES 14
LES MÉTHODES D'AGRÉGATION 14
AJOUTER UN ÉLÉMENT À LA FIN DE LA LISTE 14
AJOUTER PLUSIEURS ÉLÉMENTS À LA FIN DE LA LISTE 14
AJOUTER UN ÉLÉMENT À UNE POSITION DONNÉE 14
SUPPRIMER LE DERNIER ÉLÉMENT DE LA LISTE 14
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SON INDEX 15
SUPPRIMER UN ÉLÉMENT EN FONCTION DE SA VALEUR 15
MÉTHODES DE COMMANDE 15
TRIER UNE LISTE EN SENS INVERSE (ORDRE INVERSE) 15
TRIER UNE LISTE PAR ORDRE CROISSANT 15
TRIER UNE LISTE PAR ORDRE DÉCROISSANT 15
- 34 -

4.0

COUNT NOMBRE D'OCCURRENCES ÉLÉMENTS 15
OBTENIR LE NUMÉRO D'INDEX 16
ANNEXE SUR LES LISTES ET LES TUPLES 16
CONVERSION DE TYPE 16
CONCATÉNATION DE COLLECTIONS 17
VALEUR MAXIMALE ET MINIMALE 20
COMPTER LES ÉLÉMENTS 20
MANIPULATION DU DICTIONNAIRE 22
VIDER UN DICTIONNAIRE 22
MÉTHODES D'AGRÉGATION ET DE CRÉATION 22
COPIER UN DICTIONNAIRE 22
POUR CRÉER UN NOUVEAU DICTIONNAIRE À PARTIR DES CLÉS D'UN 23
SEQUENCE 23
CONCATÉNER DES DICTIONNAIRES 23
DÉFINIR UNE CLÉ ET UNE VALEUR PAR DÉFAUT 23
MÉTHODES DE RETOUR 24
OBTENIR LA VALEUR D'UNE CLÉ 24
POUR SAVOIR SI UNE CLÉ EXISTE DANS LE DICTIONNAIRE 24
OBTENIR LES CLÉS ET LES VALEURS D'UN DICTIONNAIRE 24
OBTENIR LES CLÉS D'UN DICTIONNAIRE 24
OBTENIR LES VALEURS D'UN DICTIONNAIRE 25
OBTENIR LE NOMBRE D'ÉLÉMENTS D'UN DICTIONNAIRE 25
LA MANIPULATION DES FICHIERS 27
LES FAÇONS D'OUVRIR UN FICHIER 27
CERTAINES MÉTHODES DE L'OBJET FICHIER 29
TRAITEMENT DES FICHIERS CSV 30
QUELQUES EXEMPLES DE FICHIERS CSV 30
TRAVAILLER AVEC DES FICHIERS CSV DEPUIS PYTHON 32
LECTURE DE FICHIERS CSV 32
ÉCRITURE DE FICHIERS CSV 37
PROBABILITÉS ET STATISTIQUES AVEC PYTHON 40
PROBABILITÉ D'ÉVÉNEMENTS SIMPLES ET COMPOSÉS MUTUELLEMENT
EXCLUSIFS EN PYTHON 40
- 35 -

4.0
ESPACE D'ÉCHANTILLON 40
ÉVÉNEMENTS SIMPLES ET COMPOSÉS 40
RÉPARTITION DES PROBABILITÉS 41
DES ÉVÉNEMENTS SIMPLES QUI S'EXCLUENT MUTUELLEMENT 41
DES ÉVÉNEMENTS COMPOSÉS D'ÉVÉNEMENTS UNIQUES S'EXCLUANT
MUTUELLEMENT 42
FONCTIONS 43
PROBABILITÉ CONDITIONNELLE EN PYTHON 43
FONCTIONS 44
ÉVÉNEMENTS DÉPENDANTS 44
THÉORIE DES ENSEMBLES EN PYTHON 46
ÉVÉNEMENTS INDÉPENDANTS 46
THÉORÈME DE BAYES EN PYTHON 47
THÉORÈME DE BAYES ET PROBABILITÉ DES CAUSES 47
DONNÉES : ÉTUDE DE CAS 47
ANALYSE 48
PROCEDURE 49
FONCTIONS 54
BIBLIOGRAPHIE COMPLÉMENTAIRE 54
ANNEXE I : CALCULS COMPLEXES 60
STATISTIQUES SUR LA POPULATION ET L'ÉCHANTILLON : CALCUL DES 60
VARIANCE ET ÉCART-TYPE 60
PRODUIT SCALAIRE DE DEUX VECTEURS 61
LES CALCULS DE FRÉQUENCES RELATIVES, ABSOLUES ET CUMULÉES 61
ANNEXE II : CRÉATION D'UN MENU D'OPTIONS 63
Une autre façon de lire les fichiers CSV avec des en-têtes est d'utiliser l'objet DictReader au lieu du
lecteur, et d'accéder ainsi uniquement à la valeur des colonnes souhaitées par leur nom :
from csv import DictReader
with open("file.csv", "r") as file : document = DictReader(file, delimiter=';', for row in document :
rangée['DONNÉES'] quotechar='"")
- 36 -

4.0
Sortie :
'2016-03-01 00:00:00'
'2016-03-01 00:30:00'
'2016-03-01 01:00:00'
'2016-03-01 01:30:00'
'2016-03-01 02:00:00'
'2016-03-01 02:30:00'
'2016-03-01 03:00:00'
'2016-03-01 03:30:00'
'2016-03-01 04:00:00'
ÉCRITURE DE FICHIERS CSV
Écriture d'un CSV sans en-tête :
from csv import writer with open("data.csv", "w") as file :

document = writer(file, delimiter=';', quotechar='"') document.writerows(array)
Dans l'exemple ci-dessus, un tableau pourrait être une liste de listes avec un nombre égal
d'éléments. Par exemple : matrix = [
["John", 373, 1970],

[Ana', 124, 1983],
[Peter', 901, 1650],
[Rosa', 300, 2000],
[Juana', 75, 1975],
]
Cette opération génère un fichier appelé data.csv dont le contenu est le suivant :
eugenia@bella:~$ cat data.csv

Jean;373;1970
Ana;124;1983
Peter;901;1650
Rose;300;2000
Joan;75;1975
- 37 -

4.0
Écriture d'un CSV avec en-tête :
Dans ce cas, le tableau à écrire devra être une liste de dictionnaires dont les clés correspondent aux
en-têtes indiqués.
matrice = [
dict(player='John', points=373, année=1970), dict(player='Anna', points=124, année=1983),
dict(player='Peter', points=901, année=1650), dict(player='Rose', points=300, année=2000),
dict(player='Jane', points=75, année=1975), ] from csv import DictWriter
headers = ['player', 'points', 'year'] with open("data.csv", "w") as file :

document = DictWriter(file, delimiter=';', fieldnames=headers) quotechar='"",
document.writeheader()
document.writerows(array)
Fonctions statistiques simples
Des fonctions statistiques simples telles que les suivantes peuvent être exécutées sur des listes et des
tuples obtenus ou non à partir d'un CSV :
Compter les éléments len(collection)

Ajout d'éléments sum(collection)
Obtenir un chiffre plus élevé max(collection)
Obtenir un nombre plus petit min(collection)
- 38 -

4.0
PROBABILITÉS ET STATISTIQUES AVEC PYTHON
PROBABILITÉ D'ÉVÉNEMENTS SIMPLES ET COMPOSÉS
MUTUELLEMENT EXCLUSIFS EN PYTHON
ESPACE D'ÉCHANTILLON
Un espace d'échantillonnage est un ensemble d'événements possibles, tels que ceux qui peuvent
résulter d'un lancer de dé :
E=(1,2,3,4,5,6)
espace_échantillon = [1, 2, 3, 4, 5, 6].
Chaque élément d'un espace d'échantillonnage est appelé point d'échantillonnage . Le nombre de
points d'échantillonnage est noté n de telle sorte que pour l'espace d'échantillonnageE=11,2,3,4,5,6/
, n=6 .
n = len(monthly_space)
ÉVÉNEMENTS SIMPLES ET COMPOSÉS

Un événement est un ensemble de résultats dans un espace d'échantillonnage. Par exemple :
• le lancer d'un dé est un événement
• la probabilité que le nombre 5 soit lancé, est un événement simple A = {5} et est exclusif: si
5 est lancé, aucun autre nombre ne peut être lancé en même temps.
• la probabilité qu'un nombre impair soit lancé est l'événement compositeB=11,3,5}

qui dépendra à son tour des événements
simple exclusif ^ = {1} , B2 = {2} et B3 = {3} B2 = {2} et B3 = {3}

4.0
RÉPARTITION DES PROBABILITÉS

L'affectation des probabilités est celle qui fournit des modèles mathématiques pour calculer les
chances que des événements spécifiques se produisent ou ne se produisent pas.
La probabilité d'un événement est désignée par P( événement)

.
Les événements peuvent être :
• simple ou composé
• mutuellement exclusifs ou indépendants
DES ÉVÉNEMENTS SIMPLES QUI S'EXCLUENT MUTUELLEMENT

Si l'on considère un espace d'échantillonnage A, chacun des k points d'échantillonnage est désigné
par Ak et la probabilité de ces points, désignée par P(Ak) , est déterminée par :
P(A,) = -
n
probabilité = 1,0 / n
En Python, au moins un élément de l'équation doit être un nombre réel si ce qui est demandé
comme résultat est un nombre réel.
La probabilité de chaque point d'échantillonnage, en tant qu'événements mutuellement exclusifs, est
la même pour chaque événement.
P^) = P(5) = P(4) = P(3) = P(2) = P(1)
- 41 -

4.0
DES ÉVÉNEMENTS COMPOSÉS D'ÉVÉNEMENTS UNIQUES

S'EXCLUANT MUTUELLEMENT
Lorsque les événements simples qui composent l'événement composite A s'excluent mutuellement,
la probabilité de l'événement composite sera donnée par la somme des probabilités de chaque
événement simple P(Ak) , telle que :
P(A) = P(A1)-P(A2)-.-P(Ak)
Par exemple, pour estimer la probabilité qu'un seul lancer de dé produise un nombre pair, nous
obtenons l'événement .4 = {2. 4,. 6}
donnée par la somme
des probabilités de chacun des événements uniquesP(2)-P(3)-P(4,de l'espace
d'échantillonnageE=11,2,3,4,5,6}.
de telle sorte que :
P(A) = P(2) - P(4) + P(6)

P(A) =1+1+1+1=8
P(A) - |
3
Dans le premier résultat 6 ( dans la deuxième étape, avant de trouver le plus grand commun
1
et réduire la fraction à 2 ) , le dénominateur est équivalent au nombre d'événements simples dans
l'événement composite "nombres pairs" et est noté h. Le dénominateur, 6 , est n, le total de tous les
événements dans l'espace d'échantillonnage. Ainsi, la probabilité d'un événement composé A par
des événements mutuellement exclusifs est donnée par le quotient de hyn tel que :
p(a) = - n
numéros_impairs = [i for i in sample_space if i % 2 is 0] h = len(numéros_impairs) probabilité = float(h) / n
- 42 -

4.0
Un événement composite peut être désigné par l'union de ses événements simples (symbole u , lu
comme "o"), de telle sorte que :
P(A, u A u ...A,) = P (A, ) + P (A2) + ...A,
Par exemple, pour le cas de l'événement "nombres pairs", on obtient que :
P(2U4U 6) = P(2)+P(4)+P(6)
P(2U4U6) = 1++1+1+1 =8
P(2 U 4 U 6) = | |
De sorte que P(2U4U 6)

est un événement et P(2) , P( 4) et P(6 ) sont les probabilités de
les trois événements qui la composent. Dans un nouveau contexte, U 4 U 6)
peut être
traité comme un événement A.
FONCTIONS
# Probabilité d'événements simples mutuellement exclusifs pssme = lambda e : 1.0 / len(e) # Probabilité
d'événements composés mutuellement exclusifs def pscme(e, sc):
n = len(e)
return len(sc) / float(n)
PROBABILITÉ CONDITIONNELLE EN PYTHON

B= {2,4,6}
c. Probabilité de B : P(B) =$=6=2
d. Probabilité d'intersection :
P(ARB) = P(A)P(B)
P(A n B) = 1 I
P(A n B) = I
e = sample_space = [1, 2, 3, 4, 5, 6] n = len(e) # sample total
# probabilité de A
a = [i for i in e if i % 2 is not 0] pa = len(a) / float(n)
- 43 -

4.0
# probabilité de B
b = [i pour i dans e si i % 2 est 0] b = [i pour i dans e si i % 2 est 0] b = [i pour i dans e si i % 2 est 0] b = [i
pour i dans e si i % 2 est 0
pb = len(b) / float(n)
# probabilité de l'intersection des événements pi = pa * pb
FONCTIONS
# Probabilité conditionnelle : événements dépendants def pscd(e, a, b):
i = list(set(a).intersection(b))
pi = pscme(e, i)
pa = pscme(e, a)
retour pi / pa
# Probabilité conditionnelle : événements indépendants def psci(e, a, b) :

pa = pscme(e, a)
pb = pscme(e, b)
retour pa * pb
ÉVÉNEMENTS DÉPENDANTS
Se réfère à la probabilité que deux événements se produisent simultanément lorsque le second
événement dépend de l'occurrence du premier.
La probabilité que B se produise si A se produit est notée P(BA) et se lit comme "la probabilité de
B étant donné A", telle que :
P(BI^ _ _
1
■ P(A)
Où PA n B)
est la probabilité de l'intersection des événements A etB
- définie comme suit : P{A n B) = P(A)P(B-A,

-de sorte que l'intersection est un nouvel
événement composé d'événements simples. Dans l'exemple suivant, elle serait égale à 11,3} (car 1
et 3 sont à la fois dans A et B ).
Exemple : Quelle est laprobabilité de lancer un dé avec un nombre impair inférieur à 4 ?
- 44 -

4.0
Le lancer du dé est un événement en soi. Nous voulons trouver la probabilité de B = {1.2.3}

(nombre inférieur à 4) étant donné que A=(1,3,5 (nombre impair) s'est produit dans l'espace
d'échantillonnage E = {1.2. 3. 4,5,6} .
espace_échantillon = [1, 2, 3, 4, 5, 6].

a = [i for i in monthly_space if i % 2 is not 0].
b = [i pour i dans espace_échantillon si i < 4]]]
Pour calculer la probabilité d'une intersection, il faut d'abord obtenir l'intersection :
An ={1,3}
intersec = [i pour i dans a si i dans b]]
Ensuite, la probabilité du nouvel événement composite est calculée :
112 1
P(AnB)=P(1)+P(3)=+=é=, b0O3
ou, en d'autres termes :
poand_1-2_1
n6 3
En outre, il est nécessaire d'obtenir la probabilité de A , en tenant compte du fait que

est également un événement composé :
p_I_2_1
Enfin, on obtient que :
P(B|A) = P427
P(B|.A) = 1/2
P(B-A) =5=0,6
e = sample_space = [1, 2, 3, 4, 5, 6].
a = [i for i in e if i % 2 is not 0] # nombres impairs

b = [i pour i dans e si i < 4] b = [i pour i dans e si i < 4] b = [i pour i dans e si i < 4] # nombres inférieurs à 4
- 45 -

4.0
intersec = [i for i in a if i in b] # intersection de A et B
n = len(e) # échantillon total

ha = len(a) # nombre total d'événements uniques dans A
hintersec = len(intersec) # nombre total d'événements uniques à l'intersection
# probabilité d'intersection
probability_intersec = float(hintersec) / n
# probabilité de "a
probability_a = float(ha) / n
# probabilité conditionnelle
probabilité_b_donnée_a = probabilité_intersec / probabilité_a
THÉORIE DES ENSEMBLES EN PYTHON

Pour obtenir l'intersection de deux événements composés, une méthode manuelle a été employée :
retourner 'i' pour chaque 'i' de la liste 'a' s'il se trouve dans la liste 'b'.
Cependant, comme chaque événement composite est un ensemble et que Python fournit un type de
données appelé ensemble, il est possible d'obtenir l'intersection en manipulant les événements
composites comme des ensembles Python. Avec set, vous pouvez convertir n'importe quel itérable
en un ensemble et effectuer des opérations d'ensemble telles que l'union et l'intersection lorsque cela
est nécessaire. intersec = list(set(a).intersection(b))
Ici, l'ensemble obtenu est converti en liste afin d'être cohérent avec le reste du code et de s'assurer
que l'élément résultant supporte les opérations et le traitement habituels d'une liste. En cas de doute
sur l'utilisation de listes ou d'ensembles, appliquez le principe de simplicité et mettez en œuvre la
solution la plus simple.
ÉVÉNEMENTS INDÉPENDANTS
Contrairement au cas précédent, la probabilité d'occurrence de B n'est pas affectée par l'occurrence
de A . Par exemple, la probabilité de lancer un dé
- 46 -

4.0
et obtenir un nombre pair (événement B) n'est pas affecté par le fait qu'un nombre impair a été
obtenu lors d'un lancer précédent (événement A). La probabilité de B est indépendante de A et est
donnée par le produit des probabilités des deux événements :
P(AnB) = P(A)P(B)
Ici, l'intersection est la probabilité que les deux événements se rencontrent.
Après avoir calculé la probabilité des deux événements indépendants, on les multiplie pour obtenir :
a. Espace d'échantillonnage (pour les deux événements) :
E = {1,2,3,4,5,0}
b. Probabilité de A :
.4= {1,3,5}
P(A) = h = 2 = 1
THÉORÈME DE BAYES EN PYTHON
THÉORÈME DE BAYES ET PROBABILITÉ DES CAUSES

Étant donné une série d'événements Ak dont la somme totale est un espace d'échantillonnage E et un
événement B quelconque, le théorème de Bayes nous permet de connaître la probabilité que chaque
événement Ak de E soit la cause de B. C'est pourquoi elle est également connue sous le nom de
probabilité des causes.
DONNÉES : ÉTUDE DE CAS

Dans une ville de 50 000 habitants, la répartition est la suivante :
- 47 -

4.0
Filles Les enfants Les femmesLes hommes

11000 9000 16000 14000
En outre, 9 000 cas de grippe ont été signalés, répartis comme suit :
Filles Garçons Femmes Les hommes

2000 1500 3000 2500
L'objectif est d'obtenir la probabilité que la cause de la contraction de la grippe soit l'appartenance à
un certain secteur démographique (par exemple, le secteur démographique composé de garçons ou
de filles).
ANALYSE
Il s ' ensuit que :
• La ville (nombre total absolu d'habitants) constitue l'espace d'échantillonnage E.

• Le nombre de filles, de garçons, de femmes et d'hommes est chacun des événements Ak de
l'espace d'échantillonnage E
• La valeur de n est prise comme la somme de l'espace d'échantillonnage 2 Aa , telle que

n = 50000
• La valeur de h pour les événements Ak est chacune des valeurs données dans le tableau de
distribution de la population.
• La grippe est l'événement B.

• Le tableau de distribution des cas de grippe correspond aux intersections de l'événement B
avec chaque événement Ak , c'est-à-dire chaque Akn B
Selon le calcul de probabilité appliqué, il est possible d'obtenir :
- 48 -

4.0
• La probabilité d'être une fille, un garçon, une femme ou un homme dans la ville, par P(Ak) .
Il s'agit d'une probabilité a priori.
• La probabilité d'être une fille, un garçon, une femme ou un homme et d'avoir la grippe, qui
est obtenue avec P(Ak B ) et est considérée comme une probabilité conditionnelle.
• La probabilité que tout habitant, quel que soit le secteur auquel il appartient, soit atteint de la
grippe est obtenue avec
n
P(B)=>P(A)P(BA,)
k=1 et est considérée comme une probabilité totale.
• La probabilité qu'une personne atteinte de la grippe soit une fille, un garçon, une femme ou
un homme est obtenue à l'aide du théorème de Bayes. Cette probabilité est considérée
comme une probabilité a posteriori, ce qui permet de répondre à des questions telles que :
quelle estla probabilité qu'un nouveau cas de grippe survienne chez un enfant ?
Une façon efficace et ordonnée d'obtenir une probabilité a posteriori avec le théorème de Bayes est
d'obtenir d'abord les trois probabilités préalables : a priori, conditionnelle et totale.
AVIS :
dans ce qui suit, map(float, <list>) sera utilisé dans le code source pour convertir les éléments
d'une liste en nombres réels, tant que cela ne surcharge pas le code.
PROCEDURE
1. Calcul des probabilités a priori
Rendement : probabilité qu'un habitant appartienne à un secteur démographique spécifique.
- 49 -

Formule :
Données requises :
hk = données du tableau de répartition de la population
n = toujours la quantité totale de l'espace d'échantillonnage (50 000)
Résultats :
m) = = 0.22
50000 probabilité de êtrefille
9000
P(A2) = 50000
= 0.18
probabilité de êtreenfant
16000
= 0.32
50000
probabilité de êtrefemme
14000 = 0.28
50000 probabilité de êtrehomme
Code Python :
habitants = map(float, [11000, 9000, 16000, 14000])

n = somme(habitants)
pa = [h / n pour h dans habitants].
2. Probabilité conditionnelle
Returna : probabilité d'avoir la grippe tout en appartenant à un secteur démographique

spécifique.
Certitude : Ak (secteur démographique)
Cible : B (probabilité de contracter la grippe)
- 50 -

4.0
P(AknB)
P(BAk)= P(A,)
Formule :
Données requises :
h=B,
P(Ak n B) =
h = intersections (données du tableau de distribution des cas de grippe)
Résultats :
. .....
P(BA1)= LAINE1 probabilité d'avoir contracté la grippe pendant
0 18 0.22 ' l'enfance
IWO
P(BI A) = 50000 = 0.16
0.18
probabilité de contracter la grippe pendant l'enfance
3000
P(BI A3) = woou __0 19
0.32 '
probabilité de contracter la grippe en tant que femme
2500
P(BI A) = LAINE __0 18
0.28 ' probabilité de contracter la grippe en tant qu'homme
Code Python :
affected = map(float, [2000, 1500, 3000, 2500]) pi = [k / n for k in affected]) pi = [k / n for k in affected].
pba = [pi[i] / pa[i] for i in range(len(pi))]]
3. Probabilité totale
Rendement : probabilité que n'importe quel habitant, quel que soit son secteur démographique, soit
atteint de la grippe.
- 51 -

4.0
n
P(B) = >P(A,) P(BA,)
Formule : k=1
Données requises :
probabilité a priori
probabilité conditionnelle
Résultats :
P(B) = PA ,) PBA)) PBA)) PBA)) (])+() PB])
P(B") = 0,22 ■ 0,18-0,18 ■ 0,16+0,32 ■ 0,19 - 0,28 ■ 0,18
PiB] = 0,04 - 0,03 - 0,06 - 0,05
P(B) = 0,18
Code Python :
produits = [pa[i] * pba[i] for i in range(len(pa))] pb = sum(products)
Remarques:
(a) Notez que dans le résultat ci-dessus, il y aura une différence de 0,01 par rapport à la solution
manuelle. Ceci est dû aux arrondis dans la solution manuelle. Cette différence peut être éliminée en
utilisant trois décimales dans les valeurs de probabilité conditionnelle (au lieu de deux) dans la
solution manuelle.
- 52 -

4.0
(b) la probabilité de NE PAS avoir la grippe sera donnée par 1 - P(B'l tel que
1 -0,18 = 0,82 mais il ne sera pas nécessaire de l'utiliser pour cet exemple avec le
Théorème de Bayes.
4. Probabilité ex post
Résultats : probabilité d'appartenir à un groupe démographique spécifique et d'être atteint de la
grippe.
Certitude : B (grippe)
Objectif : Ak (probabilité d'appartenir à un groupe démographique particulier)
_ . 2P(A,)P(BA+)
Formule : k=1
Données requises :
PAk) P(BAk,
= le produit obtenu dans chacun des termes de la vraisemblance totale
2P(AL)P(B|A)
k=1 = la probabilité totale
Résultats :
= 0.22
probabilité d'être une fille atteinte de la grippe
0.03
P(A2B)= 0.18
= 0.16
probabilité d'être un enfant atteint de la grippe
- 53 -

4.0
0.06 —
P(A3B)= = 0.33
0,18 probabilité d'être une femme atteinte de la grippe
0.05 -
P(A4B)= = 0.27
0,18 probabilité d'être un homme ayant la grippe
Code Python :
pab = [p / pb pour p dans les produits].
FONCTIONS
# Théorème de Bayes
def bayes(e, b) :
n = float(sum(e))
pa = [h / n pour h dans e].
pi = [k / n pour k dans b] pi = [k / n pour k dans b] pi = [k / n pour k dans b
pba = [pi[i] / pa[i] for i in range(len(pi))]]
prods = [pa[i] * pba[i] for i in range(len(pa))]]
ptb = somme(prods)
pab = [p / pb pour p dans prods].
retour pab
BIBLIOGRAPHIE COMPLÉMENTAIRE
[0] Probabilités et statistiques, Murray Spiegel. McGraw-Hill, Mexique 1988. ISBN : 968-451-102-
- 54 -

4.0
ANNEXE I : CALCULS COMPLEXES
STATISTIQUES SUR LA POPULATION ET L'ÉCHANTILLON : CALCUL
DES
VARIANCE ET ÉCART-TYPE
from math import sqrt
échantillons = [12, 23, 24, 24, 22, 10, 17]. # liste d'échantillons
n = len(samples)
Les
médias
Variance de la population
2 _ H(,2)2
" n
Variance de l'échantillon
Écart-type de l'échantillon
Écart-type de la population
moyenne = somme(échantillons) / float(n)

différences = [xi - moyenne pour xi dans les échantillons].
puissances = [x ** 2 pour x dans différences].
sommation = sum(powers)
variance_mensuelle = sommation / (n - 1) variance_population = sommation / n
écart_mois_échantillon = sqrt(variance_mois_échantillon) écart_population = sqrt(variance_population)

4.0
PRODUIT SCALAIRE DE DEUX VECTEURS

vector1 = [3, 0]
vvecteur2 = [4, 3].
pe = sum([x * y for x, y in zip(vector1, vector2)])
LES CALCULS DE FRÉQUENCES RELATIVES, ABSOLUES ET

CUMULÉES
# FRÉQUENCE ABSOLUE
# Nombre d'occurrences d'une valeur dans un échantillon
échantillons = [1, 2, 3, 4, 3, 2, 6, 7, 3, 3, 3, 1, 8, 5, 9] absolus = []

fréquences = []
pour n dans les échantillons :

si non n en absolu :
absolute.append(n)
fi = samples.count(n)
fréquences.append(fi)
N = sum(frequencies) # == len(samples)
# FRÉQUENCE RELATIVE
# Quotient entre la fréquence absolue et la fréquence relative N = [float(fi) / N for fi in frequencies] relative
sum = round(relative sum(sum(relative)) # == 1
# FRÉQUENCE CUMULÉE
# Somme de toutes les fréquences inférieures ou égales à la fréquence absolue frequencies.sort()
accumulé = [sum(frequencies[:i+1]) for i, fi in enumerate(frequencies)]]
# FRÉQUENCE RELATIVE CUMULÉE

# Rapport entre la fréquence accumulée et la quantité totale de données accumulées = [float(f) / N pour f
dans accumulé].
- 61 -

4.0
ANNEXE II : CRÉATION D'UN MENU D'OPTIONS
Dans les scripts, il peut être utile de donner à l'utilisateur un menu d'options et de faire en sorte que
le script agisse en fonction de l'option choisie par l'utilisateur. Voici une astuce pour résoudre ce
problème de manière simple et ingénieuse.
1) Tout d'abord, l'ensemble du texte doit être organisé en fonctions.
2) Deuxièmement, toutes les fonctions doivent être documentées, en définissant ce qu'elles font
exactement :
def read_file() :
"Lire le fichier CSV"""""
return "lire
def write_file() :
"Écrire un fichier CSV""""
return "écrire
def _sum_numbers(list) :
"Sum the numbers in a list"" return "private""
3) Une liste est ensuite définie avec le nom de toutes les fonctions qui seront accessibles à
l'utilisateur à partir du menu :
fonctions = ['read_file', 'write_file']
L'astuce consiste à automatiser à la fois la génération du menu et l'appel de la fonction.
Pour automatiser la génération du menu, l'astuce consiste à utiliser :
▪ La liste de l'étape 3

4.0
La fonction locals()
L'attribut doc
number = 1 # sera ensuite utilisé pour accéder à la fonction

menu = "Choisissez une option".
pour la fonction dans les fonctions :

menu += "\t{}. {}".format(number, locals()[function].__doc__) number = number + 1 # incrémente le
nombre à chaque itération
echo(menu)
option = int(get("Votre option : "))
# echo and get : hacks learned in the introductory course
Enfin, pour accéder dynamiquement à la fonction choisie par l'utilisateur, l'astuce consiste à
utiliser l'option choisie par l'utilisateur comme index pour accéder au nom de la fonction dans la
liste, et à recourir à nouveau aux fonctions locales pour invoquer la fonction :
function = functions[option - 1] locals() # vous obtenez le nom de la fonction

[function]() # la fonction est invoquée via locals()
- 64 -

4.0
CERTIFICAT
Montrez tout ce que vous avez appris !
Si vous avez atteint la fin du cours, vous pouvez obtenir une triple certification :
- Certificat de présence (délivré par l'école Eugenia Bahit)

- Certificat de réussite (délivré par CLA Linux)
- Certificat d'agrément (délivré par le LAECI)
Demandez à votre professeur ou visitez le site web de certification à l'adresse

http://python.eugeniabahit.org.
Si vous avez besoin de vous préparer à votre examen, vous pouvez vous inscrire
à la
Cours sur la science des données avec Python à l'école d'informatique
Eugenia Bahit
www.eugeniabahit.com www.eugeniabahit.com

DataScienceAvecPython Ed2018

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

DataScienceAvecPython Ed2018

Transféré par

Droits d'auteur :

Formats disponibles

44444444444.

SCIENCE DES DONNÉES

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

DIVISER UNE CHAÎNE DE CARACTÈRES EN TROIS PARTIES, EN UTILISANT UN SÉPARATEUR

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

POUR SAVOIR SI UNE CLÉ EXISTE DANS LE DICTIONNAIRE..........................................................24

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

MÉTHODES DE MANIPULATION DES VARIABLES

conséquent, ces fonctions sont accessibles à l'aide de la syntaxe :

MANIPULATION DE CHAÎNES DE CARACTÈRES

LES MÉTHODES DE FORMATAGE

MAJUSCULE À LA PREMIÈRE LETTRE

CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MINUSCULES

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

CONVERTIR UNE CHAÎNE DE CARACTÈRES EN MAJUSCULES

CONVERTIR LES MAJUSCULES EN MINUSCULES ET VICE VERSA

CONVERTIR UNE CHAÎNE AU FORMAT TITRE

> >> string.center(50, " ")

ALIGNER LE TEXTE À GAUCHE

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

ALIGNER LE TEXTE À DROITE

>>> string.rjust(50, " ")

REMPLIR UN TEXTE EN LE FAISANT PRÉCÉDER DE ZÉROS

LES MÉTHODES DE RECHERCHE

COMPTER LE NOMBRE D'OCCURRENCES D'UNE SOUS-CHAÎNE

RECHERCHE D'UNE SOUS-CHAÎNE DANS UNE CHAÎNE

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

LES MÉTHODES DE VALIDATION

POUR SAVOIR SI UNE CHAÎNE COMMENCE PAR UNE SOUS-CHAÎNE DONNÉE

POUR SAVOIR SI UNE CHAÎNE SE TERMINE PAR UNE SOUS-CHAÎNE DONNÉE

POUR SAVOIR SI UNE CHAÎNE EST ALPHANUMÉRIQUE

POUR SAVOIR SI UNE CHAÎNE EST ALPHABÉTIQUE

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

POUR SAVOIR SI UNE CHAÎNE EST NUMÉRIQUE

SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MINUSCULES

SI UNE CHAÎNE NE CONTIENT QUE DES LETTRES MAJUSCULES

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

POUR SAVOIR SI UNE CHAÎNE DE CARACTÈRES NE CONTIENT QUE DES BLANCS

SI UNE CHAÎNE DE CARACTÈRES EST AU FORMAT TITRE

LES MÉTHODES DE SUBSTITUTION

FORMATAGE D'UNE CHAÎNE DE CARACTÈRES, REMPLACEMENT DYNAMIQUE DU TEXTE

> >> string.format(gross=100, vat=100 * 21 / 100, net=100 * 21 / 100 + 100)

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

REMPLACER UN TEXTE DANS UNE CHAÎNE DE CARACTÈRES

SUPPRIMER LES CARACTÈRES À GAUCHE ET À DROITE D'UNE CHAÎNE DE CARACTÈRES

SUPPRIMER LES CARACTÈRES À GAUCHE D'UNE CHAÎNE DE CARACTÈRES

> >> string = " www.eugeniabahit.com"

SUPPRIMER LES CARACTÈRES À DROITE D'UNE CHAÎNE DE CARACTÈRES

LES MÉTHODES D'ASSEMBLAGE ET DE FENDAGE

RELIER ITÉRATIVEMENT UNE CHAÎNE

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

>>> nombre = "275

DIVISER UNE CHAÎNE DE CARACTÈRES EN TROIS PARTIES, EN UTILISANT UN SÉPARATEUR

> >> protocole, séparateur, domaine = tuple

DIVISER UNE CHAÎNE DE CARACTÈRES EN PLUSIEURS PARTIES, EN UTILISANT UN

DIVISER UNE CHAÎNE DE CARACTÈRES EN LIGNES

> >> texte = "Ligne 1 Ligne 2 Ligne 3".

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Attribution

LES MÉTHODES D'AGRÉGATION

AJOUTER UN ÉLÉMENT À LA FIN DE LA LISTE

AJOUTER PLUSIEURS ÉLÉMENTS À LA FIN DE LA LISTE

AJOUTER UN ÉLÉMENT À UNE POSITION DONNÉE

LES MÉTHODES D'ÉLIMINATION