B8ILBIX G REAL-€0RL8 PROJECTS MMD

M ASTEWING TO V APCEO TECHPlêUES

Écrit par Nibedita Sahu

Maîtrise de Python : Du débutant absolu au professionnel

NIBEDITA Sahu

Publié par NIBEDITA Sahu, 2023.

 Maîtrise de Python : Du débutant absolu au
professionnel Nibedita Sahu

Bien que toutes les précautions aient été prises dans la

préparation de cet ouvrage, l'éditeur n'assume aucune
responsabilité pour les erreurs ou omissions, ou pour les
dommages résultant de l'utilisation des informations
contenues dans ce document.

Maîtrise de Python : Du débutant absolu au professionnel

par Nibedita Sahu

Copyright © 2023 Nibedita Sahu. Tous droits réservés.
Écrit par Nibedita Sahu
 TABLE DES MATIÈRES
Page de titre

Page sur les droits d'auteur

Maîtrise de Python : Du débutant absolu au professionnel

Pourquoi ce livre sort du lot :

Ce qui rend ce livre unique :

À qui s'adresse ce livre :

Maîtrise de Python : Du débutant absolu au professionnel

2.1. Variables, types de données

2.1. Variables et types de données

2.2. Opérateurs

2.3. Flux de contrôle (instructions "si", boucles)

2.4. Fonctions et modules

I. Les fonctions : Les éléments constitutifs des programmes Python

II. Modules : Organiser le code en unités réutilisables

III. Avantages des fonctions et des modules

IV. Bonnes pratiques pour les fonctions et les modules

2.5. Entrée/sortie et traitement des fichiers

2.6. Gestion des exceptions

3.1. Listes

3.1. Listes

3.2. Tuples

Propriétés des tuples

Opérations de base sur les tuples

Cas d'utilisation et avantages des tuples

Points supplémentaires pour mieux comprendre les tuples

3.3. Dictionnaires

3.4. Ensembles et contre-ensembles

Opérations en série

Applications des ensembles

3.5. Tableaux (NumPy)

3.6. Séries et DataFrames (Pandas)

Manipulation de données avec les séries et les cadres de données

4.1. Lecture et écriture de fichiers

4.1. Lecture et écriture de fichiers

4.2. Formats de fichiers CSV et JSON

5.1. Opérations sur les chaînes de caractères | 5.2. Expressions régulières

5.1. Opérations sur les chaînes de caractères

5.2. Expressions régulières

6.1. Classes et objets | 6.2. Héritage et polymorphisme | 6.3.

Concepts OOP avancés

6.1. Classes et objets

6.2. Héritage et polymorphisme

6.3. Concepts OOP avancés

7.1. Créer et importer des modules | 7.2. Travailler avec des paquets

7.1. Création et importation de modules

7.2. Travailler avec des paquets

8.1. Gestion des erreurs et des exceptions | 8.2. Blocs try-except

8.1. Gestion des erreurs et des exceptions

8.2. Blocs try-except

9.1. Fonctions lambda | 9.2. Fonctions de cartographie, de filtrage et de réduction

9.1. Fonctions lambda

9.2. Fonctions de mappage, de filtrage et de réduction

10.1. Protocoles d'itération | 10.2. Création et utilisation de générateurs

10.1. Protocoles d' itération

10.2. Création et utilisation de générateurs

11.1. Décorateurs de fonctions | 11.2. Décorateurs de classes

11.1. Décorateurs de fonctions

11.2. Décorateurs de classe

Cas d'utilisation et avantages des décorateurs de classe

Mise en œuvre des décorateurs de classe

Manipulation de la date et de l'heure (module datetime)

Formatage et analyse des dates et heures

Exploration des modules couramment utilisés (os, sys, math, random, etc.)

14.1. SQL (SQLite) | 14.2. Connectivité à la base de données (SQLite3)

14.1. SQL (SQLite)

14.2. Connectivité à la base de données (SQLite3)

Correspondance de motifs et manipulation de texte (re module)

Correspondance de motifs de base

Manipulation de texte avec re

Drapeaux en question

16.1. Techniques et outils de débogage (pdb) | 16.2. Tests unitaires

(module unittest)

16.1. Techniques et outils de débogage (pdb)

Techniques de débogage

Utilisation de pdb pour le débogage

16.2. Tests unitaires (module unittest)

Profilage et optimisation du code (timeit, cProfile)

18.1. Créer et gérer des environnements virtuels (venv, conda) | 18.2.

Installer et gérer des paquets (pip)

18.1. Création et gestion d'environnements virtuels (venv, conda)

18.2. Installation et gestion des paquets (pip)

19.1. Organisation et styledu code (PEP 8) | 19.2. Documentation

(docstrings) | 19.3. Versionnement du code et collaboration (Git,
GitHub)

19.1. Organisation et style du code (PEP 8)

Exemples de code avec explications :

19.2. Documentation (docstrings)

Points supplémentaires :
19.3. Versionnement du code et collaboration (Git, GitHub)

Annexe : [[370]]

Exercices et solutions : | Exercices :

Solutions :

Ressources :

Fin de la description :
 Préface :
Bienvenue sur le site "Python Mastery : Du débutant absolu au
professionnel" ! Si vous tenez ce livre entre vos mains, il y a de fortes
chances que vous ayez une curiosité insatiable pour la programmation
Python, un langage qui a captivé le monde de la technologie et de
l'innovation. Que vous fassiez vos premiers pas dans le monde passionnant
de la programmation ou que vous cherchiez à affiner vos compétences,
vous êtes au bon endroit.
L'aventure de la maîtrise de Python peut être à la fois exaltante et
difficile, mais n'ayez crainte : ce livre est votre fidèle compagnon pour le
chemin à parcourir. En tant que passionné de technologie, auteur et
programmeur Python, j'ai moi-même parcouru ce chemin et je suis ravi de
partager mes connaissances et mes expériences avec vous.
Dans ces pages, nous nous embarquerons dans une aventure qui
couvrira tout le spectre de la programmation Python, depuis ses éléments
fondamentaux jusqu'au domaine des techniques avancées. Tout au long de
ce livre, j'ai pour objectif de nourrir votre compréhension, en vous
encourageant à penser comme un véritable expert de Python plutôt que de
mémoriser des lignes de code.
Attendez-vous à plonger dans des projets du monde réel, en explorant
des applications pratiques qui renforceront votre apprentissage et
enflammeront votre créativité. Lorsque vous atteindrez le dernier chapitre,
vous aurez la confiance nécessaire pour relever des défis de codage
complexes, développer vos projets et contribuer à la dynamique
communauté Python.
Rappelez-vous que le voyage vers la maîtrise de Python ne consiste pas
seulement à atteindre une destination ; il s'agit de la joie d'apprendre et de
la satisfaction de découvrir de nouvelles possibilités à chaque ligne de code
que vous écrivez.
Alors, sans plus attendre, embarquons ensemble pour ce voyage enrichissant.
Libérons tout le potentiel de Python et profitons des possibilités infinies
qu'il offre au bout de nos doigts.
Bon codage !
Nibedita Sahu
 Description :
Exploitez tout le potentiel de Python grâce à ce guide complet et
captivant qui vous emmène dans un voyage passionnant, du débutant
absolu au professionnel chevronné ! Que vous soyez totalement novice ou
que vous ayez déjà une certaine expérience de la programmation, ce livre
est conçu pour vous doter des compétences et des connaissances
nécessaires pour exceller dans la programmation Python.
POURQUOI CE LIVRE SE D É M A R Q U E :
1. Apprentissage pas à pas : Le livre suit une approche structurée,
vous guidant pas à pas à travers les concepts de Python, ce qui rend
l'apprentissage facile et agréable.
2. Des projets concrets : Acquérir une expérience pratique en
construisant des projets concrets qui consolideront votre
compréhension et vous prépareront à relever de véritables défis en
matière de codage.
3. La maîtrise, pas la mémorisation : Mettant l'accent sur la
compréhension plutôt que sur la mémorisation, ce livre vous permet
de penser comme un expert Python, ce qui vous permet de créer vos
solutions de manière créative.
 CE QUI REND CE LIVRE UNIQUE :
1. Au-delà de l'essentiel : Bien qu'il commence par les bases, ce livre
ne s'arrête pas là. Vous vous plongerez dans des sujets Python
avancés afin d'affiner vos compétences et d'élargir vos horizons.
2. Une couverture approfondie : Des types de données fondamentaux
aux algorithmes complexes, pour une compréhension approfondie
des capacités de Python.
3. Des explications claires : Les concepts complexes sont décomposés
en termes simples, ce qui rend les sujets les plus complexes
accessibles et faciles à comprendre.
 À QUI S'ADRESSE CE LIVRE :
1. Les programmeurs en herbe : Si vous êtes novice en programmation,
ce livre vous servira de guide amical, vous introduisant à Python avec
facilité et clarté.
2. Les codeurs intermédiaires : Pour ceux qui connaissent les bases de
Python, ce livre offre l'opportunité parfaite d'améliorer vos
compétences et d'explorer des techniques avancées.
3. Les passionnés de technologie : Que vous souhaitiez développer
des applications web, analyser des données ou automatiser des
tâches, Python est la porte d'entrée vers un monde de possibilités, et
ce livre en est la clé.

Libérez votre potentiel de programmation et devenez un pro de Python !

Embarquez dans le voyage de la maîtrise de Python, et laissez ce livre être
votre compagnon ultime dans cette entreprise passionnante. L'avenir du
codage vous attend ; embarquons ensemble dans cette aventure !
 PYTHON MASTERY : DU DÉBUTANT
ABSOLU AU PROFESSIONNEL

Nibedita Sahu
Chapitre 1. Maîtrise de Python (feuille de route complète)
Python est un langage de programmation polyvalent et puissant, connu
pour sa simplicité et sa lisibilité. Depuis ses débuts modestes jusqu'à ce
qu'il devienne l'un des langages les plus populaires, Python a acquis une
immense popularité en raison de sa facilité d'utilisation, de ses
bibliothèques étendues et de ses applications très variées.
Ce chapitre peut être un peu long car je couvre un large éventail de
sujets. De plus, à la fin, j'expliquerai quelles sont les possibilités de carrière
après avoir acquis une bonne maîtrise de Python. Il y a encore beaucoup de
choses à explorer.
Alors, patience, attention et finissons-en.
Sautons dans le vif du sujet !
 1. Les bases de Python
Les bases de Python font référence aux concepts fondamentaux et à la
syntaxe du langage de programmation Python. Elles comprennent des
sujets tels que les variables, les types de données, les opérateurs, le flux de
contrôle (instructions if, boucles), les fonctions, les modules, les
entrées/sorties, la gestion des fichiers et la gestion des exceptions. La
compréhension de ces bases est essentielle pour écrire et comprendre
efficacement le code Python.

a) Variables, types de données et opérateurs :

En Python, les variables sont utilisées pour stocker des valeurs de données
et peuvent contenir différents types de données tels que des nombres
(entiers, flottants), des chaînes de caractères et des booléens. Les
opérateurs sont utilisés pour effectuer des opérations sur les variables et les
données, telles que les opérations arithmétiques (+, -, *, /), les
comparaisons (==, <, >) et les opérations logiques (and, or, not).

b) Flux de contrôle (instructions "si", boucles) :

Le flux de contrôle en Python vous permet de prendre des décisions et de

répéter des actions en fonction de certaines conditions. Les instructions If
sont utilisées pour exécuter différents blocs de code selon qu'une condition
est vraie ou fausse. Les boucles, comme les boucles for et while,
permettent de répéter un bloc de code plusieurs fois.

c) Fonctions et modules :

Les fonctions sont des blocs de code réutilisables qui exécutent des tâches
spécifiques. Elles permettent d'organiser le code et de le rendre plus
modulaire. Les modules sont des fichiers contenant du code Python, y
compris des fonctions et des variables, qui peuvent être importés et utilisés
dans d'autres programmes.
d) Entrée/sortie et traitement des fichiers :
Python fournit des fonctions intégrées pour gérer les opérations d'entrée et
de sortie. Ces fonctions vous permettent de prendre en compte les données
de l'utilisateur, d'afficher les résultats et de travailler avec des fichiers. La
manipulation de fichiers implique l'ouverture, la lecture, l'écriture et la
fermeture de fichiers à l'aide d'objets fichiers et de méthodes spécifiques.

e) Gestion des exceptions :

La gestion des exceptions est un moyen de gérer les erreurs ou les

conditions exceptionnelles qui peuvent survenir au cours de l'exécution
d'un programme. En utilisant des blocs try-except, vous pouvez attraper et
gérer des exceptions spécifiques, ce qui permet à votre programme de gérer
les erreurs de manière gracieuse et d'éviter les plantages.

2. Structures de données
Les structures de données sont des conteneurs ou des formats utilisés
pour organiser et stocker efficacement les données. Elles offrent différentes
façons de stocker, de manipuler et d'accéder aux éléments de données.
Voici les explications relatives aux structures de données spécifiques :

a) Listes, tuples et dictionnaires :

Les listes sont des collections ordonnées d'éléments, autorisant les

doublons et les opérations mutables. Les tuples sont similaires aux listes
mais immuables. Les dictionnaires sont des paires clé-valeur, permettant
une recherche rapide basée sur des clés uniques.

b) Ensembles et contre-ensembles :

Les ensembles sont des collections non ordonnées d'éléments uniques,

utiles pour effectuer des opérations mathématiques telles que l'union,
l'intersection et la différence. Les Frozensets sont des ensembles
immuables.

c) Tableaux (NumPy) :
NumPy est une bibliothèque en Python qui introduit les tableaux, qui sont
similaires aux listes mais optimisés pour les opérations mathématiques et le
traitement efficace de grands ensembles de données. Les tableaux
permettent d'effectuer rapidement des opérations par éléments et de réaliser
des calculs vectoriels.

d) Series et DataFrames (Pandas) :

Pandas est une bibliothèque puissante pour la manipulation et l'analyse des

données. Les Series sont des tableaux unidimensionnels étiquetés, tandis
que les DataFrames sont des structures de données bidimensionnelles
étiquetées, similaires à des tableaux. Ils offrent des méthodes pratiques de
nettoyage, de filtrage et d'agrégation des données, ce qui facilite les tâches
d'analyse des données.

3. Traitement des fichiers

Le traitement des fichiers est la manière dont nous interagissons avec
les fichiers dans un programme informatique. Elle nous permet de lire des
informations dans des fichiers, d'écrire des données dans des fichiers et de
manipuler des fichiers dans différents formats.

a) Lecture et écriture de fichiers :

En Python, nous pouvons ouvrir un fichier à l'aide de la fonction "open()"

et lire son contenu à l'aide de méthodes telles que "read()" ou "readlines()".
Pour écrire dans un fichier, nous l'ouvrons en mode écriture et utilisons des
méthodes telles que "write()" ou "writelines()" pour ajouter des données au
fichier.

b) Formats de fichiers CSV et JSON :

CSV (Comma-Separated Values) et JSON (JavaScript Object Notation)

sont des formats de fichier couramment utilisés pour stocker des données
structurées. Les fichiers CSV stockent les données sous forme de tableau,
les valeurs étant séparées par des virgules. Les fichiers JSON stockent les
données dans un format lisible par l'homme à l'aide de paires clé-valeur.
Python fournit des bibliothèques pratiques telles que csv et json pour lire et
écrire des données dans les formats suivants
Ces formats simplifient la manipulation des fichiers CSV et JSON dans les
programmes Python.

4. Manipulation des chaînes de caractères

La manipulation de chaînes de caractères consiste à modifier, extraire
et manipuler du texte dans un programme informatique. Elle permet
d'effectuer des opérations sur les chaînes de caractères, telles que les
combiner, les diviser en parties plus petites, rechercher et remplacer des
mots ou des caractères spécifiques, et modifier leur casse.

a) Opérations sur les chaînes de caractères :

Les opérations sur les chaînes de caractères en Python offrent un large

éventail de fonctionnalités pour travailler avec les chaînes, notamment la
concaténation, la division, la recherche, le remplacement et la modification
de la casse. Ces opérations vous permettent de manipuler les chaînes de
caractères en fonction de vos besoins.

b) Opérations régulières :

Les expressions régulières en Python sont des outils puissants pour la

recherche de motifs et la manipulation de texte. Le module re fournit des
fonctions permettant de travailler avec les expressions régulières.
En utilisant des caractères spéciaux et des symboles, les expressions
rationnelles permettent de rechercher, d'extraire ou de remplacer des motifs
spécifiques dans des chaînes de caractères. Par exemple, re.search()
recherche la première occurrence, re.findall() extrait toutes les occurrences
et re.sub() remplace les motifs correspondants. Pour créer un motif regex,
utilisez des métacaractères tels que ^, $, *,
+, ?, ., etc., ainsi que des classes et des groupes de caractères. L'utilisation
efficace des expressions rationnelles permet de simplifier les opérations
complexes sur les chaînes de caractères et d'améliorer les tâches de
traitement des données.

5. Programmation orientée objet (OOP)

La programmation orientée objet (POO) est un paradigme de
programmation qui organise le code en objets, qui sont des instances de
classes. Elle se concentre sur la modélisation des entités du monde réel en
tant qu'objets dotés d'attributs (données) et de comportements (méthodes).
a) Classes et objets :

Dans la POO, une classe est un plan ou un modèle qui définit la structure et
le comportement des objets. Elle encapsule les données et les méthodes. Un
objet, d'une manière différente, est une instance d'une classe. Il représente
une entité spécifique avec un état et un comportement qui lui sont propres.

b) Héritage et polymorphisme :

L'héritage permet à une classe d'hériter des propriétés et des méthodes

d'une autre classe, appelée superclasse ou classe de base. Il favorise la
réutilisation du code et permet la création de classes spécialisées appelées
sous-classes ou classes dérivées.

Le polymorphisme désigne la capacité des objets de différentes classes à

être traités comme des objets d'une superclasse commune. Il permet de
remplacer des méthodes dans des sous-classes, en fournissant des
implémentations différentes tout en conservant une interface cohérente.

c) Concepts OOP avancés :

Les concepts avancés de la POO comprennent l'abstraction, l'encapsulation

et les interfaces. L'abstraction consiste à cacher les détails inutiles et à
n'exposer que les informations essentielles. L'encapsulation consiste à
regrouper les données et les méthodes connexes en une seule unité, ce qui
empêche l'accès direct à l'état interne d'un objet. Les interfaces définissent
un contrat auquel les classes doivent adhérer, en spécifiant les méthodes
qu'elles doivent mettre en œuvre, ce qui favorise le couplage lâche et la
modularité dans la conception du code.

6. Modules et paquets
Les modules et les paquets sont des éléments essentiels de la
programmation modulaire dans de nombreux langages de programmation,
y compris Python. Ils sont
permettent d'organiser et de réutiliser le code en le divisant en fichiers et en
répertoires distincts.

a) Création et importation de modules :

En Python, un module est un fichier contenant des définitions, des

fonctions et des instructions Python. Vous pouvez créer vos propres
modules en écrivant du code dans un fichier
.py. Pour utiliser un module dans un autre script Python, vous devez
l'importer à l'aide de l'instruction "import", ce qui vous permet d'accéder à
ses fonctions, variables et classes.

b) Travailler avec des paquets :

Un paquetage est un moyen d'organiser des modules connexes dans des

répertoires. Il aide à gérer les grands projets en regroupant les
fonctionnalités connexes. Un paquetage est simplement un répertoire
contenant un fichier spécial appelé ' init .py'. Pour
utiliser un module provenant d'un paquetage, vous devez spécifier le nom
du paquetage suivi du nom du module en utilisant la notation par points
dans l'instruction import.

Par exemple, si vous avez un paquet appelé "mon_paquet" avec un module

appelé "mon_module", vous l'importerez comme suit :

import my_package.my_module

Vous pouvez ensuite accéder aux fonctions ou aux classes du module en

utilisant la notation point :

mon_package.mon_module.ma_fonction()
# Changez en fonction de votre paquetage et de votre module.
Globalement, les modules et les paquets permettent d'organiser le code,
d'améliorer la réutilisation du code et de rendre le processus de
développement plus efficace et plus facile à gérer.

7. Gestion des erreurs et exceptions

Le traitement des erreurs et les exceptions sont des mécanismes de
programmation qui permettent de détecter et de gérer les erreurs ou les
événements inattendus qui peuvent survenir au cours de l'exécution d'un
programme.

a) Gestion des erreurs et des exceptions :

La gestion des erreurs consiste à anticiper les erreurs potentielles et à

mettre en œuvre des stratégies pour les traiter de manière élégante, afin
d'éviter que le programme ne se bloque ou ne se comporte de manière
indésirable. Elle comprend des techniques telles que les blocs try-except,
où des segments de code spécifiques sont enveloppés dans un bloc try et où
les erreurs potentielles sont détectées et gérées dans des blocs except.

b) Blocs d'essais et d'exceptions :

Les blocs try-except sont utilisés pour attraper et gérer les exceptions. Le
code contenu dans le bloc try est exécuté et si une exception survient, elle
est capturée par un bloc except qui correspond au type d'exception
spécifique. Cela permet de contrôler la gestion des erreurs, comme
l'affichage d'un message d'erreur, l'enregistrement de l'exception ou
l'adoption d'autres mesures pour remédier à l'erreur et assurer le bon
fonctionnement du programme.

8. Programmation fonctionnelle
La programmation fonctionnelle est un paradigme de programmation
qui met l'accent sur l'utilisation de fonctions pures, où la sortie est
uniquement déterminée par l'entrée.
et n'a pas d'effets secondaires. Il s'attache à considérer le calcul comme
l'évaluation de fonctions mathématiques et promeut l'immutabilité et les
fonctions d'ordre supérieur.

a) Fonctions lambda :

Les fonctions lambda, également appelées fonctions anonymes, sont des

fonctions sans nom. Elles sont définies en ligne et sont généralement
utilisées lorsqu'une fonction est nécessaire pour une opération courte et
simple. Les fonctions lambda sont concises et peuvent être transmises en
tant qu'arguments à d'autres fonctions.

b) Fonctions de mappage, de filtrage et de réduction :

Map, filter et reduce sont des fonctions d'ordre supérieur couramment

utilisées dans la programmation fonctionnelle. La fonction map applique
une fonction donnée à chaque élément d'une table itérative et renvoie une
nouvelle table itérative contenant les valeurs transformées. La fonction de
filtrage sélectionne les éléments d'un tableau itératif en fonction d'une
condition donnée. La fonction reduce applique une fonction binaire aux
éléments d'une table itérative, les réduisant à une seule valeur en combinant
itérativement les éléments.

Ces fonctions facilitent un style de programmation fonctionnel en

permettant d'exprimer les opérations de manière concise et élégante, ce qui
favorise la lisibilité et la maintenabilité du code.

9. Itérateurs et générateurs
Les itérateurs et les générateurs sont des fonctionnalités de Python qui
permettent une itération efficace et contrôlée sur une séquence d'éléments.

a) Protocoles d'itération :

Les protocoles d'itération définissent l'ensemble des méthodes qu'un objet

doit mettre en œuvre pour être considéré comme un itérateur. Les deux
méthodes essentielles sont ' iter qui
renvoie l'objet itérateur lui-même, et ' next ', qui
renvoie l'objet itérateur lui-même, et ' next
récupère l'élément suivant de la séquence. En suivant ces protocoles, les
objets peuvent être itérés à l'aide d'une boucle for ou en appelant
explicitement la fonction "next()".

classe MyIterator :
def iter ( self) :
return self

def next ( self) :

# Mise en œuvre pour récupérer l'élément
suivant # ...

my_iter = MyIterator()
for item in my_iter :
print(item)

"""
Si vous voulez le
passer 'def next
(self) :
passer

alors votre système lancera None coninuosly

et votre système peut également être endommagé. Ne faites pas cela 😅
"""

b) Création et utilisation de générateurs :

Les générateurs sont un type d'itérateur qui peut être créé à l'aide d'une
syntaxe spéciale avec le mot-clé "yield". Ils permettent de définir une
fonction qui se comporte comme un itérateur, générant des valeurs à la
volée sans les stocker en mémoire. Les générateurs sont utiles lorsqu'il
s'agit de séquences importantes ou infinies.

def my_generator() :
yield 1
rendement 2
rendement 3

gen = my_generator()
for item in gen :
print(item)

# Sortie
1
2
3

La fonction "my_generator" est définie à l'aide d'instructions "yield", et

chaque fois que la fonction est appelée, elle renvoie la valeur suivante. Cela
permet une évaluation paresseuse et une itération efficace en termes de
mémoire.

10. Décorateurs
Les décorateurs en Python sont un moyen de modifier ou d'améliorer le
comportement des fonctions ou des classes sans modifier directement leur
code source.

a) Décorateurs de fonctions :

Les décorateurs de fonctions sont des fonctions qui prennent une autre
fonction en entrée et en renvoient une version modifiée. Ils constituent un
moyen pratique d'ajouter des fonctionnalités supplémentaires aux
fonctions, telles que la journalisation, la synchronisation ou la validation
des entrées, en enveloppant la fonction d'origine d'un code supplémentaire.

def decorator(func) :
def wrapper() :
# Code supplémentaire avant d'appeler la fonction
originale result = func()
# Code supplémentaire après l'appel de la fonction
d'origine return result
retour de l'enveloppe
@decorator
def ma_fonction() :
# Code de la fonction
d'origine Résultat du
retour

La fonction "decorator" prend "ma_fonction" en entrée et renvoie une

version modifiée de celle-ci, appelée "wrapper". La syntaxe "@decorator"
est une manière abrégée d'appliquer le décorateur à "ma_fonction".

b) Décorateurs de classe :

Les décorateurs de classe fonctionnent de la même manière que les

décorateurs de fonction, mais ils agissent sur les classes et non sur les
fonctions. Ils peuvent être utilisés pour modifier le comportement ou les
attributs d'une classe. Les décorateurs de classe sont appliqués à l'aide de la
syntaxe "@decorator" au-dessus de la définition de la classe.

def decorator(cls) :
# Modifier les attributs ou le comportement
de la classe return cls

@decorator
classe
MyClass :
# Définition de la
classe pass

La fonction "decorator" prend "MyClass" comme entrée et renvoie la

version modifiée de la classe elle-même. Le décorateur peut ajouter ou
modifier des attributs, remplacer des méthodes ou apporter toute autre
modification souhaitée à la classe.
11. Travailler avec des dates et des heures
 Travailler avec des dates et des heures implique de manipuler et de
gérer des valeurs de date et d'heure en programmation. En Python, le
module "datetime" fournit des classes et des méthodes pour gérer les dates,
les heures et les durées.
Manipulation de la date et de l'heure à l'aide du module "datetime" :
Le module "datetime" fournit des classes telles que "datetime", "date",
"time" et "timedelta" pour travailler avec des dates, des heures et des
durées. Ces classes proposent des méthodes permettant d'effectuer diverses
opérations telles que la création d'objets date ou heure, l'extraction de
composants spécifiques (année, mois, jour, heure, etc.), l'exécution
d'opérations arithmétiques et le formatage de dates et d'heures.
from datetime import datetime, timedelta
# Création d'un objet datetime
now = datetime.now()
print(now) # Sortie : 2023-05-28 15:57:24.404291 #
Accès aux composants de la date et de l'heure
year = now.year
month = now.month
day = now.day
hour = now.hour
minute = now.minute
second = now.second
# Effectuer des opérations arithmétiques
future_date = now + timedelta(days=7)
elapsed_time = future_date - now
# Formatage des dates et des heures
formatted_date = now.strftime("%Y-%m-%d")
formatted_time = now.strftime("%H:%M:%S")
print(formatted_date) # Output : 2023-05-28
print(formatted_time) # Sortie ; 15:57:24

La fonction "datetime.now()" renvoie la date et l'heure actuelles. Nous

pouvons accéder à des composants spécifiques en utilisant des attributs tels
que "year", "month", etc.
Des opérations arithmétiques telles que l'addition ou la soustraction de
durées sont possibles en utilisant 'timedelta'. Le formatage des dates et des
heures est effectué à l'aide de la méthode "strftime" avec des codes de
format pour définir le format de sortie souhaité.
12. Bibliothèque standard de Python
 La bibliothèque standard de Python est un ensemble de modules et
de paquets fournis avec Python. Elle fournit un large éventail de
fonctionnalités, notamment des opérations sur les fichiers, des
interactions avec le système, des calculs mathématiques, la génération de
nombres aléatoires et bien d'autres choses encore.
Exploration des modules couramment utilisés (os, sys, math, random, etc.)

a) os :

Le module "os" fournit des fonctions permettant d'interagir avec le

système d'exploitation. Il vous permet d'effectuer des opérations telles que
la gestion des fichiers et des répertoires, l'accès aux variables
d'environnement, la gestion des processus, etc.

import os

# Obtenir le répertoire de travail actuel

current_dir = os.getcwd()

# Créer un nouveau répertoire

os.mkdir('new_directory')

# Renommer un fichier
os.rename('old_file.txt', 'new_file.txt')

# Exécute une commande système

os.system('ls')

b) sys :

Le module "sys" permet d'accéder aux paramètres et fonctions spécifiques

au système. Il vous permet d'interagir avec l'environnement d'exécution de
Python, d'accéder aux arguments de la ligne de commande et de manipuler
le comportement de l'interpréteur.

import sys
# Obtenir les arguments de la ligne de
commande arguments = sys.argv

# Terminer le programme
sys.exit()

# Obtenir la version de Python

version = sys.version

c) mathématiques :

Le module "math" fournit des fonctions et des constantes mathématiques. Il

comprend des fonctions de trigonométrie, de logarithme, d'exponentiation,
d'arrondi, etc.

import maths

# Calculer la racine carrée

sqrt = math.sqrt(25)

# Calculer le sinus d'un angle

sine = math.sin(math.pi/2)

# Calculer le logarithme
logarithme = math.log(10, 2)

d) aléatoire :

Le module "random" permet de générer des nombres aléatoires et de faire

des choix aléatoires. Il fournit des fonctions de génération de nombres
aléatoires, de mélange de séquences et de sélection d'éléments aléatoires.

import random
# Génère un entier aléatoire
random_number = random.randint(1, 10)

# Mélanger une liste

my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)

# Choisir un élément aléatoire dans une

séquence random_element =
random.choice(my_list)

Ce ne sont là que quelques exemples des modules disponibles dans la

bibliothèque standard de Python. La bibliothèque offre de nombreux
modules répondant à des besoins variés, faisant de Python un langage de
programmation puissant et polyvalent.

13. Travailler avec des bases de données

Travailler avec des bases de données implique d'interagir avec des
systèmes de stockage de données structurées, permettant le stockage,
l'extraction et la manipulation de données. En Python, cela est possible
grâce à des modules qui assurent la connectivité avec les bases de données
et la prise en charge du langage SQL (Structured Query Language).

a) SQL (SQLite) :

SQL est un langage standard pour la gestion des bases de données

relationnelles. SQLite est un moteur de base de données populaire et léger
qui prend en charge la syntaxe SQL. Il permet de créer et de gérer des bases
de données, de définir des tables, d'effectuer des opérations CRUD (Create,
Read, Update, Delete) et d'exécuter des requêtes complexes.

b) Connectivité à la base de données (SQLite3) :

Le module 'sqlite3' de Python fournit une API simple et intuitive pour

travailler avec les bases de données SQLite. Il permet d'établir des
connexions, de créer des objets curseurs pour exécuter des instructions
SQL et d'extraire des données de la base de données. Il prend également en
charge les transactions pour les opérations atomiques.
Travailler avec des bases de données peut impliquer des opérations plus
complexes comme les jointures, l'indexation et les transactions. Cependant,
le module "sqlite3" fournit une base solide pour travailler avec des bases de
données SQLite en Python.

14. Expressions régulières

Les expressions régulières (regex) sont des outils puissants pour la
recherche de motifs et la manipulation de texte. Elles fournissent une
syntaxe concise et flexible pour rechercher, extraire et manipuler du texte
sur la base de motifs spécifiques. En Python, le module "re" est utilisé pour
travailler avec les expressions régulières.
Correspondance de motifs et manipulation de textes (re module) :
Le module "re" de Python permet de travailler avec des expressions régulières.
Il fournit des fonctions telles que "match()", "search()", "findall()" et
"sub()" pour effectuer diverses opérations sur les chaînes de caractères à
l'aide de motifs regex. Ces fonctions permettent la recherche de motifs,
l'extraction d'un texte spécifique, le remplacement d'un texte, etc.
importer re
# Correspondre à un motif au début d'une chaîne
result = re.match(r'Hello', 'Hello, World!')
print(result) # <re.Match object ; span=(0, 5), match='Hello'>
# Recherche d'un motif dans une chaîne de caractères
result = re.search(r'World', 'Hello, World!')
print(result) # <re.Match object ; span=(7, 12), match='World'>
# Trouver toutes les occurrences d'un motif dans une chaîne de
caractères
result = re.findall(r'\d+', 'J'ai 5 pommes et 3 oranges')
print(result) # ['5', '3']
# Remplacer un motif par un texte de
remplacement result = re.sub(r'apple', 'banana', 'I
have an apple') print(result) # I have an banana

Le module "re" permet de faire correspondre un motif au début d'une

chaîne, de rechercher un motif dans une chaîne, de trouver toutes les
occurrences d'un motif et de remplacer un motif par un texte de
remplacement.
Les expressions régulières constituent un moyen souple et efficace de
traiter des tâches complexes de traitement de texte. Elles vous permettent
d'exploiter la puissance de la recherche de motifs à des fins diverses, telles
que la validation de données, l'analyse syntaxique et la manipulation de
texte.
 15. Débogage et tests
Le débogage et les tests sont des aspects cruciaux du développement de
logiciels qui permettent d'identifier et de résoudre les problèmes dans le
code et de garantir l'exactitude et la fiabilité du logiciel.

a) Techniques et outils de débogage (pdb) :

Le débogage est le processus qui consiste à trouver et à corriger les erreurs

ou les bogues dans le code. Python fournit le module "pdb", qui est un
débogueur intégré. Il vous permet de définir des points d'arrêt, de suivre
l'exécution du code, d'inspecter les variables et d'analyser le déroulement
du programme afin d'identifier et de corriger les problèmes.

importer pdb

def ma_fonction() :
x=5
y=2
résultat = x / (y - 2)
retour résultat

pdb.set_trace()
result = my_function()
print(result)

L'option 'pdb.set_trace()' crée un point d'arrêt à cette ligne. Lorsque le

programme s'exécute, il s'arrête au point d'arrêt, ce qui vous permet
d'inspecter les variables de manière interactive, d'exécuter le code étape par
étape et de diagnostiquer les problèmes.

b) Tests unitaires (module unittest) :

Les tests unitaires sont une méthode permettant de tester des unités ou des
composants individuels d'un logiciel afin de s'assurer qu'ils fonctionnent
correctement. Le module "unittest" de Python fournit un cadre pour
l'écriture et l'exécution de tests unitaires. Il permet de définir des cas de
test, des fonctions de test et des assertions pour vérifier les résultats
attendus.
import unittest

def add_numbers(x, y) :
retour x + y

classe MonTest(unittest.TestCase) :
def test_addition(self) :
result = add_numbers(3, 4)
self.assertEqual(result, 7)

si nom == ' main ' :

unittest.main()

Une classe de cas de test est définie avec une fonction de test qui vérifie si
la fonction "add_numbers" renvoie le résultat attendu à l'aide de l'assertion
"self.assertEqual()". L'exécution du script permet d'exécuter les tests et de
communiquer les résultats.

En utilisant des techniques de débogage et en écrivant des tests unitaires

complets, les développeurs peuvent identifier et corriger les problèmes au
cours du développement et garantir la fiabilité et l'exactitude de leur code.

16. Optimisation des performances

L'optimisation des performances fait référence au processus
d'amélioration de l'efficacité et de la vitesse d'un programme ou
d'un système. Il s'agit d'identifier les goulets d'étranglement et de
mettre en œuvre des changements pour améliorer ses performances.
Profilage et optimisation du code (timeit, cProfile) !

a) timeit :

Le module timeit de Python est utilisé pour mesurer le temps d'exécution de

petits extraits de code. Il permet d'évaluer différentes approches et de les
comparer.
leur performance.

b) cProfil :

cProfile est un module Python utilisé pour profiler du code, c'est-à-dire

analyser le temps d'exécution de différentes fonctions et identifier les zones
qui consomment le plus de ressources. Il fournit des informations détaillées
sur le temps d'exécution de chaque fonction, ce qui aide les développeurs à
optimiser leur code en se concentrant sur les sections critiques.

Timeit et cProfile sont des outils précieux pour l'optimisation des

performances, car ils aident les développeurs à comprendre où leur code
passe le plus de temps et dépense le plus de ressources, ce qui leur permet
de prendre des décisions éclairées sur la manière d'améliorer son efficacité.
17. Environnements virtuels et gestion des paquets
Les environnements virtuels et la gestion des paquets sont des aspects
cruciaux du développement et du déploiement de logiciels.
Les environnements virtuels fournissent des environnements isolés pour
les projets Python, ce qui permet aux développeurs d'avoir des installations
et des paquets Python distincts pour différents projets. Cela permet d'éviter
les conflits entre les dépendances et de garantir le respect des exigences
propres à chaque projet.

a) Création et gestion d'environnements virtuels :

Python fournit des modules intégrés comme "venv" et des outils externes
comme "conda" pour créer et gérer des environnements virtuels. Ces outils
permettent aux développeurs de mettre en place des environnements isolés
avec des versions et des paquets Python spécifiques, ce qui leur permet de
travailler sur différents projets sans interférence.
b) Installation et gestion des paquets :

Les outils de gestion de paquets tels que pip sont utilisés pour installer,
mettre à niveau et gérer les paquets externes et les dépendances dans un
environnement virtuel. Pip simplifie le processus d'ajout de nouveaux
paquets à un projet, en veillant à ce que les bibliothèques requises soient
facilement utilisables.

En utilisant des environnements virtuels et des outils de gestion de paquets,

les développeurs peuvent maintenir des structures de projet propres et
organisées, gérer facilement les dépendances et garantir des
environnements cohérents et reproductibles pour leurs projets Python.
18. Meilleures pratiques Python
Les meilleures pratiques Python font référence aux lignes directrices et
aux approches recommandées pour écrire un code Python propre, efficace
et facile à maintenir.

a) Organisation et style du code :

Le respect des lignes directrices énoncées dans la PEP 8 (Python

Enhancement Proposal) permet de garantir une organisation et un style de
code cohérents. Elles couvrent des aspects tels que l'indentation, les
conventions de dénomination, la longueur des lignes et la structure du code,
ce qui rend le code plus lisible et plus facile à comprendre pour les autres
développeurs.

b) Documentation :

L'inclusion de chaînes de documentation dans les fonctions, les classes et

les modules est essentielle pour documenter l'objectif, l'utilisation et les
paramètres du code. Les chaînes de documentation servent de
documentation autonome et fournissent des informations précieuses aux
développeurs qui pourraient avoir besoin d'utiliser ou de modifier le code à
l'avenir.
c) Version du code et collaboration :
L'utilisation de systèmes de contrôle de version comme Git et de
plateformes de collaboration comme GitHub facilite la gestion efficace du
code et la collaboration entre les développeurs. Le contrôle de version
permet de suivre les modifications, les ramifications et les fusions, tandis
que les plateformes comme GitHub offrent un emplacement centralisé pour
héberger les dépôts de code, gérer les problèmes et faciliter la collaboration
grâce à des fonctionnalités telles que les demandes d'extraction (pull
requests).

En adhérant à ces bonnes pratiques Python, les développeurs peuvent

améliorer la lisibilité du code, la maintenabilité et la collaboration, ce qui
se traduit par des flux de développement plus efficaces et une meilleure
qualité du code.
Après avoir maîtrisé Python, vous ouvrez la porte à un large éventail
d'opportunités de carrière passionnantes et gratifiantes. Voici quelques-
unes des voies que vous pouvez emprunter :

Développeur/ingénieur logiciel :

Python est largement utilisé dans le développement de logiciels, ce qui en

fait une compétence précieuse pour devenir un développeur de logiciels ou
un ingénieur professionnel. Vous pouvez contribuer à la création
d'applications robustes, au développement web, à l'analyse de données, au
calcul scientifique et à bien d'autres choses encore.

Scientifique de données :

Les bibliothèques étendues de Python, telles que NumPy, Pandas et scikit-

learn, en font un choix de premier ordre pour la science et l'analyse des
données.

Avec la maîtrise de Python, vous pouvez travailler avec de grands

ensembles de données, effectuer des manipulations de données complexes,
développer des modèles d'apprentissage automatique et obtenir des
informations à partir des données pour prendre des décisions
commerciales.
 Ingénieur en apprentissage automatique :

Python est largement utilisé dans le domaine de l'apprentissage

automatique et de l'intelligence artificielle.
Maîtriser Python vous permet de travailler avec des frameworks populaires
tels que TensorFlow et PyTorch, vous permettant de développer et de
déployer des modèles d'apprentissage automatique pour diverses
applications.

Ingénieur de données :

La polyvalence de Python s'étend aux tâches d'ingénierie des données,

notamment l'extraction, la transformation et le chargement des données
(ETL). Avec Python, vous pouvez automatiser les flux de données, créer
des pipelines de données évolutifs et travailler avec des technologies big
data comme Apache Spark.

Ingénieur DevOps :

La simplicité de Python et son vaste écosystème en font un excellent choix

pour automatiser le déploiement, la gestion de la configuration et
l'orchestration de l'infrastructure. Avec une expertise en Python, vous
pouvez poursuivre une carrière dans le DevOps, en assurant une livraison
de logiciels et une gestion de l'infrastructure fluides et efficaces.

Développeur Web :

Les cadres web de Python, tels que Django et Flask, permettent aux
développeurs de créer des applications web dynamiques, évolutives et
sécurisées. La maîtrise de Python vous permet d'acquérir les compétences
nécessaires pour développer une logique de backend, gérer des bases de
données et créer des API web robustes.

Professionnel de la cybersécurité :

Python est couramment utilisé pour diverses tâches de cybersécurité, telles

que les tests de pénétration, l'évaluation des vulnérabilités et
l'automatisation de la sécurité.

En maîtrisant Python, vous pouvez contribuer à renforcer la sécurité des

systèmes et des réseaux.
 Travailleur indépendant/consultant :

La popularité et la polyvalence de Python en font une compétence très

demandée par les indépendants et les consultants. Vous pouvez offrir votre
expertise en développement Python, en analyse de données, en
automatisation ou dans des domaines spécialisés à des clients de tous les
secteurs.

La maîtrise de Python ouvre un large éventail de possibilités de carrière

dans des secteurs tels que la technologie, la finance, la santé, le commerce
électronique, etc. La polyvalence et la large adoption de Python
garantissent que vos compétences restent précieuses et très demandées dans
le monde en constante évolution de la technologie.
Joyeux Pythonage ! 😊
Chapitre 2. Les bases de Python
 2.1. VARIABLES, TYPES DE DONNÉES

2.2. Opérateurs

2.3. Flux de contrôle (instructions "si", boucles)

2.4. Fonctions et modules

2.5. Entrées/sorties et traitement des fichiers

2.6. Gestion des exceptions

 2.1. VARIABLES ET TYPES DE DONNÉES
Python est un langage de programmation polyvalent et puissant qui est
largement utilisé dans divers domaines, tels que le développement web,
l'analyse de données, l'apprentissage automatique, etc. L'un des concepts
fondamentaux de la programmation Python est celui des variables et des
types. Les variables nous permettent de stocker et de manipuler des
données, tandis que les types définissent la nature des données et la
manière dont elles peuvent être exploitées.
En Python, les variables servent de conteneurs pour le stockage des
valeurs. Elles peuvent contenir différents types de données, notamment des
nombres, des chaînes de caractères, des listes, des dictionnaires, etc. La
flexibilité des variables en Python permet un typage dynamique, ce qui
signifie que les variables peuvent changer de type si nécessaire pendant
l'exécution. Cela fait de Python un langage très flexible et adaptable à
diverses tâches de programmation.
Pour comprendre les variables et les types en Python, commençons par
explorer les différents types de données disponibles dans le langage.
1. Types numériques :
Python propose plusieurs types numériques pour représenter les
nombres. Les types numériques les plus couramment utilisés sont les
entiers ("int") et les nombres à virgule flottante ("float"). Les entiers sont
des nombres entiers sans décimales, tandis que les nombres à virgule
flottante peuvent avoir des décimales.
# Types numériques
x = 5 # assigne une valeur entière à x
y = 3.14 # assigner une valeur en virgule flottante à
y print(x) # Sortie : 5
print(y) # Sortie : 3.14
print(x+y) # Sortie : 8.14

2. Cordes :
Les chaînes de caractères sont utilisées pour représenter des données
textuelles en Python. Elles sont placées entre guillemets simples (') ou
doubles ("). Les chaînes sont immuables, ce qui signifie qu'une fois
définies, leurs valeurs ne peuvent pas être modifiées. Cependant, de
nouvelles chaînes peuvent être créées en manipulant des chaînes
existantes.
# Cordes
 name = "Nibedita Sahu" # assigner une valeur de chaîne à
name message = 'Hello, ' + name + '!' # concaténer des
chaînes print(name) # Output : Nibedita Sahu
print(message) # Sortie : Bonjour, Nibedita Sahu !

3. Listes :
Les listes sont un type de données polyvalent en Python qui peut
contenir une collection de valeurs. Elles sont ordonnées et mutables, ce qui
signifie que des éléments peuvent être ajoutés, supprimés ou modifiés. Les
listes sont définies en plaçant entre crochets ('[]') des valeurs séparées par
des virgules.
# Listes
numbers = [1, 2, 3, 4, 5] # définition d'une liste de nombres
fruits = ['apple', 'banana', 'orange'] # définition d'une liste de
chaînes mixed = [1, 'apple', 3.14, True] # une liste avec des
types de données mixtes print(numbers) # Sortie : [1, 2, 3, 4, 5]
print(fruits) # Sortie : ['apple', 'banana', 'orange']
print(mixed) # Sortie : [1, 'apple', 3.14, True]
print(fruits + nombres)
# Sortie : ['apple', 'banana', 'orange', 1, 2, 3, 4, 5]

4. Tuples :
Les tuples sont similaires aux listes, mais ils sont immuables, ce qui
signifie que leurs éléments ne peuvent pas être modifiés après leur création.
Les tuples sont définis en plaçant entre parenthèses ('()') des valeurs
séparées par des virgules.
# Tuples
point = (3, 4) # définition d'un tuple représentant un point 2D
person = ('Nibe', 20, '[email protected]') # définition d'un tuple représentant les
informations d'une personne
print(personne)
# Sortie : ('Nibe', 20, '[email protected]')
print(point) # Sortie : (3, 4)
print(point+personne)
# Sortie : (3, 4, 'Nibe', 20, '[email protected]')

5. Dictionnaires :
Les dictionnaires sont utilisés pour stocker des paires clé-valeur.
Chaque valeur est associée à une clé unique, qui peut être utilisée pour
accéder à la valeur correspondante.
Les dictionnaires sont définis en entourant les paires clé-valeur d'accolades ("{}").
 # Dictionnaires
student = {'name' : 'Nibedita Sahu', 'age' : 20, 'grade' :
'A'} # définition d'un dictionnaire représentant un
étudiant print(student)
# Output : {'name' : 'Nibedita Sahu', 'age' : 20, 'grade' : 'A' }

Maintenant que nous avons exploré les différents types de données en

Python, nous allons nous pencher sur les variables et leur utilisation.
En Python, les variables sont créées en affectant une valeur à un nom à
l'aide de l'opérateur d'affectation ('='). Les noms de variables peuvent
contenir des lettres, des chiffres et des traits de soulignement, mais ne
peuvent pas commencer par un chiffre. Ils sont sensibles à la casse, ce qui
signifie que "var" et "var" sont traités comme des variables différentes.
# Variables
x = 7 # assigne la valeur 7 à la variable x message =
"Hello, World !"
# assigner une chaîne à la variable message
print(x) # Sortie : 7
print(message) # Sortie : Hello, World !
# Un autre amusement
print(x + message)
# TypeError : unsupported operand type(s) for + : 'int' and
'str' print(str(x) + message) Output : 7Bonjour le monde !

Les variables peuvent être utilisées dans des expressions pour effectuer
des opérations et stocker les résultats. Elles peuvent également être
réaffectées à de nouvelles valeurs. Voici un exemple illustrant l'utilisation
des variables :
# Utilisation de la
variable radius = 5
pi = 3,14
print(radius) # Sortie : 5
# Calcul de la surface d'un cercle
area = pi * (radius ** 2)
print(area) # Output : 78.5
# Mise à jour de la valeur du rayon
radius radius = 7
print(radius) # Sortie : 7
# Calcul de la nouvelle surface du
cercle new_area = pi * (radius ** 2)
print(new_area) # Sortie : 153.86

Dans l'extrait de code ci-dessus, nous attribuons d'abord la valeur 5 à la

variable "radius" et 3,14 à la variable "pi". Ensuite, nous calculons la
surface d'un cercle à l'aide de la formule "pi * radiusZ" et nous stockons le
résultat dans la variable "area".
Ensuite, nous mettons à jour la valeur de "radius" à 7 et calculons la
nouvelle surface sur la base du rayon mis à jour, en la stockant dans la
variable "new_area".
Les variables peuvent également être utilisées pour stocker les résultats
de fonctions ou d'expressions. Par exemple, nous pouvons utiliser des
variables pour stocker le résultat d'un calcul mathématique, la longueur
d'une chaîne de caractères ou le résultat d'une opération conditionnelle.
# Utilisation de variables avec des fonctions
phrase = "Le renard brun et rapide saute par-dessus le chien paresseux".
sentence_length = len(sentence) # stocker la longueur de la chaîne dans une
variable print(sentence_length) # Sortie : 44
is_long_sentence = sentence_length > 50 # stocker le résultat d'une comparaison dans une
variable print(is_long_sentence) # Sortie : Faux

Dans l'extrait de code ci-dessus, nous calculons la longueur de la chaîne

"phrase" à l'aide de la fonction "len()" et nous stockons le résultat dans la
variable "sentence_length". Nous stockons ensuite le résultat d'une
comparaison (longueur_de_la_phrase>50) dans la variable
"is_long_sentence". Cela nous permet de réutiliser ces valeurs plus tard
dans le programme ou de les manipuler davantage.
Python fournit plusieurs fonctions intégrées qui peuvent être utilisées
pour convertir des variables d'un type à un autre. Ces fonctions sont utiles
lorsque nous devons effectuer des opérations ou des comparaisons entre
des variables de types différents. Voici quelques fonctions de conversion
de types couramment utilisées :

int() : Convertit une variable en un type d'entier.

float() : Convertit une variable en un type à virgule
flottante. str() : Convertit une variable en un type de
chaîne de caractères.
list() : Convertit une variable en un type de liste.
tuple() : Convertit une variable en un type de tuple.
dict() : Convertit une variable en un type de dictionnaire.
Prenons un exemple pour comprendre le fonctionnement de la conversion de type :
 # Conversion de
type x = 5
y = "10"
print(x+y)
# TypeError : unsupported operand type(s) for + : 'int' and
'str' z = float(x) + int(y)
# convertir x en float et y en int, puis effectuer l'addition
print(z) # Output : 15.0
#Vous pouvez aussi essayer des choses différentes et vous amuser :)

Dans l'extrait de code ci-dessus, nous avons une variable entière "x"
avec une valeur de 5 et une variable chaîne "y" avec une valeur de "10".
Pour effectuer l'addition, nous convertissons "x" en un nombre flottant à
l'aide de la fonction "float()" et "y" en un nombre entier à l'aide de la
fonction "int()". Après la conversion, nous additionnons les deux variables
et stockons le résultat dans la variable "z". Enfin, nous imprimons la valeur
de "z", qui est de 15,0.
Python supporte le typage dynamique, ce qui signifie que nous pouvons
changer le type d'une variable en lui assignant une valeur d'un type
différent. Cette flexibilité nous permet d'écrire un code concis et souple.
Cependant, il est important de manipuler les conversions de type avec
précaution afin d'éviter des résultats inattendus ou des erreurs.
Outre les types de données de base dont nous avons parlé
précédemment, Python propose plusieurs types de données spécialisés et
des modules qui étendent ses fonctionnalités.
Parmi les plus notables, on peut citer

6. Jeux :
Les ensembles sont utilisés pour stocker une collection d'éléments
uniques. Ils sont définis en plaçant des valeurs séparées par des virgules
entre accolades ("{}"). Les ensembles sont utiles pour des tâches telles que
la suppression des doublons d'une liste ou la vérification efficace de
l'appartenance.
# Sets
fruits = {"pomme", "banane", "orange"}
fruits.add("mangue") # ajout d'un élément à
l'ensemble print(fruits)
# Sortie : {'apple', 'mango', 'orange', 'banana'}
 7. Booléens :
Les booléens représentent les valeurs de vérité Vrai et Faux. Ils sont
souvent utilisés dans les instructions conditionnelles et le flux de contrôle.
Les comparaisons et les opérations logiques produisent des valeurs
booléennes.
# Booléens
is_raining = True
is_sunny = False
if is_raining :
print("Prenez un parapluie.")
else :
print("C'est bon !") if
not is_sunny :
print("Portez une
veste") else :
print("Suivez votre mode !")

# Sortie :
# Prendre un
parapluie. # Porter
une veste.
# Essayez vous-même en modifiant le code!😊

8. Modules :
Python propose une vaste collection de modules qui offrent des
fonctionnalités supplémentaires par rapport aux types intégrés. Les
modules sont des bibliothèques de code qui peuvent être importées et
utilisées dans vos programmes Python. Parmi les modules les plus
populaires, citons "math" pour les opérations mathématiques, "random"
pour la génération de nombres aléatoires et "datetime" pour travailler avec
des dates et des heures.
# Modules
importés math
Rayon = 5
circonférence = 2 * math.pi * rayon
# utilise le module mathématique pour calculer la
circonférence print(circumference) # Sortie :
31.41592653589793

La compréhension des variables et des types est fondamentale pour la

programmation Python. Les variables nous permettent de stocker et de
manipuler des données, tandis que les types
définissent la nature des données et la manière dont elles peuvent être
exploitées. Python offre un large éventail de types de données, des types
numériques aux chaînes de caractères, en passant par les listes, les
dictionnaires, etc.
En utilisant efficacement les variables et en comprenant leurs types,
vous pouvez écrire des programmes Python robustes, flexibles et efficaces.
Vous pouvez effectuer des opérations, des comparaisons et des
manipulations sur les variables en fonction de leur type, et le typage
dynamique de Python permet une grande souplesse dans la gestion des
différents types de données.
En outre, Python fournit diverses fonctions intégrées pour la conversion
de type, ce qui vous permet de convertir les variables d'un type à l'autre si
nécessaire. Cette fonction est particulièrement utile lorsqu'il s'agit de traiter
les données saisies par l'utilisateur ou d'effectuer des calculs impliquant
différents types de données.
La polyvalence de Python s'étend au-delà des types de données de base dont nous
avons parlé.
Les types de données spécialisés, tels que les ensembles, les booléens et les
modules, offrent des fonctionnalités supplémentaires et répondent à des
besoins de programmation spécifiques. Les ensembles sont utiles pour
stocker des éléments uniques et effectuer des opérations sur les ensembles,
les booléens sont essentiels pour les instructions conditionnelles et les
opérations logiques, tandis que les modules fournissent des bibliothèques
étendues à des fins diverses, notamment les mathématiques, la génération
de nombres aléatoires et la manipulation de la date et de l'heure.
Au fur et à mesure que vous progressez dans la programmation Python,
il est important de vous entraîner à utiliser les variables de manière efficace
et de comprendre comment les différents types de données peuvent être
utilisés à votre avantage. Voici quelques conseils à garder à l'esprit :

Choisissez des noms de variables significatifs : Choisissez des noms

qui reflètent l'objectif et la signification des données stockées dans la
variable. Cela améliore la lisibilité du code et permet aux autres (ou à
votre futur moi) de comprendre plus facilement votre code.

Soyez attentif à la portée des variables : Les variables ont des portées
différentes, telles que locale et globale. Il est essentiel de comprendre
la portée des variables pour éviter les conflits de noms et s'assurer que
les variables sont accessibles là où elles sont nécessaires.

Manipulez les conversions de types avec précaution : Lors de la

conversion de variables d'un type à un autre, il faut être conscient des
risques de perte de données ou d'erreurs inattendues.
 les résultats. S'assurer que la conversion est adaptée à l'opération
envisagée et valider les données saisies par l'utilisateur si nécessaire.

Utiliser le riche écosystème de bibliothèques de Python : La force de

Python réside dans son vaste écosystème de bibliothèques. Explorez et
utilisez les bibliothèques pour tirer parti des solutions existantes et
rationaliser vos tâches de programmation. N'oubliez pas d'importer les
modules requis et de vous familiariser avec leur documentation.

Testez et déboguez votre code : Testez toujours votre code avec

différents scénarios et entrées pour vous assurer de son exactitude et
de sa fiabilité.
Les outils et techniques de débogage sont inestimables pour identifier
et résoudre les problèmes dans votre code.

En maîtrisant les variables et les types en Python, vous obtenez une

base solide pour construire des programmes plus complexes et explorer des
concepts avancés, tels que la programmation orientée objet, l'analyse de
données ou l'apprentissage automatique.
En résumé, les variables et les types constituent l'épine dorsale de la
programmation Python. Ils vous permettent de stocker, de manipuler et
d'opérer sur des données de manière efficace. Comprendre les différents
types de données disponibles, pratiquer une utilisation efficace des
variables et connaître les conversions de types vous permettra d'écrire un
code Python élégant et fonctionnel. Profitez de la puissance des variables et
des types en Python et laissez votre parcours de programmation s'épanouir !
 2.2. OPÉRATEURS
Python est un langage de programmation polyvalent et puissant qui offre un
large éventail d'opérateurs permettant d'effectuer diverses opérations sur les
données. Dans cette section, nous allons nous plonger dans le monde des
opérateurs en Python, en explorant leurs types, leurs fonctions et la manière
dont ils peuvent être utilisés pour manipuler et traiter efficacement les
données.
1. Opérateurs arithmétiques :
Les opérateurs arithmétiques sont utilisés pour effectuer des calculs
mathématiques tels que l'addition, la soustraction, la multiplication, la
division, le module et l'exponentiation.
# Résultat de
l'addition = 5
+3
print(result) # Sortie : 8
# Soustraction
result = 10 - 4 print(result)
# Output :
6 # Multiplication
résultat = 2 * 3
print(result) # Sortie : 6
# Division
résultat = 15 / 4
print(result) # Sortie : 3.75
# Module (reste) résultat =
15 % 4
print(result) # Sortie : 3
# Exponentiation
résultat = 2 ** 4
print(result) # Sortie : 16

2. Opérateurs d' affectation :

Les opérateurs d'affectation sont utilisés pour attribuer des valeurs aux
variables. Ils constituent un moyen pratique de mettre à jour et de modifier
les variables en fonction de leurs valeurs précédentes.
# Affectation simple
x = 10
 # Addition Assignment
x += 5 # Equivalent à : x = x + 5
# Exercice de soustraction
x -= 3 # Equivalent à : x = x - 3
# Affectation de la
multiplication
x *= 2 # Equivalent à : x = x * 2
# Affectation de la division
x /= 4 # Equivalent à : x = x / 4

3. Opérateurs de comparaison :
Les opérateurs de comparaison sont utilisés pour comparer des valeurs
et renvoyer un résultat booléen (vrai ou faux). Ces opérateurs sont
pratiques lorsqu'il s'agit de prendre des décisions ou d'effectuer des
opérations conditionnelles.
# égal au
résultat = 5 ==
5
print(result) # Sortie : True
# Pas égal à
résultat = 5 != 5
print(result) # Sortie : False
# Plus grand que
résultat = 10 > 5
print(result) # Sortie : True
# Inférieur ou égal à
résultat = 3 <= 2
print(result) # Sortie : Faux

Vous pouvez également écrire votre code de cette manière. Définissez

d'abord deux variables, puis comparez-les une par une ou en une seule fois.
#COMPARAISON
OPERATORS n = 10
s=7
print(n>s) # Sortie : True
print(n>=s) # Sortie : True
print(n<s) # Sortie : False
print(n<=s) # Sortie[ut :
Faux print(n==s) #
Sortie : Faux
 print(n!=s) # Sortie : Vrai
# Ou vous pouvez écrire en une
seule ligne ! print(n>5, n<5, n==5,
n!=s)
# Sortie : Vrai Faux Faux Vrai

4. Opérateurs logiques :
Les opérateurs logiques nous permettent de combiner plusieurs
conditions et d'effectuer des opérations logiques telles que AND, OR et
NOT. Ils sont largement utilisés dans la prise de décision et les
instructions de flux de contrôle.
# Opérateur AND
result = True and False
print(result) # Sortie : Faux
# Opérateur OR
result = True or False
print(result) # Sortie : True
# Opérateur NOT
result = not True
print(result) # Sortie : Faux

5. Opérateurs d' adhésion :

Les opérateurs d'appartenance sont utilisés pour vérifier si une valeur
ou une variable est présente dans une séquence, telle qu'une liste, un tuple
ou une chaîne de caractères. Les deux opérateurs d'appartenance en Python
sont "in" et "not in".
# dans Opérateur
result = 'a' in 'apple'
print(result) # Output :
True # not in Operator
result = 'b' not in 'apple'
print(result) # Output :
Vrai

6. Opérateurs d'identité :
Les opérateurs d'identité sont utilisés pour comparer les emplacements
mémoire de deux objets. Ces opérateurs vérifient si deux variables font
référence au même objet ou non. Les deux opérateurs d'identité en Python
sont "is" et "is not".
# est
l'opérateur x
= [1, 2, 3]
y=x
résultat = y est x
 print(result) # Sortie : True
# n'est pas un opérateur
x = [1, 2, 3]
y = [1, 2, 3]
result = y is not x print(result)
# Output :
Vrai

7. Opérateurs Bitwise :
Les opérateurs bitwise effectuent des opérations sur des bits individuels
de nombres binaires. Ces opérateurs sont utiles dans les scénarios où vous
devez manipuler des données à un niveau inférieur.
# Bitwise AND
result = 5 & 3
print(result) # Sortie : 1
# Bitwise OR
résultat = 5 | 3
print(result) # Sortie : 7
# Bitwise XOR
résultat = 5 ^ 3
print(result) # Sortie : 6
# Bitwise NOT
résultat = ~5
print(result) # Sortie : -6
# Décalage bit à bit vers la
gauche
result = 5 << 1 print(result)
# Output :
10 # Bitwise Right Shift
résultat = 5 >> 1
print(résultat)# Sortie :
2

Explorons maintenant d'autres aspects du monde des opérateurs !

Priorité de l'opérateur :

La priorité des opérateurs fait référence à l'ordre dans lequel les opérateurs
sont évalués dans une expression. Python suit des règles spécifiques pour la
préséance des opérateurs afin de
garantissent que les expressions sont évaluées correctement. Il est essentiel
de comprendre ces règles pour éviter des résultats inattendus. Comme :

Les parenthèses : Les expressions entre parenthèses sont évaluées en premier.

L'exponentiation : L'exponentiation est effectuée ensuite.
Multiplication, division et module : Ces opérateurs sont évalués de
gauche à droite.
Addition et soustraction : Ces opérateurs sont évalués de gauche à
droite.
Opérateurs de comparaison : Ces opérateurs sont évalués ensuite.
Opérateurs logiques : Les opérateurs logiques "not", "and" et "or" sont
évalués dans cet ordre.
Opérateurs d'affectation : Les opérateurs d'affectation sont évalués en dernier.

Il est important de noter que vous pouvez utiliser des parenthèses pour
ignorer la priorité par défaut et spécifier explicitement l'ordre d'évaluation
dans les expressions complexes.

Surcharge de l'opérateur :

En Python, la surcharge des opérateurs vous permet de définir le

comportement des opérateurs pour les objets définis par l'utilisateur. Cette
fonctionnalité vous permet d'utiliser des opérateurs tels que "+", "-", "*" et
"==" dans vos classes personnalisées. En implémentant des méthodes
spéciales dans vos classes, vous pouvez personnaliser le comportement des
opérateurs.

classe Vector :
def init (self, x, y) :
self.x = x
self.y = y

def add (self, other) :

new_x = self.x + other.x
new_y = self.y + other.y
return Vector(new_x, new_y)

def eq ( self, other) :

return self.x == other.x et self.y == other.y

# Utilisation
v1 = Vecteur(1,
2) v2 =
Vecteur(3, 4) v3
= v1 + v2
print(v3.x, v3.y) # Sortie : 4 6

print(v1 == v2) # Sortie : Faux

Ici, nous avons défini l'élément ' add pour ajouter deux objets 'vector'
ensemble. Nous avons également implémenté la méthode ' eq pour
comparer l'égalité de deux objets 'vector' à l'aide de l'opérateur '=='. Ceci
illustre la puissance de la surcharge des opérateurs en Python.

Si vous n'avez pas compris cet exemple, ne vous inquiétez pas. Pour
l'instant, jetez-y un coup d'œil et essayez de comprendre son
fonctionnement et ses utilisations. Nous allons explorer chaque élément
étape par étape. Nous allons lentement, car la compréhension est également
importante. Si nous procédons sans connaître les bases, nous serons
confrontés à des problèmes à l'avenir. Il n'y a pas lieu de s'inquiéter de ce
que vous ne comprenez pas pour l'instant. Il suffit de prendre les codes, de
les essayer, de faire quelques changements et d'obtenir des erreurs. Vous
obtiendrez alors celles que vous n'obteniez pas auparavant.😅

Les opérateurs en Python sont des outils essentiels pour manipuler,

comparer et évaluer les données. Nous avons exploré différents types
d'opérateurs, notamment les opérateurs arithmétiques, d'affectation, de
comparaison, logiques, d'appartenance, d'identité, bitwise et de précédence.
Nous avons également abordé le concept de surcharge des opérateurs.
En maîtrisant l'utilisation des opérateurs, vous pouvez écrire un code
concis et expressif pour résoudre un large éventail de problèmes. Il est
recommandé de
s'entraîner à utiliser les opérateurs dans différents scénarios afin de se
familiariser avec leur utilisation.
Rappelez-vous que les opérateurs sont comme des blocs de
construction qui vous permettent de construire des algorithmes et des
programmes complexes. Profitez de leur puissance et libérez votre
créativité dans la programmation Python. Ne vous précipitez pas ! 😄
 2.3. FLUX DE CONTRÔLE
(INSTRUCTIONS "SI",
BOUCLES)
Dans le monde de la programmation, le flux de contrôle fait référence à
l'ordre dans lequel les instructions sont exécutées. Il nous permet de dicter
le flux de notre programme, ce qui le rend plus dynamique et plus réactif
aux différentes conditions et entrées.
Python, un langage de programmation polyvalent et populaire, offre de
puissants mécanismes de flux de contrôle qui permettent aux développeurs
de créer des applications complexes et efficaces.
Dans cette section, nous allons nous plonger dans les fonctionnalités de
flux de contrôle de Python, en abordant les instructions conditionnelles, les
boucles et les mots-clés de flux de contrôle.
1. Déclarations conditionnelles
Les instructions conditionnelles nous permettent de contrôler le
déroulement de notre programme en fonction de certaines conditions. Elles
nous aident à prendre des décisions et à exécuter différents blocs de code
selon qu'une condition est vraie ou fausse.

a) si l'énoncé :

L'instruction "if" est la forme la plus simple d'une instruction

conditionnelle. Elle exécute un bloc de code si une condition spécifiée est
vraie.

âge = 20
si âge >= 18 :
print("You are eligible to vote.") #

Output : Vous avez le droit de

voter.
Ici, l'instruction "if" vérifie si la variable "age" est supérieure ou égale à
18. Si la condition est vraie, il imprime le message "Vous avez le droit de
voter". Sinon, il passe au bloc de code suivant.
b) sinon l'énoncé :

L'instruction "else" nous permet de spécifier un bloc de code qui sera

exécuté si la condition de l'instruction "if" est fausse.

âge = 15
si âge >= 18 :
print("Vous avez le droit de
vote") else :
print("You are not yet eligible to vote.") #

Output : Vous n'avez pas encore le droit

de vote.

Dans ce cas, comme la valeur de "age" est de 15 (moins de 18 ans), la

condition "if" est fausse et le code contenu dans le bloc "else" est exécuté.
Il imprime le message "Vous n'avez pas encore le droit de vote".

c) elif statement :

L'instruction "elif" est utilisée lorsque nous voulons tester plusieurs

conditions. Elle signifie "else if" et permet d'enchaîner plusieurs
conditions.

score = 85
if score >= 90 :
print("Votre note est A.")
elif score >= 80 :
print("Votre note est B.")
elif score >= 70 :
print("Votre note est C.")
else :
print("Votre note est D.")

# Sortie : Votre note est B.

Dans cet extrait de code, le programme évalue la note et imprime la note

correspondante en fonction des conditions. Si la note est de 85, l'instruction
"elif" "note≥80" est vraie et le programme imprime "Votre note est B".

2. Boucles
Les boucles sont utilisées pour répéter un bloc de code plusieurs fois.
Elles nous permettent d'effectuer des tâches itératives et de traiter les
données plus efficacement.
Python propose deux principaux types de boucles : les boucles "for" et les boucles
"while".

a) pour la boucle :

La boucle "for" parcourt une séquence d'éléments et exécute un bloc de

code pour chaque élément.

fruits = ["pomme", "banane",

"orange"] pour fruit dans fruits :
print(fruit)

# Sortie
pomme
banane
orange

# ou si vous voulez qu'il soit sur une seule ligne avec un

espacement, alors : for fruit in fruits :
print(fruit, end=" ")

# Output : apple banana orange

# Vous pouvez modifier selon vos besoins et votre plaisir!😀
Dans cet extrait de code, la boucle "for" parcourt chaque élément de la liste
"fruit" et l'imprime.

b) boucle while :

La boucle "while" poursuit l'exécution d'un bloc de code tant qu'une

condition spécifiée reste vraie.

compte = 0
while count < 5 :
print(count)
count += 1

# Sortie :
0
1
2
3
4

"""
Ici, si vous ne l'incrémentez pas de 1 (count += 1), alors
il lancera continuellement 0 0 0 0 0... jusqu'à ce que vous
l'arrêtiez. Lorsque vous l'arrêterez, il dira
"KeyboardInterrupt". Ne faites pas cela, sinon votre système
risque de se planter aussi !
"""

Dans cet extrait de code, la boucle "while" s'exécute jusqu'à ce que la

valeur de "count" soit inférieure à 5. Elle imprime la valeur de "count" et
l'incrémente de 1 à chaque itération.

3. Mots clés du flux de contrôle

 Python fournit des mots-clés de flux de contrôle supplémentaires qui
nous permettent de modifier le comportement des boucles et des
instructions conditionnelles.

a) pause :

Le mot-clé "break" est utilisé pour sortir prématurément d'une boucle.

Lorsqu'il est rencontré, il met immédiatement fin à la boucle et reprend
l'exécution à la prochaine instruction en dehors de la boucle.

nombres = [1, 2, 3, 4, 5]
pour nombre dans
nombres :
si nombre == 3 :
break
print(nombre)

# Sortie :
1
2

# Mais si vous faites quelque chose comme ça :

pour le nombre dans les nombres :
si nombre == -3 :
break
print(nombre)

# sortie :
1
2
3
4
5

# Modifiez le code et essayez vous-même, obtenez des erreurs et voyez à quel point c'est excitant !
Dans cet extrait de code, la boucle se termine lorsqu'elle rencontre le nombre
3. Prenez ce code, voyez ce qu'il exécute, puis faites des changements de
votre propre chef, c'est normal d'avoir des erreurs, c'est un autre moment
quand vous résolvez quelque chose de votre propre chef après avoir obtenu
des erreurs. Vous pouvez modifier selon vos besoins et vous amuser ! 😀

b) continuer :

Le mot-clé "continue" est utilisé pour ignorer le reste du code à l'intérieur

d'une boucle pour l'itération en cours et passer à l'itération suivante.

nombres = [1, 2, 3, 4, 5]
pour nombre dans
nombres :
si nombre == 3 :
continue
print(nombre)

# sortie :
1
2
4
5

Dans cet extrait de code, lorsque la boucle atteint le nombre 3, elle ignore
l'instruction "print" et passe à l'itération suivante.

c) passer :

Le mot-clé "pass" est utilisé comme un espace réservé lorsqu'une

instruction est syntaxiquement nécessaire mais ne doit rien faire. Il agit
comme une opération nulle et permet au code de passer sans aucune action.
nombre = 10
si nombre > 5
:
passer
autre
chose :
print("Le nombre est inférieur ou égal à 5.")

# Sortie : Il passera simplement la fonction et ne renverra rien !

Dans cet extrait de code, l'instruction "pass" est utilisée pour indiquer
qu'aucune action n'est nécessaire lorsque la condition est vraie. Si le
nombre est inférieur ou égal à 5, l'instruction "print" est exécutée.

4. Imbrication des instructions de flux de contrôle

L'un des aspects puissants du flux de contrôle en Python est la
possibilité d'imbriquer les instructions de flux de contrôle les unes dans les
autres.
Cette imbrication nous permet de créer des structures décisionnelles et
de bouclage plus complexes.
grade = 75
si note >= 60 :
si note >= 90 :
print("Vous avez obtenu la note A
!") elif note >= 80 :
print("Vous avez obtenu la note B
!") else :
print("Vous avez obtenu la note
C.") else :
print("Vous n'avez pas réussi
l'examen.") # Sortie : Vous avez
obtenu la note C.

Dans cet extrait de code, nous avons imbriqué des instructions "if",
"elif" et "else" à l'intérieur de l'instruction "if" extérieure. En fonction de la
valeur de "grade", le bloc de code correspondant sera exécuté. Cela
démontre la flexibilité et l'expressivité du flux de contrôle en Python.
5. Le flux de contrôle dans les applications réelles
 Le flux de contrôle est un concept fondamental qui joue un rôle crucial
dans diverses applications du monde réel.
Explorons quelques scénarios dans lesquels le flux de contrôle est couramment
utilisé !

a) Validation des données par l'utilisateur :

Lors du développement de programmes interactifs, il est essentiel de

valider les entrées de l'utilisateur afin de s'assurer qu'elles répondent à des
critères spécifiques. Le flux de contrôle nous permet de vérifier la validité
de l'entrée de l'utilisateur et de l'inviter à entrer des informations correctes
si nécessaire.

age = int(input("Enter your age : "))

if age >= 18 :
print("Vous avez le droit de
participer.") else :
print("Vous êtes trop jeune pour participer")

# Entrée : Entrez votre âge : 20

# Sortie : Vous pouvez participer.

# Entrée : Entrez votre âge : 14

# Sortie : Vous êtes trop jeune pour entrer.

Dans cet extrait de code, le programme invite l'utilisateur à saisir son

âge. L'instruction "if" vérifie si l'âge est supérieur ou égal à 18 ans et
affiche le message approprié.

b) Filtrage et traitement des données :

Le flux de contrôle est souvent utilisé dans les tâches de filtrage et de

traitement des données. Il nous permet d'itérer sur des ensembles de
données, d'appliquer des conditions spécifiques et d'effectuer des actions en
fonction des résultats.
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_sum = 0
odd_sum = 0
pour le nombre dans les nombres :
si nombre % 2 == 0 :
even_sum += nombre
else :
odd_sum += nombre
print("Somme des nombres pairs :",
even_sum) print("Somme des nombres
impairs :", odd_sum)

# Sortie :
Somme des nombres pairs
: 30 Somme des nombres
impairs : 25

Dans cet extrait de code, la boucle "for" parcourt chaque nombre de la liste
"numbers". L'instruction "if" vérifie si le nombre est pair ou impair et
calcule la somme en conséquence. Enfin, elle imprime la somme des
nombres pairs et la somme des nombres impairs.

c) Contrôle du flux du programme :

Les mots-clés de contrôle tels que "break" et "continue" nous permettent de

contrôler le flux d'exécution à l'intérieur des boucles. Ils nous aident à
optimiser nos programmes et à éviter les itérations inutiles.

pause :

names = ["Nibe", "Dita", "Nibedita", "NS"]

for name in names :
if name == "Nibedita" :
break
print(nom)
 # Sortie :
Nibe Dita

Poursuivre :

names = ["Nibe", "Dita", "Nibedita", "NS"]

for name in names :
si nom == "Nibedita" :
continuer
print(nom)

# Sortie :
Nibe
Dita
NS

Le flux de contrôle est un concept fondamental en programmation, et

Python fournit un riche ensemble de fonctionnalités pour le gérer
efficacement. Dans cet article, nous avons exploré les instructions
conditionnelles, notamment "if", "else" et "elif", qui nous permettent de
prendre des décisions en fonction de conditions. Nous avons également
abordé les boucles, telles que "for" et "while", qui nous permettent d'itérer
sur des séquences et de répéter des blocs de code.
En outre, nous avons examiné des mots-clés de flux de contrôle tels que
"break", "continue" et "pass", qui offrent un contrôle et une flexibilité
supplémentaires au sein des boucles et des instructions conditionnelles.
Avec une solide compréhension du flux de contrôle en Python, vous
pouvez créer des programmes dynamiques et efficaces qui répondent à
diverses conditions et entrées. Continuez donc à vous entraîner et à
explorer les possibilités du flux de contrôle, et vous serez bien équipé pour
écrire un code robuste et adaptable.
 2.4. FONCTIONS ET MODULES
Dans le domaine de la programmation, l'efficacité et l'organisation jouent
un rôle essentiel dans le processus de développement. Python, un langage
de programmation polyvalent et populaire, fournit aux développeurs des
outils puissants pour créer un code propre, lisible et facile à maintenir. Les
fonctions et les modules sont deux concepts essentiels qui permettent
d'atteindre ces objectifs. Dans cette section, nous allons explorer les
fonctions et les modules en Python, leur importance et la manière dont ils
contribuent à la modularité du code, à sa réutilisation et à la structure
globale du programme.
 I. FONCTIONS : LES ÉLÉMENTS
CONSTITUTIFS DES
PROGRAMMES PYTHON
En Python, les fonctions sont des blocs de code organisés et réutilisables
qui exécutent des tâches spécifiques. Elles encapsulent une séquence
d'instructions, ce qui nous permet de décomposer des problèmes complexes
en éléments plus petits et plus faciles à gérer. En mettant en œuvre des
fonctions, nous pouvons améliorer la lisibilité du code, promouvoir la
réutilisation du code et améliorer la maintenabilité globale de nos
programmes.
1. Définition des fonctions :
Pour définir une fonction en Python, on utilise le mot-clé "def" suivi du
nom de la fonction et d'une paire de parenthèses.
def add_numbers(a, b) :
renvoie a + b

2. Fonctions d'appel :
Une fois que nous avons défini une fonction, nous pouvons l'appeler
plusieurs fois dans notre programme. L'appel d'une fonction exécute les
instructions contenues dans son bloc et renvoie le résultat, le cas échéant.
Voici comment nous appelons la fonction "add_numbers" de tout à l'heure :
result = add_numbers(5, 7)
print(result) # Output :
12

3. Paramètres et arguments des fonctions :

Les fonctions en Python peuvent accepter des paramètres, qui servent
d'espaces réservés pour les valeurs transmises lors de l'appel de la fonction.
Ces valeurs sont appelées arguments. Modifions notre fonction
"add_numbers" pour illustrer ce concept :
def add_numbers(a, b) :
renvoie a + b
result = add_numbers(5, 7)
print(result) # Output :
12

4. Paramètres par défaut :

 Les fonctions Python peuvent également avoir des valeurs de
paramètres par défaut. Ces valeurs sont utilisées lorsqu'un argument n'est
pas fourni lors de l'appel de la fonction. Par exemple
améliorer notre fonction "add_numbers" pour y inclure un paramètre par défaut :
def add_numbers(a, b=0) :
return a + b
result = add_numbers(5)
print(result) # Output :
5
 II. MODULES : ORGANISER LE CODE EN
UNITÉS RÉUTILISABLES
Alors que les fonctions aident à décomposer les problèmes complexes, les
modules servent de conteneurs pour organiser les fonctions, les classes et
les variables connexes en unités réutilisables. Les modules facilitent la
séparation du code, encouragent la réutilisation du code et permettent une
meilleure évolutivité du projet.
1. Création de modules :
En Python, un module est simplement un fichier contenant du code
Python. En regroupant des fonctions et des classes apparentées dans un
module, nous pouvons organiser notre base de code de manière efficace.
Créons un module appelé "math_operations.py" :
# math_operations.py
def add_numbers(a, b) :
return a + b
def multiply_numbers(a, b) :
return a * b

2. Importation de modules :
Pour utiliser les fonctions définies dans un module, nous devons
l'importer dans notre script actuel. Python propose plusieurs façons
d'importer des modules :

Importation du module entier :

Importation du module entier :

import math_operations

result = math_operations.add_numbers(5, 7)
print(result) # Output : 12

Importation de fonctions spécifiques :

from math_operations import add_numbers, multiply_numbers

result = add_numbers(5, 7)
print(result) # Output :
12

Importation avec un alias :

from math_operations import add_numbers as add

result = add(5, 7)
print(result) # Sortie : 12

3. Modules de la bibliothèque standard :

Python fournit également un riche ensemble de modules de bibliothèque
standard qui offrent un large éventail de fonctionnalités. Ces modules
couvrent différents domaines tels que les mathématiques, la gestion des
fichiers, les opérations de réseau, etc. Pour utiliser ces modules, nous
pouvons les importer dans nos programmes.
import random
nombre_aléatoire = random.randint(1, 10)
print(nombre_aléatoire)
 III. AVANTAGES DES FONCTIONS
ET DES MODULES
1. Réutilisation du code :
Les fonctions et les modules favorisent la réutilisation du code, ce qui
nous permet d'utiliser le même code dans différentes parties d'un
programme ou même dans différents projets. Au lieu de réécrire le même
code, il suffit d'appeler des fonctions ou d'importer des modules, ce qui
permet d'économiser du temps et des efforts.
2. Modularité :
Les fonctions et les modules nous permettent de décomposer des
problèmes complexes en éléments plus petits et plus faciles à gérer. Cette
approche modulaire améliore la lisibilité du code et le rend plus facile à
comprendre et à maintenir.
3. Encapsulation :
Les fonctions encapsulent une séquence d'instructions et fournissent
une interface claire pour interagir avec le code. Cette encapsulation nous
permet de cacher les détails de l'implémentation interne et de nous
concentrer sur l'objectif de la fonction et sur les entrées/sorties.
4. Test et débogage :
Les fonctions et les modules facilitent les processus de test et de
débogage. En isolant des fonctionnalités spécifiques au sein de fonctions
ou de modules, nous pouvons facilement écrire des cas de test et
identifier les problèmes lorsque des erreurs se produisent.
5. Collaboration :
Les fonctions et les modules améliorent la collaboration entre les
développeurs. Lorsqu'on travaille en équipe, les fonctions et les modules
offrent un moyen normalisé d'organiser le code. Ils permettent aux
membres de l'équipe de travailler indépendamment sur différentes parties
d'un projet tout en garantissant la compatibilité et la cohérence du code.
 IV. MEILLEURES PRATIQUES POUR
LES FONCTIONS ET LES
MODULES
1. Désignation des fonctions :
Choisissez des noms descriptifs et significatifs pour les fonctions, qui
représentent avec précision leur objectif et leur fonctionnalité. Respectez
les conventions de dénomination de Python, en utilisant des lettres
minuscules et des traits de soulignement pour séparer les mots (par
exemple, "calculer_moyenne", "traiter_données").
2. Longueur et complexité des fonctions :
Les fonctions doivent être concises, ciblées et n'effectuer qu'une seule tâche.
Évitez de créer des fonctions trop longues ou qui effectuent trop
d'opérations. Divisez les fonctions complexes en fonctions plus petites et
réutilisables pour améliorer la maintenabilité du code.
3. Documentation de la fonction :
Fournissez une documentation claire et concise pour vos fonctions, y
compris des informations sur leur objectif, leurs paramètres, leurs valeurs
de retour et leurs éventuels effets secondaires. Une bonne documentation
aide les autres développeurs à comprendre et à utiliser efficacement vos
fonctions.
4. Structure du module :
Organiser les fonctions, classes et variables apparentées au sein d'un
module en fonction de leur fonctionnalité ou de leur objectif. Utiliser les
commentaires et les chaînes de caractères pour fournir une vue d'ensemble
du module et documenter les détails importants du code qu'il contient.

5. Importations de modules :
N'importez que les fonctions ou classes nécessaires d'un module pour
éviter d'encombrer l'espace de noms. Si un module contient un grand
nombre de fonctions, l'importation de fonctions spécifiques peut améliorer
la lisibilité du code et éviter les conflits de noms potentiels.
6. Réutilisation des modules :
 Lors de la création de modules, il faut s'efforcer d'obtenir une grande
réutilisabilité. Veillez à ce que le module puisse être utilisé dans différents
contextes sans être étroitement lié à des parties spécifiques du programme.
Créez des modules avec des limites claires et des interfaces bien définies.
Dans cette section, nous avons appris à connaître les fonctions et les modules.
Les fonctions et les modules sont des concepts fondamentaux de
Python qui contribuent grandement à l'organisation, à la réutilisation et à la
maintenance du code. En utilisant des fonctions, nous pouvons décomposer
des problèmes complexes en éléments plus petits et plus faciles à gérer,
tandis que les modules nous permettent d'organiser le code connexe en
unités réutilisables.
Le respect des meilleures pratiques, telles que le choix de noms
descriptifs, la création de fonctions modulaires et concises et la
documentation adéquate du code, contribue à améliorer la collaboration, la
lisibilité du code et la facilité de maintenance.
L'exploitation de la puissance des fonctions et des modules en Python
permet aux développeurs d'écrire un code propre, modulaire et efficace, ce
qui favorise de meilleures pratiques de développement logiciel et accélère
le processus de développement. Alors, faites des fonctions et des modules
vos alliés dans la programmation Python, et libérez leur potentiel pour
créer des solutions élégantes et robustes.
 2.5. ENTRÉE/SORTIE ET TRAITEMENT DES
FICHIERS
Python, connu pour sa simplicité et sa polyvalence, offre un large éventail
de fonctionnalités pour gérer les opérations d'entrée/sortie et la
manipulation des fichiers. Que vous soyez un débutant faisant ses premiers
pas dans la programmation ou un développeur expérimenté cherchant à
rafraîchir ses connaissances, cette section vous servira de guide complet
pour comprendre et utiliser les concepts d'entrée/sortie et de manipulation
de fichiers en Python.
Avant d'entrer dans les détails, examinons brièvement ce que les
entrées/sorties (E/S) et la gestion des fichiers impliquent dans le contexte
de la programmation.
Comprendre les entrées/sorties et le traitement des fichiers :
Les entrées/sorties (E/S) désignent la communication entre un
programme et son environnement externe, tel que l'utilisateur, les fichiers
ou les ressources réseau. En Python, les E/S sont essentielles pour interagir
avec les utilisateurs, lire des données dans des fichiers, écrire des données
dans des fichiers et effectuer diverses opérations sur les flux d'entrée et de
sortie.
La gestion des fichiers, quant à elle, se concentre spécifiquement sur la
lecture et l'écriture dans les fichiers. Les fichiers constituent un mécanisme
de stockage persistant, qui permet de stocker et d'extraire des données lors
de l'exécution de différents programmes.
Lecture des données de l'utilisateur :
Commençons par l'un des aspects les plus fondamentaux des E/S : la
lecture des entrées utilisateur. La fonction "input" de Python vous permet de
demander des informations à l'utilisateur et de stocker la valeur fournie dans
une variable.
name = input("Veuillez saisir votre nom : ")
print("Hello, " + name + " ! Welcome to our program.")
# Input : Veuillez saisir votre nom : NS
# Sortie : Bonjour, NS ! Bienvenue dans notre programme.

Dans cet extrait de code, la fonction "input" affiche l'invite "Veuillez

saisir votre nom : ", et la saisie de l'utilisateur est stockée dans la
variable "name". Le programme accueille ensuite l'utilisateur en utilisant
le nom saisi.
Sortie et impression standard :
La fonction "print" de Python permet d'afficher des informations sur la
sortie standard, généralement la console. Elle accepte un ou plusieurs
arguments et
les édite sous forme de texte.
name = "NS"
age = 20
print("Nom :", nom, "\nAge :", âge)

# Sortie :
Nom : NS
Age : 20
# Ici, nous avons utilisé "\n" : C'est ce qu'on appelle un
caractère de nouvelle ligne. # Ça a l'air bien, alors j'ai
ajouté : faites comme vous voulez ! 😅

Lorsqu'il est exécuté, ce code s'affiche : "Name : NS Age : 20" sur la

console si vous n'ajoutez pas de caractère de nouvelle ligne ; sinon, vous
pouvez voir ce que cela donne.
Lecture de fichiers :
Pour lire les données d'un fichier, vous devez l'ouvrir en mode lecture à
l'aide de la fonction "open".
file = open("data.txt", "r")
content = file.read()
file.close()
print(content)

Ici, le fichier nommé "data.txt" est ouvert en mode lecture ("r"), et

l'ensemble de son contenu est lu à l'aide de la méthode "read". Enfin, le
contenu est affiché à l'aide de la fonction "print". Il est essentiel de fermer
le fichier à l'aide de la méthode "close" après avoir terminé la lecture afin
de libérer les ressources du système. Si vous n'avez pas de fichier nommé
"data.txt", créez-en un ou faites en sorte que le programme lise le fichier
que vous avez déjà.
Sinon il y aura une erreur, la console dira "qu'avez-vous pensé et
essayé d'exécuter, où vais-je le trouver, allez en créer un ou exécutez celui
que vous avez déjà" 😅 c'est juste une petite blague ! Bon, passons au
suivant...
Écrire dans des fichiers :
Comme pour la lecture, vous pouvez ouvrir un fichier en mode écriture
("w") pour y écrire des données.
file = open("output.txt", "w")
 file.write("Hello, World !")
file.close()

Dans cet extrait, le fichier "output.txt" est ouvert en mode écriture et le

texte "Hello, World !" y est écrit à l'aide de la méthode "write". N'oubliez
pas de fermer le fichier après l'écriture pour vous assurer que les données
sont correctement sauvegardées.
Ajout aux fichiers :
L'ajout de données à un fichier existant peut être effectué en ouvrant le
fichier en mode ajout ("a").
file = open("log.txt", "a")
file.write("Nouvelle entrée dans le
journal.\n") file.close()

Ce code ouvre le fichier "log.txt" en mode append, ajoute une nouvelle

entrée de journal, puis ferme le fichier. Le "\n" représente un caractère de
nouvelle ligne, assurant que chaque entrée est écrite sur une nouvelle ligne.
J'ai déjà expliqué cela auparavant.
Les gestionnaires de contexte et la déclaration "avec" :
Python offre un moyen pratique de gérer les opérations sur les fichiers
à l'aide de gestionnaires de contexte et de l'instruction "with". Les
gestionnaires de contexte gèrent automatiquement l'allocation et la
désallocation des ressources. Voyons comment cela peut simplifier notre
code de gestion des fichiers :
avec open("data.txt", "r") comme fichier :
content = file.read()
print(content)

Dans cet exemple, l'instruction "with" se charge d'ouvrir le fichier et la

poignée du fichier est assignée à la variable "file". Une fois que le bloc de
code en retrait est exécuté, le fichier est automatiquement fermé, qu'une
exception se produise ou non.
Dans ce guide destiné aux débutants, nous avons couvert les bases de
l'entrée/sortie et de la gestion des fichiers en Python. Vous avez appris à lire
les entrées de l'utilisateur, à afficher du texte sur la console, à lire des
fichiers, à écrire dans des fichiers et à ajouter des données à des fichiers
existants. N'oubliez pas de fermer les fichiers après utilisation ou d'utiliser
l'instruction "with" pour une gestion automatique.
Les capacités d'E/S et de gestion de fichiers de Python sont essentielles
pour la création d'applications interactives, le traitement de grands
ensembles de données et la conservation des données.
d'information. En maîtrisant ces concepts, vous acquerrez les compétences
nécessaires pour développer des programmes Python puissants.
Au fur et à mesure que vous progressez dans la programmation,
n'hésitez pas à explorer des techniques avancées, telles que la manipulation
de fichiers CSV, le travail avec des données binaires ou l'utilisation de
bibliothèques externes telles que pandas. Le riche écosystème de Python
fournit de nombreuses ressources pour améliorer vos compétences en
matière d'entrées/sorties et de manipulation de fichiers.
 2.6. TRAITEMENT DES EXCEPTIONS
La gestion des exceptions est un aspect vital de tout langage de
programmation, et Python ne fait pas exception (jeu de mots !). En Python,
les exceptions sont des événements qui se produisent au cours de
l'exécution d'un programme et qui entraînent l'arrêt du déroulement normal
du programme. Ces exceptions peuvent survenir pour diverses raisons,
telles que des entrées non valides, l'indisponibilité de ressources ou même
des erreurs de programmation. Heureusement, Python fournit un
mécanisme robuste et flexible pour gérer les exceptions, ce qui permet aux
développeurs de gérer les erreurs avec élégance et d'assurer la stabilité et la
fiabilité de leurs applications.
À la fin, vous aurez une solide compréhension de la manière de gérer
efficacement les exceptions et d'écrire un code robuste.
1. Le bloc try-except :
Le mécanisme central de gestion des exceptions en Python est le bloc
try-except. Il vous permet d'entourer un bloc de code susceptible de lever
une exception et de spécifier comment le programme doit gérer cette
exception.
essayer :
# Code susceptible de soulever une
exception except ExceptionType :
# Code de gestion des exceptions

Dans l'exemple ci-dessus, le code contenu dans le bloc "try" est

exécuté. Si une exception de type "ExceptionType" se produit, l'exécution
est immédiatement transférée au bloc "except", où l'exception est traitée. Si
aucune exception ne se produit, le bloc "except" est ignoré.
2. Rattrapage d'exceptions multiples :
Python vous permet d'attraper plusieurs exceptions dans un seul bloc
"except" en les spécifiant sous la forme d'un tuple. Cette fonctionnalité est
utile lorsque des exceptions différentes nécessitent une logique de
traitement similaire.
essayer :
# Code susceptible de lever une exception
except (ExceptionType1, ExceptionType2)
: # Code de gestion des exceptions
 Dans ce cas, si le type d'exception 1 ou le type d'exception 2 est levé, le
code contenu dans le bloc "except" est exécuté.
3. Traitement des exceptions spécifiques :
Bien qu'il soit pratique d'attraper plusieurs exceptions, il est parfois
nécessaire de traiter chaque exception différemment. Python vous permet
d'avoir des blocs "except" distincts pour les différents types d'exception.
essayer :
# Code susceptible de soulever une
exception except ExceptionType1 :
# Code de gestion des exceptions pour
ExceptionType1 sauf ExceptionType2 :
# Code de gestion des exceptions pour le type d'exception 2

Dans le code ci-dessus, si "ExceptionType1" est soulevé, le premier

bloc "except" sera exécuté. Si l'exception de type 1 est soulevée, le
deuxième bloc "except" la traitera.
4. La clause de l'autre :
En plus des blocs "try" et "except", Python fournit une clause facultative
"else" qui peut être utilisée pour spécifier le code qui doit être exécuté
uniquement si aucune exception ne se produit. Cette clause est
particulièrement utile lorsque vous souhaitez effectuer certaines actions
lorsque votre code s'exécute correctement.
essayer :
# Code susceptible de soulever une
exception except ExceptionType :
# Code de gestion des
exceptions else :
# Code à exécuter si aucune exception ne se produit

Le code contenu dans le bloc "else" ne sera exécuté que si aucune

exception n'est levée dans le bloc "try".

5. La clause finale :
Un autre aspect essentiel de la gestion des exceptions en Python est la
clause "finally". Elle vous permet de spécifier le code qui doit être exécuté
sans tenir compte des exceptions.
qu'une exception se produise ou non. Cela permet de s'assurer que les
opérations de nettoyage nécessaires sont effectuées, telles que la fermeture
des fichiers ou la libération des ressources.
essayer :
# Code susceptible de soulever une
exception except ExceptionType :
# Code de gestion des
exceptions enfin :
# Code à exécuter sans tenir compte des exceptions

Le bloc "finally" est exécuté même si une exception se produit et est

traitée dans un bloc "except". Il est généralement utilisé pour libérer des
ressources et effectuer des opérations de nettoyage.
6. Lever les exceptions :
En plus de la gestion des exceptions, Python vous permet de lever des
exceptions explicitement en utilisant l'instruction "raise". Cela peut s'avérer
utile lorsque vous rencontrez une condition spécifique qui justifie la levée
d'une exception.
def divide(x, y) :
si y == 0 :
raise ZeroDivisionError("Impossible de diviser par
zéro") return x / y

Dans le code ci-dessus, si la valeur de "y" est 0, une exception

"ZeroDivisionError" est explicitement levée avec un message d'erreur
personnalisé.
7. Exceptions personnalisées :
Python vous permet également de définir vos propres exceptions en
créant une nouvelle classe qui hérite de la classe "Exception" ou de ses
sous-classes. Les exceptions personnalisées peuvent s'avérer utiles lorsque
vous souhaitez fournir des détails plus précis sur l'erreur ou traiter
différemment certains scénarios.
classe CustomException(Exception) :
essai
de
passa
ge :
# Code qui pourrait soulever une exception
personnalisée except CustomException as e
:
 # Code de gestion des exceptions pour CustomException

Dans le code ci-dessus, si une "CustomException" est soulevée, le bloc

"except" correspondant la traitera.
 La gestion des exceptions est un aspect crucial de l'écriture d'un code
Python fiable et robuste. En utilisant des blocs try-except, vous pouvez
gérer les exceptions de manière élégante, en veillant à ce que votre
programme continue à fonctionner sans problème, même en cas d'erreur. La
flexibilité offerte par le mécanisme de gestion des exceptions de Python
vous permet d'adapter vos stratégies de gestion des erreurs aux besoins
spécifiques de votre application. Avec les connaissances acquises dans cet
article, vous êtes maintenant équipé pour gérer efficacement les exceptions
et écrire des programmes Python plus résistants.
N'oubliez pas que la gestion des exceptions ne consiste pas seulement
à éviter les pannes de programme, mais aussi à fournir un retour
d'information significatif aux utilisateurs, à enregistrer les erreurs à des
fins de débogage et à prendre les mesures correctives qui s'imposent.
Alors, profitez de la puissance de la gestion des exceptions en Python et
améliorez la qualité et la fiabilité de votre code !
3. Structures de données :
 3.1. LISTS

3.2. Tuples

3.3. Dictionnaires

3.4. Ensembles et contre-ensembles

3.5. Tableaux (NumPy)

3.6. Séries et DataFrames (Pandas)

 3.1. LISTS
Dans le monde de la programmation, les structures de données jouent un
rôle crucial dans l'organisation et la manipulation efficace des données.
L'une de ces structures de données fondamentales en Python est la liste. Les
listes sont des conteneurs polyvalents qui vous permettent de stocker et de
gérer plusieurs éléments de différents types. Dans ce guide complet, nous
allons explorer les tenants et les aboutissants des listes en Python, en
discutant de leurs caractéristiques, de leurs opérations et en fournissant des
extraits de code pour consolider votre compréhension.
C'est notre première section sur les structures de données, lentement
nous couvrirons tous les sujets en Python, et une fois que vous aurez
terminé, vous serez appelé un maître de Python. Ce qui nous attend est très
excitant. Rien ne peut être appris et terminé en une nuit, et rien ne peut
faire de vous un expert de quelque chose en un jour.
Tout nécessite du dévouement et du temps. Alors, restez à l'écoute et
continuez à mettre en œuvre.
Comprendre les listes :
Une liste est une collection ordonnée d'éléments placés entre crochets [ ].
Ces éléments peuvent être de n'importe quel type de données, comme des
nombres, des chaînes de caractères ou même d'autres listes. Les listes sont
mutables, ce qui signifie que vous pouvez modifier leurs éléments après
leur création. Elles prennent également en charge l'indexation et le
découpage, ce qui vous permet d'accéder à des éléments spécifiques ou
d'extraire des sous-listes sans effort.

1. Création de listes :
Pour créer une liste en Python, il suffit de placer les éléments entre
crochets.
fruits = ['pomme', 'banane', 'orange']
Dans l'extrait de code ci-dessus, nous avons créé une liste appelée
"fruits" contenant trois chaînes : "pomme", "banane" et "orange".
liste_vide = []
2. Accès aux éléments de la liste :
 Il est possible d'accéder aux éléments de la liste en utilisant
l'indexation. L'index représente la position d'un élément dans la liste, à
partir de 0 pour le premier élément. Pour accéder à un élément spécifique,
vous pouvez utiliser la notation entre crochets.
fruits = ['pomme', 'banane', 'orange']
print(fruits[0]) # Sortie : pomme
print(fruits[1]) # Sortie : banane
print(fruits[2]) # Sortie : orange

Dans l'extrait de code ci-dessus, nous avons imprimé les premier,

deuxième et troisième éléments de la liste "fruits" en accédant à leurs
indices respectifs.
Modification des éléments d'une liste : Les listes sont mutables, ce qui
signifie que vous pouvez modifier leurs éléments en attribuant de nouvelles
valeurs à des indices spécifiques.
fruits = ['pomme', 'banane', 'orange']
fruits[1] = 'mangue'
print(fruits) # Sortie : ['pomme', 'mangue', 'orange']

Dans l'extrait de code ci-dessus, nous avons modifié le deuxième

élément de la liste "fruits" en remplaçant "banane" par "mangue". La liste
résultante reflète désormais la valeur mise à jour.
3. Ajouter et étendre des listes :
Les listes fournissent des méthodes pour ajouter des éléments à la fin.
La méthode "append()" permet d'ajouter un seul élément, tandis que la
méthode "extend()" permet de concaténer une autre liste à la liste existante.
fruits = ['apple', 'banana']
fruits.append('orange')
print(fruits)
# Sortie : ['pomme', 'banane',
'orange'] more_fruits = ['mangue',
'pastèque'] fruits.extend(more_fruits)
print(fruits)
# Sortie : ['pomme', 'banane', 'orange', 'mangue', 'pastèque']

Dans l'extrait de code ci-dessus, nous avons d'abord utilisé la méthode

"append()" pour ajouter la chaîne "orange" à la liste "fruits". Ensuite, nous
avons créé une nouvelle liste appelée "more_fruits" et utilisé la méthode
"extend()" pour la concaténer à la liste "fruits".
4. Découper des listes :
 Les listes peuvent être découpées, ce qui permet d'extraire des sous-listes sur la base
d'indices.
La syntaxe de découpage consiste à spécifier l'indice de début, l'indice de
fin (exclusif) et une valeur de pas optionnelle.
fruits = ['pomme', 'banane', 'orange', 'mangue', 'pastèque']
print(fruits[1:4]) # Sortie : ['banane', 'orange', 'mangue']
print(fruits[:3]) # Sortie : ['apple', 'banana', 'orange']
print(fruits[2 :]) # Output : ['orange', 'mangue', 'pastèque']
print(fruits[::2]) # Sortie : ['pomme', 'orange', 'pastèque']
print(fruits[::-1])
# Sortie : ['pastèque', 'mangue', 'orange', 'banane', 'pomme']

Dans l'extrait de code ci-dessus, nous avons démontré différentes

opérations de découpage sur la liste "fruits". En spécifiant les indices de
début et de fin, nous avons extrait différentes sous-listes. En outre, nous
avons utilisé la valeur de l'étape pour sauter des éléments dans la sous-liste.
Opérations de liste communes :
En dehors des opérations de base, les listes en Python offrent un large
éventail de méthodes pour manipuler et travailler avec les données qu'elles
contiennent. Discutons de quelques opérations de liste couramment
utilisées :

len() : renvoie le nombre d'éléments d'une liste.

index() : renvoie l'indice de la première occurrence d'un élément
spécifié.
count() : renvoie le nombre d'occurrences d'un élément spécifié.
sort() : Trie les éléments de la liste par ordre croissant.
reverse() : inverse l'ordre des éléments de la liste.

Comprenons-le en écrivant le code :

nombres = [5, 9, 2, 7, 8, 3, 1, 7, 4, 6]
print(len(nombres)) # Sortie : 10
print(nombres.index(3)) # Sortie : 5
print(nombres.count(7)) # Sortie : 2
nombres.sort()
print(numbers) # Sortie : [1, 2, 3, 4, 5, 6, 7, 7, 8, 9]
numbers.reverse()
 print(numbers) # Sortie : [9, 8, 7, 7, 6, 5, 4, 3, 2, 1]

Après avoir couvert les bases des listes, il y a quelques points

supplémentaires que les débutants devraient connaître pour améliorer leur
compréhension et leur utilisation des listes en Python :
5. Listes imbriquées :
Les listes peuvent contenir d'autres listes en tant qu'éléments,
créant ainsi une structure imbriquée. Cela permet de créer des
structures de données multidimensionnelles ou de représenter des
relations hiérarchiques.
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0][1]) # Sortie : 2

Dans l'extrait de code ci-dessus, nous avons créé une liste imbriquée
appelée "matrix" dont chaque élément est lui-même une liste. L'accès à des
éléments individuels dans la liste imbriquée implique l'utilisation de
plusieurs indices.
6. Compréhension de listes :
Les compréhensions de listes constituent un moyen concis de créer de
nouvelles listes basées sur des listes existantes. Elles vous permettent de
combiner des boucles et des instructions conditionnelles en une seule ligne
de code.
nombres = [1, 2, 3, 4, 5]
carrés = [x ** 2 for x in numbers]
print(carrés) # Sortie : [1, 4, 9, 16, 25]

Dans l'extrait de code ci-dessus, nous avons utilisé une compréhension

de liste pour créer une nouvelle liste appelée "carrés" dont chaque élément
est le carré de l'élément correspondant dans la liste "nombres".
7. Aliasage et clonage :
Lorsque l'on travaille avec des listes, il est important de comprendre les
concepts d'aliasing et de clonage. Il y a aliasing lorsque deux variables ou
plus font référence au même objet de liste. La modification d'une variable
affecte tous les alias. Pour créer une copie d'une liste sans aliasing, vous
pouvez utiliser la méthode "copy()" ou la notation par tranches.
fruits = ['apple', 'banana', 'orange']
alias = fruits
alias.append('mango')
print(fruits) # Sortie : ['apple', 'banana', 'orange', 'mango']
 clone = fruits.copy()
clone.append('pastèque')
print(fruits) # Sortie : ['apple', 'banana', 'orange', 'grape']
print(clone)
# Sortie : ['pomme', 'banane', 'orange', 'raisin', 'pastèque']

Dans l'extrait de code ci-dessus, nous avons montré comment la

modification de la liste "alias" affecte la liste "fruits", puisqu'elles se
réfèrent au même objet. En revanche, la liste "clone", créée à l'aide de la
méthode "copy()", reste distincte de la liste d'origine. Votre liste d'origine
est donc en sécurité.
8. Liste de la mutabilité et de l'immutabilité :
Si les listes sont mutables, c'est-à-dire que leurs éléments peuvent être
modifiés, certains éléments d'une liste peuvent être immuables. Par
exemple, si une liste contient des éléments de type chaîne de caractères, les
caractères individuels des chaînes ne peuvent pas être modifiés
directement. Pour modifier les caractères, vous devez créer une nouvelle
chaîne et l'affecter à l'élément de la liste.
names = ['Nibe', 'Dita', 'NS']
names[0] = 'Nibe'
print(names) # Sortie : ['Nibe', 'Dita', 'NS']

noms[1][0] = 'N'
# Erreur : Les chaînes de caractères sont immuables
# Erreur de type : l'objet 'str' ne prend pas en charge l'affectation d'éléments

Dans l'extrait de code ci-dessus, nous avons modifié avec succès le

premier élément de la liste "names", mais nous avons rencontré une erreur
lorsque nous avons essayé de modifier le premier caractère du deuxième
élément. Pour résoudre ce problème, vous devez créer une nouvelle chaîne
de caractères et remplacer l'ensemble de l'élément, car les chaînes de
caractères sont immuables.
Les listes sont incroyablement polyvalentes et puissantes, vous
permettant de vous attaquer à un large éventail de tâches de manipulation
de données. N'oubliez pas de vous entraîner régulièrement et d'approfondir
vos connaissances afin de maîtriser l'utilisation des listes et d'autres
structures de données en Python.
Les listes sont des structures de données fondamentales en Python qui
permettent de stocker et de manipuler des collections d'éléments. Il est
essentiel pour tout programmeur de comprendre comment créer, accéder,
modifier et effectuer des opérations sur les listes.
 Nous avons couvert les bases des listes, y compris leur création, l'accès
aux éléments, la modification, l'ajout, l'extension, le découpage, certaines
opérations courantes et quelques points supplémentaires : Les listes
imbriquées, les compréhensions de listes, l'aliasing et le clonage, la
mutabilité et l'immuabilité des listes, etc. Armé de ces connaissances, vous
pouvez exploiter en toute confiance les listes pour traiter des données
complexes dans vos programmes Python. Continuez à vous entraîner et à
explorer les vastes possibilités offertes par les listes, et vous deviendrez un
programmeur Python compétent en un rien de temps.
 3.2. TUPLES
Dans le domaine de la programmation Python, les tuples sont une structure
de données polyvalente et précieuse. Ils offrent une série de
caractéristiques qui les rendent indispensables pour diverses tâches de
programmation. Dans cet article, nous allons explorer les tuples en
profondeur, en discutant de leur définition, de leurs propriétés, de leurs
opérations et de leurs cas d'utilisation.
Que vous soyez un débutant ou un développeur Python expérimenté, ce
guide complet vous permettra de mieux comprendre les tuples et leur
importance dans les structures de données.
Ne vous précipitez pas ! Nous irons de l'avant et lentement, avec la
meilleure compréhension possible, nous compléterons le voyage du novice
au pro et deviendrons un maître de Python. Ayez un peu de patience et
pratiquez quotidiennement ! Alors, allons-y...
Qu'est-ce qu'un tuples ?
Un tuple est une collection ordonnée et immuable d'objets en Python. Il
est similaire à une liste, mais avec une distinction cruciale : les tuples ne
peuvent pas être modifiés une fois qu'ils sont créés. Cette immuabilité leur
confère certains avantages par rapport à d'autres structures de données dans
des scénarios spécifiques. Les tuples sont créés en plaçant entre
parenthèses des valeurs séparées par des virgules.
mon_tuple = (1, 2, 3, 4, 5)
 PROPRIÉTÉS DES TUPLES
1. Nature immuable :
Comme je l'ai mentionné précédemment, les tuples sont immuables, ce
qui signifie que leurs valeurs ne peuvent pas être modifiées après leur
création. Cette immutabilité garantit l'intégrité des données et empêche les
modifications accidentelles. Bien que cela puisse sembler restrictif à
première vue, cela offre des avantages tels qu'un traitement plus rapide et la
possibilité d'utiliser les tuples comme clés de dictionnaire.
2. Éléments ordonnés :
Les n-uplets conservent l'ordre des éléments, en préservant la séquence
dans laquelle ils ont été définis. Cette caractéristique nous permet d'accéder
aux éléments d'un tuple par leur index, comme nous le ferions avec des
listes.
my_tuple = (1, 2, 3)
print(my_tuple[0]) # Output : 1

3. Types de données hétérogènes :

Les tuples peuvent contenir des éléments de différents types de
données. Cette polyvalence permet aux développeurs de stocker diverses
informations dans un seul tuple. Voici un exemple de tuple contenant des
types de données mixtes :
person_details = ("Nibedita Sahu", 25, "[email protected]")
 OPÉRATIONS DE BASE SUR LES TUPLES
1. Accès aux éléments :
Comme les tuples conservent l'ordre, il est possible d'accéder à des
éléments individuels en utilisant l'indexation ou le découpage.
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[2]) # Sortie : 3
print(mon_tuple[1:4]) # Sortie : (2, 3, 4)

2. Concaténation :
Les tuples peuvent être concaténés à l'aide de l'opérateur "+", ce qui
crée un nouveau tuple contenant les éléments combinés.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple) # Output : (1, 2, 3, 4, 5,
6)

3. Multiplication :
Les tuples peuvent être multipliés par un nombre entier, ce qui donne
un nouveau tuple avec des éléments répétés.
mon_tuple = (1, 2)
multiplied_tuple = mon_tuple *
3
print(multiplied_tuple) # Sortie : (1, 2, 1, 2, 1, 2)

4. Longueur d'un tuple :

La fonction 'len()' peut être utilisée pour déterminer le nombre
d'éléments d'un tuple. Ou vous pouvez dire "pour connaître la longueur du
n-uplet".
my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple)) # Sortie : 5
CAS D'UTILISATION ET AVANTAGES DES TUPLES
1. Déballer les valeurs :
Les tuples permettent de décompresser plusieurs valeurs dans une seule
instruction d'affectation. Cette fonctionnalité est particulièrement utile
lorsqu'il s'agit de fonctions qui renvoient plusieurs valeurs.
def get_name_and_age() :
retour "Nibedita Sahu", 20
name, age = get_name_and_age()
print(name) # Output : Nibedita
Sahu print(age)# Résultat : 20
# Ou directement sur une ligne, vous pouvez imprimer le nom et l'âge comme
vous le souhaitez ! print(name, age) # Sortie : Nibedita Sahu 20

Clés de dictionnaire : Les tuples étant immuables, ils peuvent être

utilisés comme clés dans les dictionnaires. Les listes, qui sont
mutables, ne peuvent pas être utilisées comme clés. Cette propriété
permet aux tuples de servir d'identifiants fiables et efficaces dans les
structures de données basées sur des dictionnaires.

Arguments de fonction : Les tuples peuvent être utilisés pour

transmettre plusieurs valeurs en tant qu'arguments à des fonctions.
Cela est utile lorsque le nombre d'arguments est fixe et que l'ordre des
valeurs est important.

Structures de données légères : Par rapport aux listes, les tuples

consomment moins de mémoire en raison de leur immuabilité. Ils sont
donc idéaux pour les scénarios dans lesquels l'intégrité des données et
l'efficacité de la mémoire sont essentielles.
POINTS SUPPLÉMENTAIRES POUR AMÉLIORER
VOTRE COMPRÉHENSION DES TUPLES
1. Itération sur un tuple :
Les tuples peuvent être facilement itérés à l'aide de boucles, telles que
la boucle "for", pour accéder à chaque élément de manière séquentielle.
my_tuple = (1, 2, 3, 4, 5)
for item in my_tuple :
print(item, end=" ") # Output:1 2 3 4 5
# Ou si vous ne voulez pas que cela soit sur une seule ligne, vous
pouvez également le supprimer. for num in my_tuple :
print(num)
# Sortie :
1
2
3
4
5

C'est à vous de décider comment vous l'aimez et comment vous le

voulez. C'est pourquoi Python est si amusant ! 'end=' n'est pas très
compliqué, il signifie comment vous voulez terminer la fin. Ici, je voulais
que les nombres soient sur une seule ligne et séparés par un espace, donc
j'ai mis un espace. Modifiez-le selon votre humeur !
2. Emballage et déballage de n-uplets :
L'empaquetage de tuple consiste à combiner plusieurs valeurs en un seul
tuple, tandis que le dépaquetage de tuple nous permet d'affecter ces valeurs
à des variables distinctes. Cette fonctionnalité constitue un moyen pratique
de regrouper des données connexes.
personne = "Nibedita Sahu"
âge = 20
email = "[email protected]"
# Emballage de tuple
person_details = person, age, email
# Tuple unpacking
nom, âge, email = person_details
 print(name) # Résultat : Nibedita
Sahu print(age) # Résultat : 20
print(email) # Sortie : [email protected]

3. Tuples imbriqués :
Les tuples peuvent être imbriqués dans d'autres tuples, ce qui permet
de créer des structures de données complexes. Cette imbrication peut se
faire à n'importe quel niveau, ce qui permet de représenter avec
souplesse des données hiérarchiques ou multidimensionnelles.
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(nested_tuple[1]) # Sortie : (4, 5, 6)
print(nested_tuple[1][2]) # Sortie : 6

4. Comparaison de tuple :
Les tuples prennent en charge les opérations de comparaison, telles que
l'égalité (==), l'inégalité (!=), plus grand que (>), moins grand que (<), etc.
La comparaison s'effectue de gauche à droite jusqu'à ce qu'une incohérence
soit détectée ou que la fin du n-uplet soit atteinte.
tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 == tuple2) # Sortie : False
print(tuple1 < tuple2) # Sortie : True
print(tuple1 > tuple2) # Sortie : Faux

Méthodes pour les n-uplets : Les tuples disposent de quelques

méthodes intégrées qui offrent des fonctionnalités supplémentaires. Il
s'agit notamment des méthodes "count()" et "index()". La méthode
"count()" renvoie le nombre d'occurrences d'une valeur spécifique
dans le tuple, tandis que la méthode "index()" renvoie l'indice de la
première occurrence d'une valeur donnée.

my_tuple = (1, 2, 2, 3, 4, 2)
print(my_tuple.count(2)) # Sortie : 3
print(my_tuple.index(3)) # Sortie : 3

5. Conversion de type :
Les n-uplets peuvent être convertis en d'autres structures de données à
l'aide de fonctions de conversion intégrées. Par exemple, "list(my_tuple)"
convertit un tuple en liste, et "set(my_tuple)" le convertit en ensemble.
Cette flexibilité permet à
pour une interconversion transparente entre différentes structures de
données selon les exigences de votre programme.
En vous plongeant dans le monde des tuples, vous avez acquis une base
solide pour comprendre leurs propriétés, leurs opérations et leurs cas
d'utilisation. Vous possédez désormais les connaissances nécessaires pour
exploiter efficacement les tuples dans vos programmes Python, que ce soit
pour regrouper des données connexes, créer des structures de données
légères ou passer plusieurs arguments à des fonctions. Les tuples offrent
l'immuabilité, l'ordre et la compatibilité avec diverses fonctionnalités de
Python, ce qui en fait un outil inestimable pour tout développeur Python.
N'oubliez pas que la pratique est la clé de la maîtrise des tuples et des
autres structures de données. L'intégration régulière des tuples dans vos
exercices et projets de codage permettra non seulement de renforcer votre
compréhension, mais aussi d'améliorer vos compétences générales en
matière de programmation Python.
 3.3. DICTIONNAIRES
Les structures de données jouent un rôle essentiel dans la programmation
informatique, car elles nous permettent de stocker, d'organiser et d'extraire
des données de manière efficace. Parmi ces structures, les dictionnaires se
distinguent comme l'une des options les plus polyvalentes et les plus
puissantes. Dans cette section, nous allons nous pencher sur les
dictionnaires en tant que structure de données en Python, comprendre leurs
propriétés uniques, leur fonctionnement et leurs applications pratiques. Que
vous soyez un débutant ou un programmeur expérimenté, ce guide vous
aidera à comprendre les principes fondamentaux des dictionnaires et à
exploiter tout leur potentiel.
Comprendre les dictionnaires
En Python, un dictionnaire est une collection qui contient des paires
clé-valeur. Contrairement aux listes ou aux tableaux, où l'on accède aux
éléments à l'aide d'indices entiers, les dictionnaires nous permettent
d'accéder aux éléments à l'aide des clés qui leur sont associées. Imaginez
un dictionnaire comme un véritable dictionnaire de langue, où les mots
(clés) ont des significations correspondantes (valeurs).
La création d'un dictionnaire est simple en Python. Vous utilisez des
accolades "{}" et séparez chaque paire clé-valeur par deux points ':'.
# Création d'un dictionnaire des notes des élèves
student_grades = {'Nibedita' : 85, 'Tushar' : 82, 'Salil' : 88, 'Mayukh' : 91}

Dans ce cas, "Nibedita", "Tushar", "Salil" et "Mayukh" sont les clés,

tandis que 85, 82, 88 et 91 sont les valeurs correspondantes.
Accès aux valeurs dans les dictionnaires :
Les dictionnaires permettent d'extraire des valeurs en spécifiant la clé
associée entre crochets "[]".
# Accès à la note de 'Nibedita'
nibedita_grade = student_grades['Nibedita']
print(nibedita_grade) # Résultat : 85

Notez que si vous tentez d'accéder à une clé qui n'existe pas dans le
dictionnaire, Python lèvera une exception "KeyError". Pour éviter cela,
vous pouvez utiliser la méthode "get()", qui renvoie une valeur par défaut si
la clé n'est pas trouvée.
# Utilisons get() pour accéder à une clé en toute
sécurité bidisha_grade =
student_grades.get('Bidisha', 'N/A')
 print(bidisha_grade) # Sortie : 'N/A'

# Ou si vous ne voulez rien garder, vous obtiendrez

None. bidisha_grade = student_grades.get('Bidisha')
print(bidisha_grade) # Output : Aucune

Mise à jour et ajout d'entrées :

Les dictionnaires sont mutables, ce qui signifie que vous pouvez
modifier leur contenu même après leur création. Pour mettre à jour la
valeur associée à une clé, il suffit d'utiliser la clé correspondante et de lui
attribuer une nouvelle valeur.
# Mettons à jour la note de Nibedita
student_grades['Nibedita'] = 89

Pour ajouter une nouvelle entrée au dictionnaire, il faut attribuer une valeur à une
nouvelle clé :

# Ajout d'un nouvel élève et d'une

nouvelle note student_grades['Nibe'] = 94

Itération sur les dictionnaires :

Les dictionnaires proposent différentes méthodes pour parcourir leurs
éléments. Une approche courante consiste à utiliser une boucle for avec la
méthode "items()", qui renvoie un objet de vue contenant des paires clé-
valeur sous forme de tuples.
# Itération sur le dictionnaire en utilisant items()
pour étudiant, note dans student_grades.items() :
print(élève, note)

# Sortie :
Nibedita 89
Tushar 82
Salil 88
Mayukh 91
Nibe 94

Vous pouvez également parcourir les clés ou les valeurs séparément à

l'aide des méthodes "keys()" et "values()", respectivement.
Vérification de l'existence d'une clé :
 Avant d'accéder à une clé, il est souvent utile de vérifier si elle existe
dans le dictionnaire pour éviter les erreurs. Le mot-clé "in" peut être utilisé
à cette fin.
# Vérification de l'existence d'une clé
if 'Tushar' in student_grades :
print("Note de Tushar : ",
student_grades['Tushar']) # Output : Note de
Tushar : 82

Suppression d'entrées :
Pour supprimer une paire clé-valeur d'un dictionnaire, vous pouvez
utiliser le mot-clé "del" suivi de la clé :
print(student_grades)
# Sortie :
{'Nibedita' : 89, 'Tushar' : 82, 'Salil' : 88, 'Mayukh' : 91, 'Nibe' :
94} # Suppression de 'Nibe' :
del student_grades['Nibe']
print(student_grades)
# Output : {'Nibedita' : 89, 'Tushar' : 82, 'Salil' : 88, 'Mayukh' : 91}

Opérations sur les dictionnaires :

Les dictionnaires permettent plusieurs opérations au-delà de la manipulation de base
Copie d'un dictionnaire : Vous pouvez créer une copie superficielle
d'un dictionnaire en utilisant la méthode "copy()" ou le constructeur intégré
"dict()".
# Copier un dictionnaire
copied_dict = student_grades.copy()

Vérification de la longueur : La fonction 'len()' renvoie le nombre de

paires clé-valeur dans un dictionnaire.
# Vérifier la longueur d'un dictionnaire
num_students = len(student_grades)

Effacer un dictionnaire : La méthode "clear()" supprime toutes les

paires clé-valeur d'un dictionnaire, le rendant ainsi vide.
 # Effacement d'un dictionnaire
student_grades.clear()

Vérification de l'égalité : Les dictionnaires peuvent être comparés à

l'aide de l'opérateur "==", qui vérifie si les paires clé-valeur correspondent.
# Vérification de l'égalité des
dictionnaires dict1 = {'a' : 1, 'b' : 2}
dict2 = {'b' : 2, 'a' : 1}
print(dict1 == dict2) # Sortie : Vrai

Dictionnaires imbriqués :
Les dictionnaires peuvent être imbriqués dans d'autres dictionnaires, ce
qui permet de créer des structures de données complexes. Cela est utile
pour traiter des données hiérarchiques.
# Dictionnaires
imbriqués
student_details = {
Nibe" : {'age' : 20, 'major' : 'Mathematics'},
Dita : {'age' : 21, 'major' : 'Data Science'}
}
print(student_details['Nibe']['major']) # Output : 'Mathématiques'

Applications pratiques des dictionnaires : Les dictionnaires trouvent

des applications pratiques dans un large éventail de scénarios de
programmation, notamment :

Recherche de données : Les dictionnaires permettent une extraction

efficace des données à l'aide de clés. Ils conviennent donc à des
scénarios tels que la consultation de bases de données ou la mise en
cache.

Gestion de la configuration : Les dictionnaires constituent un moyen

pratique de stocker et de gérer les configurations des applications, les
clés représentant des paramètres spécifiques et les valeurs les valeurs
correspondantes.

Comptage et analyse des fréquences : Les dictionnaires permettent de

compter les occurrences des éléments d'une collection. Chaque
élément peut être stocké en tant que clé et la valeur associée peut
représenter le nombre d'occurrences.
 # Compte les occurrences des
éléments word = 'Hello'
count = {}
pour char dans word :
count[char] = count.get(char, 0) + 1
print(count) # Sortie : {'H' : 1, 'e' : 1, 'l' : 2, 'o' : 1}

1. Cartographie des relations :

Les dictionnaires permettent de cartographier les relations entre différentes entités.
Par exemple, les dictionnaires peuvent être utilisés pour établir des
liens entre les utilisateurs et leurs préférences correspondantes.
Après avoir couvert les bases des dictionnaires dans les structures de
données, les débutants peuvent approfondir leurs connaissances et leurs
compétences en explorant les concepts suivants :
Méthodes de dictionnaire : Les dictionnaires Python sont dotés d'un
certain nombre de méthodes intégrées qui offrent des fonctionnalités
supplémentaires. Voici quelques-unes des méthodes les plus couramment
utilisées :

keys() : renvoie un objet de vue contenant toutes les clés du dictionnaire.

values() : renvoie un objet de vue contenant toutes les valeurs du
dictionnaire.
items() : renvoie un objet de vue contenant toutes les paires clé-valeur
sous forme de tuples.
pop() : Supprime et renvoie la valeur associée à une clé donnée.
update() : Met à jour un dictionnaire avec des paires clé-valeur
provenant d'un autre dictionnaire ou d'une table itérative.
clear() : supprime toutes les paires clé-valeur du dictionnaire.
student_grades = {'Nibedita' : 85, 'Tushar' : 82, 'Salil' : 86, 'Mayukh' :
91} # Obtenir les clés
keys = student_grades.keys()
print(keys) # Sortie : dict_keys(['Nibedita', 'Tushar', 'Salil', 'Mayukh']) #
Obtention des valeurs
values = student_grades.values()
print(values) # Output : dict_values([85, 82, 86, 91])
 # Obtenir les paires clé-valeur
items = student_grades.items()
print(items) # Output : dict_items([('Nibedita', 85), ('Tushar', 82), ('Salil', 86), ('Mayukh', 91)])
# Suppression d'une paire clé-valeur
grade = student_grades.pop('Nibedita')
print(grade) # Output : 85
# Mise à jour du dictionnaire
student_grades.update({'Salil' : 88})
print(student_grades) # Sortie : {'Tushar' : 82, 'Salil' : 88, 'Mayukh' : 91}

2. Compréhension du dictionnaire :
Similaire à la compréhension de liste, la compréhension de
dictionnaire fournit un moyen concis de créer des dictionnaires basés
sur des objets itérables. Elle consiste à spécifier des paires clé-valeur et
une condition facultative.
nombres = [1, 2, 3, 4, 5]
carrés = {x : x ** 2 for x in numbers}
print(squares) # Sortie : {1 : 1, 2 : 4, 3 : 9, 4 : 16, 5 : 25}

1. Tri de dictionnaires :

Par défaut, les dictionnaires en Python ne sont pas ordonnés.

Cependant, si vous avez besoin de trier un dictionnaire sur la base de clés
ou de valeurs, vous pouvez utiliser la fonction "sorted()" avec la méthode
"items()".
student_grades = {'Nibedita' : 85, 'Tushar' : 82, 'Salil' : 88, 'Mayukh' :
91} # Tri par clés
notes_sorties_par_clé = dict(sorted(student_grades.items())) #
Tri par valeurs
sorted_grades_by_value = dict(sorted(student_grades.items(), key=lambda x : x[1]))
print(sorted_grades_by_key) # Output : {'Mayukh' : 91, 'Nibedita' : 85, 'Salil' : 88, 'Tushar' :
82}
print(sorted_grades_by_value) # Sortie : {'Tushar' : 82, 'Nibedita' : 85, 'Salil' : 88, 'Mayukh' : 91}

4. Traitement des clés manquantes :

Lorsque l'on accède à une clé qui n'existe pas dans un dictionnaire,
Python lève une "KeyError" par défaut. Cependant, vous pouvez utiliser la
classe "defaultdict" du module "collections" pour gérer les clés manquantes
de manière élégante.
from collections import defaultdict
student_grades = defaultdict(lambda :
'N/A')
 notes_étudiants['Tushar'] = 89
print("Note de Tushar : ", student_grades['Tushar']) # Output : Note de Tushar : 89
print("Note de Nidisha : ", student_grades['Bidisha']) # Output : Note de Bidisha : N/A

5. Vues du dictionnaire :
Les vues de dictionnaire fournissent des vues dynamiques et en temps
réel des clés, des valeurs ou des paires clé-valeur d'un dictionnaire. Elles
reflètent toutes les modifications apportées au dictionnaire.
student_grades = {'Nibedita' : 85, 'Tushar' : 82, 'Salil' : 88, 'Mayukh' : 91}
keys_view = student_grades.keys()
values_view = student_grades.values()
items_view = student_grades.items()
# Modifier le dictionnaire
student_grades['Bidisha'] = 81
print(keys_view)
# Sortie : dict_keys(['Nibedita', 'Tushar', 'Salil', 'Mayukh', 'Bidisha'])
print(values_view)
# Output : dict_values([85, 82, 88, 91, 81])
print(items_view)
# Output : dict_items([('Nibedita', 85), ('Tushar', 82), ('Salil', 88), ('Mayukh', 91), ('Bidisha', 81)])

En explorant ces concepts supplémentaires, vous pouvez améliorer

votre compréhension des dictionnaires dans les structures de données et
élargir votre capacité à exploiter efficacement les dictionnaires dans la
programmation Python. Les dictionnaires sont un outil polyvalent qui peut
gérer divers scénarios du monde réel et leur maîtrise contribuera de
manière significative à vos compétences en matière de codage.
 3.4. ENSEMBLES ET ENSEMBLES FROZENS
Lorsque l'on travaille avec des données en Python, il est essentiel de
comprendre les différentes structures de données disponibles. L'une de ces
structures de données est un ensemble, qui est une collection d'éléments
uniques. Dans cette section, nous allons explorer les ensembles dans les
structures de données et la manière dont ils peuvent être utilisés
efficacement en Python.
Introduction aux ensembles
Un ensemble est une collection non ordonnée d'éléments uniques en
Python. Contrairement aux listes ou aux tuples, les ensembles n'autorisent
pas les valeurs dupliquées. Les éléments d'un ensemble sont placés entre
accolades "{}" et séparés par des virgules.
fruits = {"pomme", "banane", "orange", "pomme"}
print(fruits) # Sortie : {"banane", "orange",
"pomme"}

Dans cet exemple, nous avons défini un ensemble appelé "fruits"

comprenant quatre éléments : "pomme", "banane", "orange" et "pomme".
Cependant, lorsque nous imprimons l'ensemble, nous remarquons que
l'élément dupliqué "pomme" n'est affiché qu'une seule fois.
En effet, les ensembles éliminent automatiquement les valeurs en double.
Vous l'avez peut-être aussi étudié en mathématiques à l'école à propos des
ensembles.
 SET OPERATIONS
Les ensembles en Python supportent diverses opérations qui peuvent être
effectuées sur eux. Explorons quelques-unes des opérations les plus
couramment utilisées :
1. Ajout d'éléments :
Nous pouvons ajouter des éléments à un ensemble à l'aide de la méthode "add()".
fruits = {"pomme", "banane", "orange"}
fruits.add("mangue")
print(fruits)
# Sortie : {'apple', 'mango', 'orange', 'banana'}

2. Suppression d'éléments :
Pour supprimer un élément d'un ensemble, nous pouvons utiliser la
méthode "remove()". Si l'élément n'est pas trouvé dans l'ensemble, une
"KeyError" est levée. Il est également possible d'utiliser la méthode
"discard()", qui ne soulève pas d'erreur si l'élément n'est pas présent.
fruits = {"pomme", "banane", "orange"}
fruits.remove("banane")
print(fruits) # Sortie : {'apple', 'orange'}
fruits = {"apple", "banana", "orange"}
fruits.remove("cherry")
print(fruits) # Sortie : KeyError : 'cherry'
fruits = {"apple", "banana", "orange"}
fruits.discard("cherry")
print(fruits) # Sortie : {'orange', 'pomme', 'banane'}

3. Opérations mathématiques :
Les ensembles prennent en charge diverses opérations mathématiques
telles que l'union, l'intersection et la différence. Ces opérations peuvent être
effectuées à l'aide de méthodes ou d'opérateurs intégrés.
#Union :
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) # Sortie : {1, 2, 3, 4, 5}
Intersection :
 set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set) # Sortie : {3}
Différence :
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set) # Sortie : {1, 2}

4. Test d' adhésion :

Nous pouvons vérifier si un élément existe dans un ensemble en utilisant le mot-clé
"in".
fruits = {"pomme", "banane", "orange"}
print("pomme" in fruits) # Sortie : True
print("mango" in fruits) # Output : False

Les ensembles sont particulièrement utiles lorsqu'il s'agit de traiter de

grands ensembles de données et de vérifier rapidement l'existence
d'éléments.
 APPLICATIONS DES ENSEMBLES
Les ensembles trouvent des applications dans divers scénarios, tels que :
1. Suppression des doublons :
Les ensembles peuvent être utilisés pour supprimer les éléments en
double d'une liste ou de toute autre collection. Nous pouvons convertir la
collection en ensemble, puis en liste, ce qui élimine automatiquement les
doublons.
nombres = [1, 2, 3, 2, 4, 5, 1]
nombres_uniques = list(set(nombres))
print(unique_numbers) # Sortie : [1, 2, 3, 4, 5]

2. Opérations mathématiques :
Les ensembles peuvent être utilisés pour effectuer des opérations
mathématiques, telles que la recherche des éléments communs entre deux
ensembles, la recherche des éléments distincts, etc. Ces opérations sont très
efficaces avec les ensembles.
3. Test d' adhésion :
Les ensembles permettent de vérifier rapidement si un élément est
présent dans une collection. C'est utile lorsque l'on travaille avec de
grands ensembles de données et que l'on a besoin de rechercher
rapidement des valeurs spécifiques.

Quelques points supplémentaires qu'un débutant devrait apprendre sur

les ensembles dans les structures de données après avoir compris les
bases que nous avons discutées ci-dessus...
1. L'appartenance à un ensemble et l'itération :
Les ensembles permettent d'effectuer des tests d'appartenance efficaces
à l'aide du mot-clé "in", comme nous l'avons vu précédemment. En outre,
les ensembles peuvent être itérés à l'aide de boucles, tout comme les autres
objets itérables de Python. Cela vous permet d'effectuer facilement des
opérations sur chaque élément de l'ensemble.
fruits = {"pomme", "banane",
"orange"} pour fruit dans fruits :
print(fruit)
# Sortie :
orange
 banane
pomme

2. Éléments immuables :
En Python, les ensembles ne peuvent contenir que des éléments
immuables, tels que des nombres, des chaînes de caractères et des tuples.
Les objets mutables tels que les listes et les dictionnaires ne peuvent pas
être des éléments d'un ensemble. En effet, les ensembles utilisent le
hachage pour déterminer rapidement l'unicité et les objets mutables
peuvent modifier leur valeur de hachage, ce qui entraîne un comportement
inattendu.

3. Jeux gelés :
Bien que les ensembles soient mutables, Python fournit également une
variante immuable intégrée appelée "frozen sets". Les ensembles gelés
peuvent être créés à l'aide de la fonction "frozenset()" et possèdent les
mêmes propriétés que les ensembles, à l'exception du fait qu'ils ne peuvent
pas être modifiés une fois créés. Les ensembles gelés sont utiles dans les
situations où vous avez besoin d'une collection immuable d'éléments
uniques.
nombres = frozenset([1, 2, 3, 4])
print(numbers) # Sortie : frozenset({1, 2, 3, 4})

4. Compréhension de l' ensemble :

Comme pour les compréhensions de listes, Python prend également en
charge les compréhensions d'ensembles, qui permettent de créer des
ensembles à l'aide d'une syntaxe concise. Les compréhensions d'ensembles
sont entourées d'accolades et suivent un modèle similaire à celui des
compréhensions de listes.
carrés = {x**2 for x in range(1, 6)}
print(carrés) # Sortie : {1, 4, 9, 16, 25}
5. Caractéristiques de performance :
 Les ensembles en Python sont implémentés sous forme de tables de
hachage, ce qui permet d'obtenir des performances moyennes rapides pour
les opérations courantes telles que les tests d'appartenance, l'ajout
d'éléments et la suppression d'éléments. Cependant, les performances
peuvent se dégrader dans le pire des cas lorsqu'il y a de nombreuses
collisions de hachage. Il est important d'être conscient des caractéristiques
de performance sous-jacentes lorsque l'on travaille avec des ensembles et
de prendre en compte le cas d'utilisation spécifique.
6. Opérations et méthodes ensemblistes :
Les ensembles en Python offrent un large éventail d'opérations et de
méthodes qui vous permettent de manipuler et d'analyser les ensembles de
manière efficace. Parmi les méthodes les plus couramment utilisées, citons
"update()", "clear()", "copy()", "issubset()", "issuperset()" et
"symmetric_difference()". Il est utile d'explorer l'ensemble des méthodes
disponibles et de comprendre leur fonctionnalité afin de maximiser l'utilité
des ensembles dans vos programmes.
Les ensembles sont une structure de données précieuse en Python
lorsque l'on travaille avec des éléments uniques. Ils fournissent des
opérations efficaces pour ajouter, supprimer et effectuer des opérations
mathématiques sur les éléments.
Grâce à leur capacité à éliminer les doublons et à tester rapidement
l'appartenance à un groupe, les ensembles sont très utiles dans divers
scénarios. En comprenant les ensembles et leurs opérations, vous pouvez
écrire un code Python plus efficace et plus propre.
En maîtrisant les points supplémentaires, les débutants et même les
professionnels qualifiés auront une solide compréhension des ensembles
dans les structures de données et seront équipés pour les utiliser
efficacement en Python.
N'oubliez pas d'utiliser les ensembles chaque fois que vous devez traiter
des collections d'éléments uniques et tirez parti de leurs puissantes
fonctionnalités pour simplifier vos tâches de programmation.
 3.5. TABLEAUX ( NUMPY)
Les structures de données jouent un rôle essentiel dans l'informatique et la
programmation, car elles nous permettent d'organiser et de manipuler
efficacement les données. L'une de ces structures de données est le tableau.
Les tableaux sont fondamentaux dans de nombreux langages de
programmation, y compris Python, et ils constituent un moyen pratique et
efficace de stocker et de manipuler de grandes quantités de données.
En Python, la bibliothèque NumPy (Numerical Python) est largement
utilisée pour travailler avec des tableaux. NumPy fournit une
implémentation puissante et efficace des tableaux multidimensionnels,
ainsi qu'une collection de fonctions pour les opérations mathématiques sur
les tableaux. Dans cet article, nous allons explorer les tableaux dans le
contexte de NumPy, en discutant de leurs caractéristiques, de leurs
avantages et de la manière de les utiliser efficacement.
Qu'est-ce qu'un tableau ?
Un tableau est une collection d'éléments de même type, organisés dans
un bloc de mémoire contigu. Chaque élément du tableau est accessible par
son index, qui représente sa position dans le tableau. Les tableaux offrent
un accès aléatoire efficace aux éléments, ce qui permet d'accéder en temps
constant à n'importe quel élément.
En Python, les tableaux peuvent être créés à l'aide de la bibliothèque
NumPy. Les tableaux NumPy sont homogènes, ce qui signifie qu'ils ne
peuvent stocker que des éléments du même type de données. Cela garantit
une utilisation efficace de la mémoire et permet d'effectuer des opérations
vectorielles, ce qui améliore considérablement les performances des calculs
numériques.
Création de tableaux
Pour travailler avec des tableaux dans NumPy, nous devons d'abord
importer la bibliothèque NumPy. Nous pouvons ensuite créer des tableaux
à l'aide de la fonction "numpy.array()" en passant une liste ou un tuple
Python en argument.
import numpy as np #
Création d'un tableau
1D
arr_1d = np.array([1, 2, 3, 4, 5])
print(arr_1d) # Sortie : [1 2 3 4 5]
# Création d'un tableau 2D
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d)
 # Sortie :
[[1 2 3]
[4 5 6]]

Dans l'exemple ci-dessus, nous avons créé un tableau 1D "arr_1d" et

un tableau 2D "arr_2d" à l'aide de la fonction "numpy.array()". Nous
passons une liste d'éléments à la fonction, qui crée le tableau
correspondant.
Attributs du tableau
Les tableaux dans NumPy ont plusieurs attributs importants qui
fournissent des informations utiles sur le tableau. Les attributs les plus
couramment utilisés sont les suivants :

'ndim' : renvoie le nombre de dimensions du tableau.

'shape' : renvoie un tuple représentant la taille de chaque dimension du
tableau.
'size' : renvoie le nombre total d'éléments du tableau.
'dtype' : renvoie le type de données des éléments du tableau.
'itemsize' : renvoie la taille (en octets) de chaque élément du tableau.
'nbytes' : renvoie la taille totale (en octets) du tableau.
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Forme :", arr.shape)
print("Nombre de dimensions :",
arr.ndim) print("Taille :", arr.size)
print("Type de données :", arr.dtype)
print("Taille de chaque élément (en octets) :", arr.itemsize)
print("Taille totale du tableau (en octets) :", arr.nbytes)

# Sortie :
Forme : (2, 3)
Nombre de dimensions : 2
Taille : 6
Type de données : int32
Taille de chaque élément (en octets)
: 4 Taille totale du tableau (en octets)
: 24
 Dans l'exemple ci-dessus, nous créons un tableau 2D "arr", puis nous
imprimons ses attributs. Nous pouvons voir que la forme du tableau est '(2,
3)', ce qui indique qu'il comporte 2 lignes et 3 colonnes. Le tableau a 2
dimensions, un total de 6 éléments, et chaque élément est de type 'int64'. La
taille de chaque élément est de 8 octets et la taille totale du tableau est de
48 octets.
Indexation et découpage des tableaux
Accéder aux éléments d'un tableau et les manipuler est une
opération courante lorsqu'on travaille avec des tableaux. Dans
NumPy, nous pouvons utiliser des techniques d'indexation et de
découpage pour récupérer des éléments spécifiques ou des sous-
ensembles d'un tableau.
L'indexation dans NumPy commence à partir de 0, comme dans les
autres langages de programmation. Nous pouvons accéder aux éléments
d'un tableau 1D en utilisant leur index, et aux éléments d'un tableau 2D en
utilisant les index des lignes et des colonnes.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print("Premier élément :",
arr[0]) print("Dernier élément
:", arr[-1]) # Sortie :
Premier élément : 1
Dernier élément : 5

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

print("Élément à (0, 1) :", arr[0, 1])
print("First row :", arr[0, :])
# Output :
Élément à (0, 1) : 2
Premier rang : [1 2 3]

Dans l'exemple ci-dessus, nous créons un tableau 1D "arr" et nous

imprimons le premier et le dernier élément en utilisant l'indexation. Nous
créons également un tableau 2D "arr" et accédons à des éléments
spécifiques à l'aide d'indices de ligne et de colonne.
Le découpage en tranches permet d'extraire des sous-réseaux d'un
tableau plus grand en spécifiant les indices de début et de fin ainsi qu'une
taille de pas facultative. Le découpage fonctionne
de la même manière pour les réseaux 1D et 2D.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print("Tranche de l'index 1 à 3 :",
arr[1:4]) print("Chaque élément alternatif
:", arr[::2]) # Sortie :
Trancher de l'index 1 à 3 : [2 3 4]
Chaque élément alternatif : [1 3 5]

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

print(arr[1:3, 0:2])
# Sortie :
[[4 5]
[7 8]]

Dans l'exemple ci-dessus, nous créons un tableau 1D "arr" et effectuons

des opérations de découpage pour extraire des éléments ou des sous-
réseaux spécifiques. Nous créons également un tableau 2D "arr" et le
découpons pour obtenir un sous-réseau composé des lignes 1 à 2 et des
colonnes 0 à 1.
Opérations sur les tableaux
NumPy fournit une large gamme de fonctions et d'opérateurs
mathématiques qui peuvent être appliqués aux tableaux. Ces fonctions et
opérateurs sont conçus pour fonctionner efficacement sur les tableaux,
grâce à l'implémentation sous-jacente de NumPy.

Opérations par éléments

Les opérations par élément appliquent une opération spécifique à
chaque élément d'un tableau. Cela peut être fait en utilisant les opérateurs
arithmétiques fournis par NumPy, tels que '+', '-', '*', '/', et d'autres. Ces
opérateurs effectuent l'opération correspondante sur chaque élément du
tableau, ce qui donne un nouveau tableau de la même forme.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
result = arr * 2
 print("Result :", result) # Output : Résultat : [ 2 4 6 8 10]

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])
result = arr1 + arr2
print("Result :", result) # Output : Résultat : [5 7 9]

Dans l'exemple ci-dessus, nous créons un tableau 1D "arr" et le

multiplions par 2 à l'aide de l'opérateur "*". Nous créons également deux
tableaux 1D, "arr1" et "arr2", et effectuons une addition par élément à l'aide
de l'opérateur "+".
Fonctions des tableaux
NumPy fournit un ensemble riche de fonctions mathématiques qui
peuvent être appliquées aux tableaux. Ces fonctions opèrent sur l'ensemble
du tableau ou le long d'un axe spécifié, ce qui permet de calculer
efficacement diverses statistiques et opérations mathématiques.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print("Somme des éléments :",
np.sum(arr))
print("Moyenne des éléments :",
np.mean(arr)) print("Elément maximum
:", np.max(arr)) print("Elément minimum
:", np.min(arr)) # Sortie :
Somme des éléments :
15 Moyenne des
éléments : 3,0 Élément
maximal : 5
Élément minimum : 1

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

print("Somme sur les lignes :", np.sum(arr,
axis=0)) print("Somme sur les colonnes :",
np.sum(arr, axis=1)) # Sortie :
Somme le long des lignes : [5 7 9]
Somme le long des colonnes : [ 6 15]

Dans l'exemple ci-dessus, nous calculons diverses statistiques pour un

tableau 1D "arr", telles que la somme, la moyenne, le maximum et le
minimum. Nous calculons également la somme
le long des lignes et des colonnes d'un tableau 2D "arr" en utilisant le paramètre "axis".
Avantages des tableaux (NumPy)
L'utilisation des tableaux de la bibliothèque NumPy offre plusieurs
avantages par rapport aux listes classiques de Python. Les principaux
avantages sont les suivants :

Efficacité : Les tableaux NumPy sont implémentés en C, ce qui leur

confère des performances supérieures à celles des listes purement
Python. Ceci est particulièrement important lorsque l'on travaille avec
de grands ensembles de données ou que l'on effectue des calculs
numériques intensifs.

Facilité d'utilisation : NumPy fournit une large gamme de fonctions et

d'opérateurs spécialement conçus pour les opérations sur les tableaux.
Cela simplifie le code et le rend plus lisible et concis.

Efficacité de la mémoire : Les tableaux NumPy sont homogènes, ce

qui signifie qu'ils nécessitent moins de mémoire que les listes Python.
Ceci est particulièrement important lorsqu'il s'agit de grands
ensembles de données, car cela permet un stockage et une
manipulation efficaces des données.

Opérations vectorisées : NumPy permet d'effectuer des opérations

vectorisées, qui appliquent une opération à un tableau entier au lieu de
passer en boucle sur des éléments individuels. Cela permet d'améliorer
considérablement l'efficacité des calculs et de réduire la complexité du
code.

Les tableaux (NumPy) sont une structure de données fondamentale en

Python pour stocker et manipuler efficacement de grandes quantités de
données. La bibliothèque NumPy fournit une implémentation puissante des
tableaux ainsi qu'une collection de fonctions pour les opérations
mathématiques. Il est essentiel de comprendre comment créer, indexer,
découper et effectuer des opérations sur les tableaux pour pouvoir travailler
efficacement avec des données en Python. En exploitant les avantages des
tableaux NumPy, les développeurs peuvent écrire un code efficace et
concis pour les calculs numériques et les tâches d'analyse de données.
3.6. SÉRIES ET CADRES DE DONNÉES ( PANDAS)
Lorsque l'on travaille avec des données en Python, l'une des bibliothèques
les plus populaires pour manipuler et analyser les données est Pandas.
Pandas propose deux structures de données principales : Series et
DataFrames. Ces structures de données sont essentielles pour manipuler et
traiter efficacement les données structurées.
Dans cette section, nous allons explorer en détail les Series et les
DataFrames, comprendre leurs caractéristiques et la manière dont ils
peuvent être utilisés efficacement dans les tâches de manipulation de
données.
Série
Une série est un tableau unidimensionnel étiqueté qui peut contenir
n'importe quel type de données. Elle est similaire à une colonne dans une
feuille de calcul ou une table SQL. Chaque élément d'une série possède
une étiquette unique appelée index. L'index permet d'accéder aux données
et de les manipuler efficacement.
Pour créer une série, nous pouvons utiliser la fonction 'pd.Series()' de Pandas.
import pandas as pd
# Créer une série de scores des frères et
sœurs scores = pd.Series([90, 85, 92, 99,
81])

Dans l'extrait de code ci-dessus, nous avons importé la bibliothèque

Pandas et créé une série appelée "scores" comportant cinq éléments. Par
défaut, les étiquettes d'index sont des entiers commençant par 0. Nous
pouvons accéder aux éléments d'une série à l'aide de ces étiquettes d'index.
# Accès aux éléments d'une série
print(scores[0]) # Sortie : 90
print(scores[2]) # Sortie : 92

Nous pouvons également attribuer des étiquettes d'index personnalisées aux éléments
de la série.
# Créer une série avec des étiquettes d'index
personnalisées scores = pd.Series([90, 85,
92, 99, 81],
index=['Nibedita', 'Tushar', 'Salil', 'Mayukh', 'Bidisha'])
# Accès aux éléments à l'aide d'étiquettes d'index
personnalisées print(scores['Tushar']) #
Résultat : 85 print(scores['Salil']) # Sortie : 92
print(scores['Mayukh'])# Sortie : 99
 Cadres de données
Un DataFrame est une structure de données bidimensionnelle étiquetée,
similaire à un tableau dans une base de données relationnelle ou un tableur.
Il se compose de lignes et de colonnes, chaque colonne pouvant contenir
différents types de données. Les DataFrames sont très efficaces pour la
manipulation et l'analyse de données structurées.
Pour créer un DataFrame, nous pouvons utiliser la fonction
'pd.DataFrame()' de Pandas.
import pandas as pd
# Créer un DataFrame des informations sur les frères et sœurs
data = {'Name' : ['Nibedita', 'Tushar', 'Salil', 'Mayukh',
'Bidisha'], 'Age' : [20, 18, 23, 26, 20],
Hobby' : ['Problem Solving', 'Gaming', 'Gaining New Insights', 'Programming', 'Sleeping']}
df = pd.DataFrame(data)

Dans l'extrait de code ci-dessus, nous avons importé la bibliothèque

Pandas et créé un DataFrame appelé "df" à l'aide d'un dictionnaire "data".
Les clés du dictionnaire représentent les noms des colonnes et les valeurs
représentent les valeurs des colonnes correspondantes. Par défaut, les
étiquettes d'index sont des entiers commençant par 0. Nous pouvons
accéder aux colonnes d'un DataFrame en utilisant leurs noms.
# Accès aux colonnes d'un DataFrame
print(df['Nom']) # Résultat : ['Nibedita', 'Tushar', 'Salil', 'Mayukh',
'Bidisha'] print(df['Age']) # Output : [20, 18, 23, 26, 20]
print(df['Hobby']) # Sortie : ['Résolution de problèmes', 'Jeux', 'Acquérir de
nouvelles connaissances', 'Programmation', 'Dormir'].

Ou si vous souhaitez qu'ils soient présentés sous forme de tableau,

vous pouvez également les imprimer directement.
print(df)
# Sortie :
Nom Age Hobby
0 Nibedita 20 Résolution de problèmes
1 Tushar 18 Gaming
2 Salil 23 : de nouvelles perspectives
3 Mayukh 26 Programmation
4 Bidisha 20 Dormir

Nous pouvons également accéder à des lignes spécifiques d'un

DataFrame en utilisant les attributs 'iloc' ou 'loc'.
 # Accéder aux lignes d'un DataFrame en utilisant
iloc print(df.iloc[0])
# Sortie :
Nom Nibedita
Age 20
Hobby Problem Solving
Nom : 0, dtype : objet

# Accès aux lignes d'un DataFrame à l'aide de

loc print(df.loc[4])
# Sortie :
Nom Bidisha
Age 20
Nom du dormeur
Hobby : 4, dtype :
objet
 MANIPULATION DE DONNÉES AVEC DES SÉRIES ET
DES CADRES DE DONNÉES
Pandas propose un large éventail de fonctions et de méthodes pour
manipuler et transformer les données dans les Series et les DataFrames.
Explorons quelques opérations couramment utilisées.
1. Filtrage des données :
Nous pouvons filtrer les données dans les séries et les DataFrames en
fonction de conditions spécifiques. Par exemple, pour filtrer les "frères et
sœurs" dont l'âge est supérieur à 18 ans dans notre DataFrame "df" :
# Filtrage des données dans un
DataFrame filtered_data = df[df['Age'] >
18]

2. Ajout et suppression de colonnes :

Nous pouvons ajouter de nouvelles colonnes ou supprimer des colonnes existantes
dans un DataFrame.
Par exemple, pour ajouter une nouvelle colonne appelée "menu_chicken" à
notre DataFrame "df" :
# Ajout d'une nouvelle colonne à un DataFrame
df['menu_chicken'] = ['Chicken Pakoda', 'Chicken Roll',
'Chicken Fry', 'Chicken Biryani', 'Butter Chicken']

Pour supprimer une colonne, nous pouvons utiliser la méthode "drop()" :

# Suppression d'une colonne d'un

DataFrame df = df.drop('menu_chicken',
axis=1)

3. Agrégation des données :

Pandas fournit des fonctions permettant d'effectuer diverses opérations
d'agrégation sur les séries et les DataFrames. Par exemple, pour calculer
l'âge moyen des frères et sœurs dans notre DataFrame 'df' :
# Agrégation des données dans un
DataFrame mean_age = df['Age'].mean()

Après avoir maîtrisé les concepts de Series et de DataFrames dans

Pandas, les programmeurs Python doivent être conscients de quelques
points supplémentaires
pour améliorer leurs compétences en matière de manipulation de données.
Explorons ces concepts à l'aide d'extraits de code pertinents.
4. Traitement des données manquantes :
Les ensembles de données du monde réel comportent souvent des
valeurs manquantes. Pandas fournit des fonctions permettant de gérer
efficacement les données manquantes. Par exemple, pour vérifier les
valeurs manquantes dans un DataFrame.
# Vérification des valeurs manquantes
print(df.isnull())
Pour supprimer les lignes ou les colonnes contenant
des valeurs manquantes : # Abandonner les lignes
avec des valeurs manquantes
df = df.dropna()
# Suppression des colonnes avec des
valeurs manquantes df =
df.dropna(axis=1)

Remplir les valeurs manquantes par une valeur spécifique :

# Remplir les valeurs manquantes avec une

valeur spécifique df = df.fillna(0)

5. Tri des données :

Pandas permet de trier les données en fonction des valeurs des colonnes.
Par exemple, pour trier un DataFrame par la colonne 'Age' dans l'ordre
croissant :
# Trier un DataFrame par colonne
df = df.sort_values('Age')

* Pour trier un DataFrame sur plusieurs colonnes :

# Trier un DataFrame sur plusieurs
colonnes df = df.sort_values(['Hobby',
'Age'])

6. Regroupement et agrégation des données :

Le regroupement de données sur la base de colonnes spécifiques et
l'exécution d'opérations d'agrégation sont des tâches courantes dans
l'analyse des données. Pandas fournit la fonction "groupby()" à cette fin.
Par exemple, pour calculer l'âge moyen pour chaque "hobby" dans notre
DataFrame "df" :
 # Regroupement et agrégation de données
âge moyen par hobby = df.groupby('Hobby')['Age'].mean()

7. Fusionner des cadres de données :

Dans le monde réel, il est souvent nécessaire de combiner plusieurs
DataFrames sur la base de colonnes communes. Pandas fournit la fonction
"merge()" pour fusionner les DataFrames. Par exemple, si nous avons deux
DataFrames, 'df1' et 'df2', avec une colonne commune 'ID', nous pouvons
les fusionner.
# Fusionner les cadres de données
merged_df = pd.merge(df1, df2, on='ID')

8. Application de fonctions aux données :

Pandas permet d'appliquer des fonctions personnalisées aux séries et
aux DataFrames. Par exemple, pour appliquer une fonction à une colonne
d'un DataFrame et créer une nouvelle colonne basée sur le résultat :
# Application d'une fonction à une colonne
df['New_Column'] = df['Age'].apply(lambda x : x + 1)

9. Visualisation des données :

Pandas s'intègre bien avec des bibliothèques de visualisation de
données populaires telles que Matplotlib et Seaborn, ce qui nous permet de
créer des graphiques et des diagrammes intéressants.
Par exemple, pour créer un histogramme de la colonne "Age" de notre
DataFrame "df" :
 import matplotlib.pyplot as plt
# Création d'un histogramme
plt.hist(df['Age'])
plt.xlabel('Age')
plt.ylabel('Frequency')
plt.title('Age Distribution')
plt.show()

Sortie :

En maîtrisant ces concepts supplémentaires, les programmeurs Python

peuvent améliorer leurs compétences en matière de manipulation de données
à l'aide de Pandas et analyser et visualiser efficacement les données dans
divers scénarios du monde réel.
N'oubliez pas que la pratique est la clé de la maîtrise de ces concepts.
L'exploration de la documentation Pandas et la réalisation de projets
pratiques vous permettront d'améliorer votre compréhension et votre
maîtrise de la manipulation de données à l'aide de Series et de
DataFrames.
4. Traitement des fichiers :
 4.1. LECTURE ET ÉCRITURE DE FICHIERS

4.2. Formats de fichiers CSV et JSON

 4.1. LECTURE ET ÉCRITURE DE FICHIERS
La gestion des fichiers est un aspect fondamental de la programmation, qui
permet aux développeurs d'interagir avec les données stockées dans des
fichiers sur le système de fichiers d'un ordinateur. En Python, la gestion des
fichiers est remarquablement simple et offre une pléthore d'outils pour lire
et écrire des données efficacement.
Dans cette section, vous explorerez en profondeur la gestion des
fichiers en Python. Nous nous concentrerons sur la lecture et l'écriture de
fichiers et nous proposerons des extraits de code pratiques pour illustrer les
concepts clés.
Comprendre les modes de fichiers
Avant d'aborder la lecture et l'écriture de fichiers, il est essentiel de
comprendre les modes de fichiers. En Python, les modes de fichiers sont
représentés par des chaînes de caractères qui déterminent comment un
fichier doit être ouvert et quelles opérations sont autorisées. Voici les
modes de fichiers les plus couramment utilisés :

'r' : Mode lecture (par défaut). Il permet de lire les données d'un
fichier existant. 'w' : Mode écriture. Il permet de créer un nouveau
fichier ou d'écraser le fichier existant.
Soyez prudent car cela effacera le contenu du fichier.
'a' : Mode annexe. Il crée un nouveau fichier s'il n'existe pas ou ajoute
des données à un fichier existant.
'x' : Mode de création exclusif. Il crée un nouveau fichier, mais si le
fichier existe déjà, l'opération échoue.
'b' : Mode binaire. Il est utilisé avec d'autres modes comme 'rb' ou
'wb' pour traiter des données binaires (images, audio, etc.).
't' : Mode texte (par défaut). Il est utilisé avec d'autres modes comme 'rt'
ou 'wt' pour traiter les données textuelles.

Plongeons dans la lecture et l'écriture de fichiers avec Python !

Fiches de lecture :
Pour lire des fichiers en Python, nous utilisons la fonction intégrée
"open()", qui prend le nom du fichier et le mode comme arguments. La
fonction "open()" renvoie un objet fichier qui nous permet d'interagir avec
le contenu du fichier. Il est essentiel de fermer le fichier à l'aide de la
méthode "close()" lorsque vous avez terminé la lecture afin de libérer les
ressources du système.
# Ouvrir le fichier en mode lecture
file_name = "sample.txt"
with open(file_name, 'r') as file :
content = file.read()
print(content)
 """
Il lira tout le contenu du fichier et le fichier sera
automatiquement fermé après avoir quitté le bloc "with".
"""

Dans cet exemple, nous ouvrons le fichier "sample.txt" en mode lecture

("r") à l'aide de la fonction "open()". L'instruction "with" garantit que le
fichier est automatiquement fermé lorsque le bloc est quitté.
Lire ligne par ligne :
Parfois, il n'est pas possible de lire l'intégralité du contenu d'un fichier
en mémoire pour les fichiers volumineux. Nous pouvons alors lire le fichier
ligne par ligne à l'aide de la méthode "readline()" ou utiliser une boucle
pour parcourir l'objet fichier.
# Ouvrir le fichier en mode lecture
file_name = "sample.txt"
with open(file_name, 'r') as file
: for line in file :
print(line.strip())

"""
Il lira et imprimera le contenu ligne par ligne et nous pourrons
utiliser strip() pour supprimer les caractères de retour à la ligne
supplémentaires.
"""

Dossiers d'écriture :
L'écriture de fichiers en Python est également réalisée avec la fonction
'open()', mais cette fois nous utilisons le mode écriture ('w') ou le mode
annexe ('a'). Il convient d'être prudent lors de l'utilisation du mode écriture,
car il efface le contenu existant du fichier. Pour éviter toute perte
accidentelle de données, nous envisageons d'utiliser le mode append.
# Ouvrir le fichier en mode
écriture file_name = "output.txt"
with open(nom_du_fichier, 'w') as file :
file.write("Hello, this is a sample text.\N")
file.write("Writing data to a file is easy!\N")
# Il écrira des données dans le fichier.
 Dans ce code, nous ouvrons le fichier "output.txt" en mode écriture
("w") et utilisons la méthode "write()" pour ajouter des données au fichier.
Notez l'utilisation du caractère de retour à la ligne ("\n") pour commencer
une nouvelle ligne après chaque écriture.
Ajout aux fichiers :
Pour ajouter des données à un fichier existant, utilisez le mode append
('a') au lieu du mode write ('w'). Cela garantit que le contenu existant est
préservé et que les nouvelles données sont ajoutées à la fin du fichier.
# Ouvrir le fichier en mode annexe
file_name = "output.txt"
avec open(nom_du_fichier, 'a') comme fichier :
file.write("Ces données sont ajoutées au
fichier.\n") # Cela ajoutera des données au
fichier.

Gestion des exceptions :

Lorsque l'on travaille avec des fichiers, il y a toujours un risque
d'erreur, par exemple si le fichier n'existe pas, s'il n'a pas les permissions
appropriées ou s'il n'y a plus d'espace disque. Pour gérer ces situations avec
élégance, nous pouvons utiliser la gestion des exceptions avec le bloc "try-
except".
nom_du_fichier =
"fichier_non_existant.txt" try :
avec open(nom_du_fichier, 'r') comme fichier :
content = file.read()
print(content)
except FileNotFoundError :
print(f "Le fichier '{nom_du_fichier}' n'existe
pas.") except PermissionError :
print(f "Vous n'avez pas la permission de lire
'{nom_du_fichier}'.") except Exception as e :
print(f "Une erreur s'est produite : {str(e)}")

Travailler avec des fichiers binaires :

Les fichiers binaires, tels que les images, les fichiers audio ou les
données binaires, nécessitent une approche différente de celle des fichiers
texte ordinaires. Pour la gestion des fichiers binaires, nous utilisons le
mode binaire ("b") en conjonction avec le mode lecture ("rb") ou écriture
("wb").
# Lecture d'un fichier binaire (image) et écriture dans un autre fichier
 fichier_entrée = "image_entrée.png"
fichier_sortie = "image_sortie.png"
with open(fichier_entrée, 'rb') as
file_in :
with open(output_file, 'wb') as file_out :
content = file_in.read()
file_out.write(content)

Dans cet exemple, nous lisons le contenu du fichier binaire

"input_image.png" en mode binaire de lecture ("rb") et écrivons le même
contenu dans "output_image.png" en mode binaire d'écriture ("wb").
Points supplémentaires sur la lecture et l'écriture de fichiers en Python :
1. Lecture et écriture de fichiers texte avec codage :
Lorsque vous traitez des fichiers texte qui n'ont pas l'encodage par
défaut (UTF- 8), vous pouvez spécifier l'encodage de manière explicite en
utilisant le paramètre 'encoding'.
nom_du_fichier = "non_utf8_file.txt"
with open(file_name, 'r', encoding='latin-1') as file :
content = file.read()

2. Lire des lignes dans une liste :

Vous pouvez lire toutes les lignes d'un fichier dans une liste à l'aide de
la méthode "readlines()". Cette méthode est utile lorsque vous devez traiter
chaque ligne séparément.
nom_du_fichier = "data.txt"
avec open(nom_du_fichier, 'r') comme fichier :
lignes = file.readlines()

3. Écriture d'une liste dans un fichier :

Si vous avez des données dans une liste et que vous souhaitez écrire
chaque élément sur une ligne distincte dans un fichier, vous pouvez utiliser
la méthode "writelines()".
data = ["Line 1", "Line 2", "Line 3"]
with open("output.txt", 'w') as file :
file.writelines(data)

4. Utilisation de 'seek()' et 'tell()' pour la manipulation des pointeurs de fichiers :

La méthode "seek()" vous permet de déplacer le pointeur de fichier à un
endroit spécifique du fichier, et la méthode "tell()" renvoie la position
actuelle du fichier.
pointeur.
avec open("data.txt", 'r') comme fichier :
print(file.tell()) # Imprimer la position actuelle du
pointeur de fichier file.seek(5) # Déplacer le
pointeur de fichier au 6ème octet content =
file.read()

5. Contextlib pour la gestion des fichiers :

Vous pouvez utiliser le module "contextlib" pour créer des
gestionnaires de contexte personnalisés pour la gestion des fichiers, offrant
ainsi un meilleur contrôle sur les opérations relatives aux fichiers.
from contextlib import contextmanager
@contextmanager
def file_opener(nom_du_fichier, mode) :
file = open(nom_du_fichier,
mode) yield file
file.close()
#
Utilisation
avec file_opener("data.txt", "r") as file :
content = file.read()

6. Traiter efficacement les fichiers volumineux :

Pour les fichiers volumineux, il n'est pas toujours pratique de lire
l'intégralité du contenu en mémoire. Au lieu de cela, vous pouvez traiter le
fichier par petits morceaux à l'aide d'une boucle.
avec open("large_file.txt", "r") comme fichier :
chunk_size = 1024 # Traite 1KB à la fois while
True :
chunk = file.read(chunk_size)
if not chunk :
pause
# Traiter le chunk

N'oubliez pas de toujours fermer les fichiers après les avoir manipulés
afin d'éviter les problèmes potentiels liés au verrouillage des fichiers et à la
gestion des ressources. L'instruction "with" garantit la fermeture correcte
des fichiers, mais si vous optez pour l'approche traditionnelle, veillez à
appeler explicitement la méthode "close()".
 Comprendre le traitement des fichiers en Python est une compétence
précieuse pour tout programmeur. Que vous travailliez avec de petits
fichiers texte ou de grands ensembles de données, les capacités de
manipulation de fichiers de Python offrent un éventail d'outils permettant de
gérer efficacement divers scénarios. En maîtrisant ces techniques, vous
pouvez lire et écrire efficacement des données dans des fichiers, ce qui rend
vos applications plus polyvalentes et plus robustes.
 4.2. FORMATS DE FICHIERS CSV ET JSON
La gestion des fichiers est un aspect fondamental de la programmation qui
nous permet de lire et d'écrire des données dans des fichiers. Elle joue un
rôle crucial dans le traitement de divers types de données, et deux formats
de fichier populaires pour le stockage de données structurées sont CSV
(Comma Separated Values) et JSON (JavaScript Object Notation).
Les deux formats ont leurs propres atouts et cas d'utilisation, ce qui en fait
des outils essentiels pour le traitement, le stockage et l'échange de données.
Dans cet article, nous allons explorer les formats de fichiers CSV et JSON,
leurs différences, leurs avantages et la manière de les utiliser en Python.
1. Comprendre les CSV (Comma Separated Values)
CSV est un format de fichier simple et largement utilisé pour stocker
des données tabulaires. Il représente les données sous forme de texte brut,
où chaque ligne du fichier correspond généralement à une ligne, et les
valeurs de la ligne sont séparées par des virgules ou d'autres délimiteurs
tels que des tabulations ou des points-virgules. Les fichiers CSV peuvent
être facilement créés et modifiés à l'aide d'applications de feuilles de calcul
courantes telles que Microsoft Excel ou Google Sheets.

Avantages du CSV :

Simplicité : Les fichiers CSV ont une structure simple, ce qui les rend
faciles à créer, à lire et à modifier manuellement ou par programme.
Compatibilité : Les fichiers CSV peuvent être importés et exportés par
un large éventail d'applications logicielles, ce qui les rend hautement
interopérables.
Léger : Les fichiers CSV ne consomment pas beaucoup d'espace
disque, ce qui les rend adaptés aux grands ensembles de données.

Travailler avec CSV en Python :

Python fournit un module intégré appelé "csv" pour gérer les fichiers
CSV sans effort. Explorons quelques opérations courantes à l'aide de ce
module.
Lecture des données d'un fichier
CSV : import csv
# Ouvrir le fichier CSV en mode lecture
 avec open('data.csv', 'r') comme fichier :
reader = csv.reader(file)
# Itérer à travers chaque ligne du fichier
CSV pour la ligne dans le lecteur :
# Traite les données de chaque ligne (la ligne est une liste de
valeurs) print(row)

Écriture de données dans un fichier CSV :

import csv
data = [
['Nom', 'Age', 'Passion'],
['Nibedita', 20, 'Programmer'],
['Bidisha', 21, 'Blogger'],
["Nibe", 22, "Graphiste"]
]
# Ouvrir le fichier CSV en mode écriture
avec open('output.csv', 'w', newline='') comme fichier :
writer = csv.writer(file)
# Ecriture des données dans le fichier
CSV ligne par ligne pour ligne dans
données :
writer.writerow(row)

2. Comprendre JSON (JavaScript Object Notation)

JSON est un format d'échange de données léger et lisible par l'homme.
Il est principalement utilisé pour transmettre des données entre un serveur et
une application web comme alternative à XML. Les données JSON sont
représentées par des paires clé-valeur et suivent une structure hiérarchique.
Les données au format JSON sont souvent stockées de manière imbriquée,
ce qui les rend particulièrement adaptées aux données complexes et non
structurées.

Avantages de JSON :

Flexibilité : JSON peut gérer des structures de données imbriquées et

complexes, ce qui lui permet de représenter les données de manière
plus souple que CSV.
 Lisibilité : JSON est facile à lire et à comprendre pour les humains et
les machines, ce qui en fait un choix idéal pour la transmission de
données.
Indépendance vis-à-vis du langage : Les données JSON peuvent être
traitées dans différents langages de programmation en raison de leur
simplicité et de leur standardisation.

Travailler avec JSON en Python :

Python fournit un module intégré appelé "json" pour travailler
efficacement avec des données JSON. Explorons quelques opérations
courantes à l'aide de ce module.
Lecture de données à partir d'un fichier JSON :
import json
# Ouvrir le fichier JSON en mode
lecture avec open('data.json', 'r') as file
:
data = json.load(file)
# 'data' contient maintenant les données JSON sous la forme d'un
dictionnaire ou d'une liste Python print(data)
Écrire des données dans un fichier JSON :
import json
data = {
nom" : "Nibedita Sahu",
"âge" : 20,
région" : "Inde
}
# Ouvrir le fichier JSON en mode
écriture avec open('output.json', 'w') as
file :
json.dump(data, file)

3. Différences entre CSV et JSON

Bien que CSV et JSON soient tous deux utilisés pour stocker des
données, ils présentent des différences fondamentales qui les rendent
adaptés à des cas d'utilisation différents.
Représentation des données :

Le format CSV représente les données sous forme de tableaux plats,

chaque ligne correspondant à un enregistrement et chaque colonne à
un champ.
JSON représente les données de manière hiérarchique et imbriquée, ce
qui le rend plus flexible pour les structures de données complexes.

Types de données :
 CSV est limité en termes de types de données.

Toutes les valeurs sont traitées comme des chaînes de caractères et il

n'existe pas de moyen natif de représenter des structures de données
complexes telles que des dictionnaires imbriqués ou des listes.

JSON prend en charge un plus grand nombre de types de données,

notamment les chaînes de caractères, les nombres, les booléens, les
tableaux et les objets imbriqués, ce qui le rend plus polyvalent pour
représenter des données structurées et non structurées.

Facilité de lecture :

Les fichiers CSV sont généralement plus faciles à lire et à comprendre

pour les humains en raison de leur structure plate et de leur
représentation simple.
JSON, bien que toujours lisible par l'homme, peut devenir plus
complexe et plus difficile à interpréter lorsqu'il s'agit de données
profondément imbriquées.

Cas d'utilisation :

Le format CSV est bien adapté aux données tabulaires simples, telles
que les feuilles de calcul, les journaux et les exportations de bases de
données.
JSON est idéal pour le stockage et l'échange de structures de données
complexes, telles que les configurations, les réponses aux API et les
données transmises entre les applications web et les serveurs.

4. Choisir entre CSV et JSON

Le choix entre CSV et JSON dépend largement de la nature des
données avec lesquelles vous devez travailler et du cas d'utilisation auquel
vous répondez.
Utiliser CSV quand :

Traitement de données tabulaires simples telles que des feuilles de calcul ou des
bases de données.
Les données sont relativement plates et ne nécessitent pas de structures
imbriquées ou complexes.
Vous avez besoin d'un format léger et simple pour le stockage des données.

Utiliser JSON quand :

 Travailler avec des structures de données complexes et hiérarchiques.
Les données doivent être échangées entre les applications web et les API.
Les données contiennent des objets ou des tableaux imbriqués qui doivent être
préservés.

5. Conseils pour un traitement efficace des fichiers

Que vous choisissiez CSV ou JSON, tenez compte de ces conseils pour
une gestion efficace des fichiers en Python :

Gestionnaires de contexte : Utilisez toujours des gestionnaires de

contexte (avec déclaration) lorsque vous travaillez avec des fichiers en
Python. Cela permet de s'assurer que le fichier est correctement fermé
après utilisation, même si une erreur survient pendant l'exécution.
Traitement par lots : Lorsque vous traitez de grands ensembles de
données, envisagez de traiter les données par lots afin d'éviter les
débordements de mémoire.
Gestion des erreurs : Mettre en œuvre une gestion des erreurs
appropriée lors de la lecture ou de l'écriture de fichiers afin de gérer
des situations telles que des fichiers manquants, des permissions de
fichiers ou des données inattendues.
Validation des données : Validez les données avant de les écrire dans
un fichier afin d'en garantir l'intégrité et d'éviter les problèmes liés à la
structure du fichier.
Formats et extensions de fichiers : Bien que les extensions de fichiers
ne soient pas essentielles à la gestion des fichiers en Python,
l'utilisation d'extensions appropriées telles que ".csv" pour les fichiers
CSV et ".json" pour les fichiers JSON facilite l'identification et
l'organisation des fichiers.

CSV et JSON sont tous deux des formats de fichier utiles pour traiter
des données structurées en Python. Alors que CSV convient pour les
données tabulaires à structure simple, JSON se distingue lorsqu'il s'agit de
données complexes et imbriquées.
Comprendre les différences entre ces formats et leurs avantages respectifs
peut vous aider à prendre des décisions éclairées lorsqu'il s'agit de stocker,
de traiter et d'échanger des données dans vos applications Python. N'oubliez
jamais de suivre les meilleures pratiques pour une manipulation efficace des
fichiers et de garantir l'intégrité des données afin de créer des programmes
robustes et fiables.
5. Manipulation de cordes :
5.1. OPÉRATIONS SUR LES CHAÎNES DE CARACTÈRES

5.2. EXPRESSIONS RÉGULIÈRES

5.1. OPÉRATIONS SUR LES CHAÎNES DE CARACTÈRES
La manipulation des chaînes de caractères est un concept fondamental de la
programmation, et Python offre un riche ensemble d'outils pour travailler
avec les chaînes de caractères. En Python, les chaînes sont des séquences de
caractères qui jouent un rôle crucial dans diverses applications, telles que le
traitement de texte, l'analyse de données et l'interaction avec l'utilisateur.
Dans cet article, nous allons explorer certaines des opérations sur les
chaînes les plus courantes et les plus utiles en Python.
1. Concaténation
La concaténation est le processus qui consiste à combiner deux ou
plusieurs chaînes de caractères en une seule. En Python, vous pouvez
utiliser l'opérateur "+" pour concaténer des chaînes de caractères.
name1 = "Nibedita"
name2 = "Bidisha"
full_name = name1 + " " + name2
print(full_name) # Output : Nibedita Bidisha

2. Longueur de la chaîne
Pour connaître la longueur d'une chaîne de caractères, vous pouvez
utiliser la fonction intégrée "len()". Elle renvoie le nombre de caractères de
la chaîne, espaces compris.
name = "Bidisha"
length = len(name)
print(length) # Sortie : 7

3. Indexation des chaînes de caractères

L'indexation des chaînes est utilisée pour accéder à des caractères
individuels dans une chaîne. En Python, les chaînes sont indexées par zéro,
ce qui signifie que le premier caractère a un index de 0, le deuxième
caractère a un index de 1, et ainsi de suite.
name = "Tushar"
first_character = name[0]
print(premier_caractère) # Sortie : T
troisième_caractère = nom[2]
print(troisième_caractère)
# Sortie : s

4. Trancher
 Le découpage permet d'extraire une partie d'une chaîne de caractères.
Pour ce faire, on utilise l'opérateur des deux points ':'. La syntaxe du
découpage est 'string[start:stop]', où 'start'
est l'indice du premier caractère à inclure, et 'stop' est l'indice du premier
caractère à exclure.
name = "Salil"
partial_name = name[2:5]
print(nom_partiel) # Sortie : lil
Ou si vous pouvez le faire :
name = "Mayukh"
partial_name = name[1:-2]
print(nom_partiel) # Sortie : ayu

Si vous omettez l'indice "start", Python le considère comme égal à 0.

De même, si vous omettez l'indice "stop", Python le considère comme la
longueur de la chaîne.
name = "Nibedita"
first_three_chars = name[:4]
print(first_three_chars) # Résultat :
Nibe last_two_chars = name[-4 :]
print(last_two_chars) # Sortie : dita

5. Méthodes des chaînes de caractères

Python fournit une pléthore de méthodes intégrées pour les chaînes de
caractères qui facilitent la manipulation des chaînes. Quelques méthodes
couramment utilisées :

5.1. lower() et upper() :

Ces méthodes renvoient une nouvelle chaîne dont tous les caractères ont
été convertis en minuscules ou en majuscules, respectivement.

text = "Hello, World !"

lowercase_text = text.lower()
print(lowercase_text) # Sortie : hello, world !

uppercase_text = text.upper()
print(uppercase_text) # Sortie : HELLO, WORLD !
5.2. strip(), lstrip() et rstrip() :

'strip()' supprime les caractères d'espacement de début et de fin de la

chaîne. 'lstrip()' supprime les caractères d'espacement initiaux et 'rstrip()'
supprime les caractères d'espacement finaux.

string_with_spaces = " Hello, Python !

"stripped_string = string_with_spaces.strip()
print(stripped_string) # Sortie : Bonjour,
Python !

5.3. split() :

La méthode 'split()' divise une chaîne de caractères en une liste de sous-

chaînes en fonction d'un délimiteur spécifié. Par défaut, elle divise la
chaîne au niveau des espaces.

sentence = "Python est un langage

extraordinaire" words = sentence.split()
print(words) # Sortie : ['Python', 'is', 'an', 'amazing', 'language']

Vous pouvez également fournir un délimiteur personnalisé comme argument à 'split()'.

date = "2023-07-31"
jour_mois_année = date.split("-")
print(jour_mois_année) # Sortie : ['2023', '07', '31']

5.4. join() :

La méthode 'join()' est utilisée pour joindre les éléments d'un itérable (par
exemple, une liste) en une seule chaîne de caractères en utilisant le
séparateur spécifié.
words = ['Python', 'is', 'awesome']
joined_string = " ".join(words)
print(joined_string) # Sortie : Python est génial

5.5. remplacer() :

La méthode "replace()" remplace toutes les occurrences d'une sous-chaîne

par une autre sous-chaîne.

text = "Bonjour, Nibedita !"

modified_text = text.replace("Nibedita", "NS")
print(modified_text) # Output : Bonjour, NS
!

5.6. startswith() et endswith() :

Ces méthodes vérifient si une chaîne commence ou se termine par une

sous-chaîne donnée et renvoient une valeur booléenne.

nom = "Nibedita"
starts_with_n = name.startswith("N")
print(starts_with_n) # Sortie : Vrai

ends_with_a = name.endswith("a")
print(ends_with_a) # Sortie : Vrai

6. Formatage des chaînes de caractères

Python propose différentes méthodes pour formater efficacement les
chaînes de caractères. Voici deux méthodes courantes :

6.1. f-strings (chaînes formatées) :

Les chaînes F sont un moyen pratique d'intégrer des expressions à
l'intérieur de chaînes littérales à des fins de formatage.

name = "Tushar"
age = 18
chaîne_formatée = f "Je m'appelle {nom} et j'ai {âge} ans" print(chaîne_formatée)

# Sortie : Je m'appelle Tushar et j'ai 18 ans.

6.2. format() :

La méthode "format()" permet d'insérer des valeurs dans des espaces

réservés au sein d'une chaîne de caractères.

name = "Salil"
age = 22
chaîne_formatée = "Mon nom est {} et j'ai {} ans.".format(nom, âge) print(chaîne_formatée)

# Sortie : Je m'appelle Salil et j'ai 22 ans.

Vous pouvez également utiliser l'indexation dans les espaces réservés pour
spécifier l'ordre des variables dans la méthode "format()".

name = "Mayukh"

age = 25

chaîne_formatée = "Mon nom est {1} et j'ai {0} ans.".format(age, name) print(chaîne_formatée)
# Sortie : Je m'appelle Mayukh et j'ai 25 ans.

7. Validation des chaînes de caractères

Python propose plusieurs méthodes pour valider les chaînes de
caractères, par exemple pour vérifier si une chaîne ne contient que des
caractères alphanumériques, des chiffres, des alphabets, etc.

7.1. isalpha() :

La méthode "isalpha()" renvoie "True" si tous les caractères de la chaîne

sont des alphabets ; sinon, elle renvoie "False".

text1 = "PythonIsFun"
is_alpha = text1.isalpha()
print(is_alpha) # Sortie : Vrai

# Mais si vous voulez bien écrire une phrase :

text2 = "Python is fun"
is_alpha = text2.isalpha()
print(is_alpha) # Sortie : Faux

7.2. isdigit() :

La méthode "isdigit()" renvoie "True" si tous les caractères de la chaîne

sont des chiffres ; sinon, elle renvoie "False".

phone_number = "1234567890"
is_digit = phone_number.isdigit()
print(is_digit) # Sortie : Vrai

7.3. isalnum() :

La méthode "isalnum()" renvoie "True" si tous les caractères de la chaîne

sont alphanumériques ; sinon, elle renvoie "False".
username = "NibeditaSahu2023"
is_alphanumeric = username.isalnum()
print(is_alphanumeric) # Sortie : Vrai

Dans cette section, nous avons exploré diverses opérations sur les chaînes
de caractères en Python pour la manipulation des chaînes. Nous avons
abordé la concaténation, la longueur des chaînes, l'indexation des chaînes,
le découpage, les méthodes de chaînes couramment utilisées, le formatage
des chaînes et la validation des chaînes. En tirant parti de ces opérations sur
les chaînes, vous pouvez effectuer de puissantes tâches de traitement de
texte et de manipulation de données en Python.
Comprendre la manipulation des chaînes de caractères est essentiel
pour tout programmeur Python, car elle constitue la base de nombreuses
applications du monde réel. Que vous travailliez avec des entrées
utilisateur, que vous lisiez des fichiers ou que vous traitiez avec des API,
une bonne maîtrise des opérations sur les chaînes de caractères rendra sans
aucun doute votre code plus efficace et plus robuste. Alors, continuez à
vous entraîner et à explorer les possibilités de la manipulation des chaînes
de caractères en Python !
 5.2. EXPRESSIONS RÉGULIÈRES
Les expressions régulières, souvent appelées "regex" ou "regexp", sont des
outils puissants pour la recherche de motifs et la manipulation de texte en
Python et dans de nombreux autres langages de programmation. Elles
permettent de rechercher des motifs spécifiques dans des chaînes de
caractères et d'effectuer diverses opérations basées sur ces motifs. Python
fournit le module re, qui prend en charge les expressions régulières.
Voici une définition des expressions régulières en Python :
Les expressions régulières en Python sont une séquence de caractères
qui définissent un modèle de recherche. Elles peuvent être utilisées pour
trouver, faire correspondre et manipuler des chaînes de caractères basées
sur des motifs spécifiques, ce qui rend le traitement de texte et l'extraction
de données plus efficaces et plus flexibles.
Pour utiliser les expressions régulières en Python, vous devez importer le module re.
Voici quelques fonctions et méthodes courantes fournies par le module
re de Python :
1. re.match() :
Déterminer si l'expression régulière correspond au début de la chaîne.
importer re
pattern = r'^Hello'
text = 'Hello, World!'
match = re.match(pattern, text)
if match :
print('Pattern matched at the beginning.')
else :
print('Pattern not found at the beginning.')

2. re.search() :
Recherche de la première occurrence d'un motif dans l'ensemble de la chaîne.
importer re
pattern = r'World'
text = 'Hello, World!'
search_result = re.search(pattern, text)
if search_result :
 print('Motif trouvé à l'index:', search_result.start())
else :
print('Motif non trouvé.')

3. re.findall() :
Recherche toutes les occurrences d'un motif dans la chaîne de caractères et les
renvoie sous forme de liste.
importer re
pattern = r'\d+' # Correspond à un ou plusieurs chiffres
text = 'Il y a 7 chats et 12 chiens dans le quartier' matches =
re.findall(pattern, text)
print('Chiffres trouvés:', matches)

4. re.sub() :
Remplacer toutes les occurrences d'un motif dans la chaîne par un
remplacement donné.
importer re
motif = r'\bapple\b'
text = 'J'ai une pomme, et elle a aussi une pomme'
replacement = 'orange'
new_text = re.sub(pattern, replacement, text)
print('Original text:', text)
print('Texte modifié:', nouveau_texte)

5. re.split() :
Divise la chaîne par les occurrences du motif.
importer re
pattern = r'\s+' # Correspond à un ou plusieurs caractères
d'espacement text = 'Hello World \ t of\tPython'
words = re.split(pattern, text)
print('Split words:', words)

Il ne s'agit là que de quelques-unes des opérations de base que les

expressions régulières peuvent effectuer en Python. Les expressions
régulières offrent un ensemble riche de fonctionnalités et de syntaxes pour
des tâches plus complexes de recherche et de manipulation de motifs. Elles
sont extrêmement utiles lorsqu'il s'agit de données textuelles et peuvent
faire gagner beaucoup de temps et d'efforts dans le traitement et l'analyse
des données.
6. Programmation orientée objet (POO) :
 6.1. CLASSES ET OBJETS
6.2. L'HÉRITAGE ET LE POLYMORPHISME
6.3. CONCEPTS AVANCÉS DE L'OOP
 6.1. CLASSES ET OBJETS
En Python, une classe est un modèle qui définit la structure et le
comportement des objets. Un objet, quant à lui, est une instance d'une
classe, créée sur la base de ce modèle. Les classes et les objets sont des
concepts fondamentaux de la programmation orientée objet (POO), qui
nous permet de modéliser des entités du monde réel, d'encapsuler des
données et de fournir des fonctionnalités.
Définir une classe :
Pour créer une classe en Python, vous utilisez le mot-clé class, suivi du
nom de la classe et de deux points. À l'intérieur de la classe, vous
définissez des attributs et des méthodes qui décrivent les caractéristiques
et les actions des objets créés à partir de la classe.
voiture de classe :
# Attributs de
classe Marque =
"Toyota" Année
= 2023
# Méthodes de classe
def start_engine(self) :
return f "Le moteur de {self.brand} a
démarré !" def accelerate(self, speed) :
return f"{self.brand} accélère à {vitesse} km/h"

Dans cet exemple, nous avons défini une classe appelée Voiture. Elle
possède deux attributs de classe (marque et année) et deux méthodes de
classe (start_engine() et accelerate()).
Création d'objets :
Une fois que vous avez une classe, vous pouvez créer des instances
(objets) de cette classe. Pour ce faire, vous appelez la classe comme s'il
s'agissait d'une fonction, ce qui crée un nouvel objet basé sur le plan de la
classe.
# Création de deux objets
Voiture nibedita_car = Car()
bidisha_car = Car()

Dans cet exemple, nous avons créé deux objets, nibedita_car et

bidisha_car, à partir de la classe Car.
Accès aux attributs et aux méthodes :
 Vous pouvez accéder aux attributs et aux méthodes d'un objet en
utilisant la notation par points.
print(nibedita_car.brand) # Sortie : Toyota
print(bidisha_car.year) # Sortie : 2023
print(nibedita_car.start_engine())
# Output : Le moteur de la Toyota a démarré !
print(bidisha_car.accelerate(80))
# Sortie : Toyota accélère à 80 km/h

Constructeur ( init ) :
Le programme init est une méthode spéciale qui est appelée
automatiquement lors de la création d'un objet. Elle est utilisée pour
initialiser les attributs spécifiques à l'objet.
classe Personne :
def init ( self, name, age) :
self.name = name
self.age = age
def say_hello(self) :
return f "Bonjour, mon nom est {self.name} et j'ai {self.age} ans"
tushar = Person("Tushar", 18)
salil = Personne("Salil", 22)
mayukh = Personne("Mayukh",
25) print(tushar.say_hello())
# Sortie : Bonjour, je m'appelle Tushar et j'ai 18 ans.
print(salil.say_hello())
# Sortie : Bonjour, je m'appelle Salil et j'ai 22 ans.
print(mayukh.say_hello())
# Sortie : Bonjour, je m'appelle Mayukh et j'ai 25 ans.

Attributs d'instance ou de classe :

Les attributs d'instance sont spécifiques à chaque objet et peuvent être
différents pour différentes instances.
Les attributs de la classe, en revanche, sont partagés par toutes les
instances de la classe.
classe Chien :
species = "Canine" # Attribut de
classe def init (self, name) :
self.name = name # Attribut d'instance
 tommy_dog = Dog("Tommy")
print(tommy_dog.name) # Output :
Tommy print(tommy_dog.species)
# Sortie : Canine (partagée entre toutes les instances)

En résumé, les classes et les objets sont essentiels dans le paradigme de

programmation orientée objet de Python. Les classes servent de plans pour
créer des objets, et les objets sont des instances de ces classes avec leurs
propres caractéristiques et comportements. Ils permettent l'organisation,
l'encapsulation et la réutilisation du code, facilitant ainsi la gestion
d'applications complexes.
 6.2. L'HÉRITAGE ET LE POLYMORPHISME
Héritage :
L'héritage est un concept fondamental de la programmation orientée
objet qui permet à une classe (appelée sous-classe ou classe dérivée)
d'hériter des propriétés et des comportements d'une autre classe (appelée
superclasse ou classe de base). La sous-classe peut réutiliser les attributs et
les méthodes de la superclasse et peut également avoir ses propres attributs
et méthodes spécifiques.
Définition d'une classe de base :
Pour créer une classe de base, vous définissez une classe normale
avec ses attributs et ses méthodes. La sous-classe peut ensuite hériter de
cette classe de base en utilisant la classe
NomSousClasse(NomBaseClasse) :
classe Animal :
def init ( self, name) :
self.name = name
def make_sound(self) :
return "Some generic sound"
def move(self) :
return "Un mouvement générique"

Dans cet exemple, nous avons une classe de base Animal avec les
attributs name, et les méthodes make_sound() et move().
Définition d'une sous-classe :
Pour créer une sous-classe qui hérite de la classe de base, il suffit
d'indiquer le nom de la classe de base entre parenthèses lors de la définition
de la sous-classe.
classe Chien(Animal) :
def init (self, name, breed) :
super(). init (name) self.breed
= breed
def make_sound(self) :
return "Woof !"
def move(self) :
return "Courir comme un chien"
 Ici, nous avons créé une sous-classe Dog qui hérite de la classe de base
Animal. La fonction super() est utilisée pour appeler le constructeur de la
classe de base et initialiser l'attribut name. La sous-classe surcharge
également les méthodes make_sound() et move().
 Utilisation de l'héritage :
Nous pouvons maintenant créer des objets de la sous-classe Chien et
accéder aux attributs et aux méthodes de la sous-classe et de la classe de
base.
dog = Dog("Buddy", "Golden Retriever")
print(dog.name) # Résultat : Buddy
print(dog.breed) # Sortie : Golden Retriever
print(dog.make_sound()) # Sortie : Woof !
print(dog.move()) # Sortie : Courir comme
un chien

Comme vous pouvez le voir, la sous-classe Dog a accès à l'attribut

name et aux méthodes make_sound() et move() de la classe de base
Animal.
Polymorphisme :
Le polymorphisme est un autre concept clé de la programmation
orientée objet, qui permet de traiter des objets de classes différentes comme
des objets d'une superclasse commune. Il permet à une interface unique de
représenter plusieurs types, ce qui apporte souplesse et réutilisation du
code.
def animal_sound(animal) :
return animal.make_sound()
# Création d'instances de la classe de base et de la sous-
classe cat = Animal("Whiskers")
dog = Dog("Buddy", "Golden Retriever")
print(animal_sound(cat)) # Sortie : Un son générique
print(animal_sound(dog)) # Sortie : Woof !

Dans cet exemple, nous avons créé une fonction animal_sound() qui
prend un objet en argument. Les classes Animal et Dog ont toutes deux une
méthode make_sound(), nous pouvons donc passer des objets des deux
classes à la fonction animal_sound(). Cela démontre le polymorphisme,
puisque le même appel de méthode se comporte différemment en fonction
du type de l'objet passé.
L'héritage et le polymorphisme sont des concepts puissants de la
programmation orientée objet qui facilitent l'organisation, la réutilisation et
la flexibilité du code.
L'héritage permet aux sous-classes d'hériter des attributs et des méthodes
d'une classe de base, ce qui permet la réutilisation et la spécialisation du
code. Le polymorphisme, quant à lui, permet à différents objets d'être
traités de manière uniforme sur la base de leur interface commune, offrant
ainsi une programmation souple et cohérente.
l'approche. Ensemble, ces concepts font de Python un langage expressif et
efficace pour construire des applications complexes et faciles à maintenir.
 6.3. CONCEPTS AVANCÉS DE L'OOP
Python est un langage polyvalent qui prend en charge des concepts avancés
de programmation orientée objet (POO). Outre les principes de base de la
POO tels que les classes, les objets, l'héritage et le polymorphisme, Python
propose également des fonctionnalités avancées qui améliorent la
modularité, la réutilisation et la maintenabilité du code. Explorons
quelques-uns de ces concepts avancés de POO à l'aide d'extraits de code :
1. Encapsulation :
L'encapsulation est le concept qui consiste à cacher au monde extérieur
les détails de l'implémentation d'un objet. Elle nous permet de protéger
l'état interne d'un objet et de contrôler l'accès à ses attributs et méthodes.
Python fournit un contrôle d'accès à l'aide de conventions de nommage :

Attribut : Un seul trait de soulignement indique un attribut privé.

attribut : Un double trait de soulignement indique un attribut
fortement privé (nom mélangé).
classe BankAccount :
def init (self, account_number, balance) :
self._account_number = account_number
self. balance = balance
def deposit(self, amount) :
self. balance += amount def
withdraw(self, amount) : if
amount <= self. balance :
self. b a l a n c e -=
amount else :
print("Solde insuffisant.")
def get_balance(self) :
return self. balance

account = BankAccount("123456789", 1000)

print(account.get_balance()) # Output : 1000
account.withdraw(500)
 print(account.get_balance()) # Sortie : 500
print(account. balance)
# AttributeError : l'objet 'BankAccount' n'a pas d'attribut 'balance'

Dans cet exemple, nous utilisons un double trait de soulignement

pour rendre l'attribut
l'attrib
ut balance. Toute tentative d'accès direct à cet attribut entraînera une
erreur de type AttributeError.
2. Décorateurs immobiliers :
Le décorateur de propriétés de Python nous permet de créer des
méthodes getter, setter et deleter pour les attributs de la classe. Cela permet
de contrôler l'accès aux attributs et leur validation.
classe Rectangle :
def init (self, width, height) : self._width
= width
self._height = height
@property
def width(self) :
return self._width
@width.setter
def width(self, value) :
si la valeur > 0 :
self._width = value
else :
raise ValueError("La largeur doit être supérieure à
0.") @property
def height(self) :
return self._height
@height.setter
def height(self, value) :
si la valeur > 0 :
self._height = value
else :
raise ValueError("La hauteur doit être supérieure à
0.") def area(self) :
return self._width * self._height
rect = Rectangle(5, 3)
print(rect.area()) # Output : 15
rect.width = 10
rect.height = 6
print(rect.area()) # Output : 60
rect.width = -2 # Raises ValueError : La largeur doit être supérieure à 0.

Dans cet exemple, nous utilisons des décorateurs de propriétés pour

créer des méthodes getter et setter pour les attributs width et height de la
classe Rectangle.
3. Méthodes de classe et méthodes statiques :
Python prend en charge les méthodes de classe et les méthodes
statiques. Les méthodes de classe prennent la classe comme premier
argument (généralement nommée cls) et peuvent accéder ou modifier les
attributs au niveau de la classe. Les méthodes statiques ne dépendent pas
de la classe ou de l'instance et sont utilisées pour des fonctions utilitaires au
sein de la classe.
classe MathUtils :
PI = 3,14159
@classmethod
def circle_area(cls, radius) :
return cls.PI * radius * radius
@staticmethod
def add(a, b) :
renvoie a + b

print(MathUtils.circle_area(5)) # Sortie : 78.53975

print(MathUtils.add(2, 3)) # Sortie : 5

Dans cet exemple, nous définissons une classe MathUtils avec une
méthode de classe circle_area() pour calculer la surface d'un cercle et une
méthode statique add() pour effectuer une addition.
4. Classes de base abstraites (ABC) :
Les classes de base abstraites (ABC) nous permettent de définir des
méthodes abstraites qui doivent être mises en œuvre par les sous-classes
concrètes. Les ABC font office de contrat pour les sous-classes,
garantissant qu'elles fournissent les fonctionnalités requises.
from abc import ABC, abstractmethod
class Shape(ABC) :
@abstractmethod
 def area(self) :
passer
classe Square(Forme) :
def init ( self, side) :
self.side = side
def area(self) :
return self.side ** 2
class Circle(Shape) :
def init ( self, radius) :
self.radius = radius
def area(self) :
return 3.14159 * self.radius ** 2
square = Square(4)
circle = Circle(3)
print(square.area()) # Output : 16
print(circle.area()) # Sortie : 28.27431

Dans cet exemple, la classe Shape est une classe de base abstraite avec
une méthode abstraite area(). Les sous-classes Square et Circle
implémentent la méthode area(), ce qui en fait des sous-classes concrètes.

Les concepts OOP avancés de Python, tels que l'encapsulation, les

décorateurs de propriétés, les méthodes de classe, les méthodes statiques et
les classes de base abstraites, améliorent les capacités du langage et
favorisent la modularité, la réutilisation et la maintenabilité du code. En
tirant parti de ces fonctionnalités, les développeurs peuvent créer des
applications orientées objet plus sophistiquées et plus efficaces en Python.
7. Modules et paquets :
 7.1. CRÉATION ET
IMPORTATION DE MODULES

7.2. TRAVAILLER AVEC DES PAQUETS

 7.1. CRÉATION ET
IMPORTATION DE
MODULES
Les modules en Python sont des fichiers séparés qui contiennent du code
Python, y compris des variables, des fonctions et des classes. Ils vous
permettent d'organiser votre code de manière logique et favorisent la
réutilisation du code. Le système de modules de Python permet de diviser
facilement un programme volumineux en parties plus petites et plus faciles
à gérer.
Création d'un module :
La création d'un module en Python est très simple. Il suffit d'écrire
votre code dans un fichier .py distinct, et ce fichier devient un module qui
peut être importé dans d'autres scripts Python.
# math_operations.py
def add(a, b) :
renvoie a + b
def subtract(a, b) :
retourner a - b
def multiply(a, b) :
retour a * b
def divide(a, b) :
si b == 0 :
raise ValueError("Impossible de diviser par
zéro.") return a / b

Dans cet exemple, nous avons créé un module math_operations.py

contenant quatre fonctions : add(), subtract(), multiply() et divide().
Importation d'un module :
Pour utiliser les fonctions ou les variables d'un module dans un autre
script, vous devez importer le module à l'aide du mot-clé import.
# main.py
import math_operations
result_add = math_operations.add(5, 3)
print("Addition :", result_add) # Output : Addition :
8 result_multiply = math_operations.multiply(4, 6)
print("Multiplication :", result_multiply) # Output : Multiplication : 24
 Dans cet exemple, nous avons importé le module math_operations et
utilisé ses fonctions add() et multiply() dans le script main.py.
Importation de fonctions spécifiques :
Vous pouvez également importer des fonctions ou des variables
spécifiques d'un module à l'aide du mot-clé from.
# main.py
from math_operations import add, multiply
result_add = add(5, 3)
print("Addition :", result_add) # Output : Addition : 8
result_multiply = multiply(4, 6)
print("Multiplication :", result_multiply) # Output : Multiplication : 24

Dans cet exemple, nous n'avons importé que les fonctions add() et
multiply() du module math_operations.
Utilisation d'alias :
Vous pouvez attribuer des alias aux noms de modules ou de fonctions à
l'aide du mot-clé as. Cela peut s'avérer utile pour éviter les conflits de noms
ou pour utiliser des noms plus courts.
# main.py
import math_operations as mo
result_add = mo.add(5, 3)
print("Addition :", result_add) # Output : Addition : 8
result_multiply = mo.multiply(4, 6)
print("Multiplication :", result_multiply) # Output : Multiplication : 24

Dans cet exemple, nous avons importé le module math_operations avec

l'alias mo.
Importer toutes les fonctions (non recommandé) :
Vous pouvez importer toutes les fonctions d'un module en utilisant la
syntaxe from nom_du_module import *. Toutefois, cette méthode n'est
généralement pas recommandée, car elle peut entraîner des conflits de
noms et réduire la lisibilité du code.
# main.py
from math_operations import *
result_add = add(5, 3)
print("Addition :", result_add) # Output : Addition : 8
result_multiply = multiply(4, 6)
 print("Multiplication :", result_multiply) # Output : Multiplication : 24

Création et importation de paquets :

Un paquetage est une collection de modules apparentés. Il s'agit
simplement d'un répertoire qui contient un fichier spécial nommé init
.py. Ce fichier peut être vide ou
contenir du code d'initialisation pour le paquet.
Pour importer des modules à partir d'un paquetage, vous utilisez
l'instruction import avec le nom du paquetage et le nom du module séparés
par un point.

Créez un répertoire nommé mon_package et créez-y deux fichiers :

mon_package/ init .py :

# my_package/ init .py (le laisser vide)

my_package/utils.py :

# my_package/utils.py
def greet(name) :
return f "Bonjour, {nom} !"

Maintenant, créez un fichier nommé main.py dans le même répertoire

que le répertoire my_package avec le contenu suivant :
# main.py
from my_package import utils message
= utils.greet("Alice") print(message) #
Output : Bonjour, Alice !

Dans cet exemple, nous avons créé un paquetage nommé my_package

et importé la fonction greet() du module utils à l'intérieur de ce paquetage.

La création et l'importation de modules et de paquets en Python est un

aspect essentiel de la construction d'un code modulaire, organisé et facile à
maintenir. Grâce aux modules et aux paquets, vous pouvez facilement
décomposer de gros programmes en
Les composants plus petits favorisent la réutilisation du code et permettent
de conserver une base de code propre et gérable.
 7.2. TRAVAILLER AVEC DES PAQUETS
En Python, un paquetage est une collection de modules connexes organisés
dans une hiérarchie de répertoires. Les paquets sont utilisés pour organiser
le code en unités logiques, ce qui permet d'améliorer la gestion et la
réutilisation du code. Travailler avec des paquets implique de créer des
paquets, d'importer des modules à partir de paquets et de comprendre
comment Python gère l'initialisation des paquets.
Création d'un paquet :
Pour créer un paquet, vous devez créer un répertoire contenant un
fichier spécial appelé init .py. Ce
fichier peut être vide ou contenir du code d'initialisation pour le paquet.
La présence du fichier init .py
indique que le répertoire est un paquet.
Créons un paquet nommé mon_paquet avec deux modules à l'intérieur.
mon_package/
init .py
module1.py
module2.py

mon_package/ init .py :

# my_package/ init .py (laissez-le vide ou ajoutez du code

d'initialisation si nécessaire)

my_package/module1.py :

# my_package/module1.py
def function1() :
return "Fonction 1 du module1"

my_package/module2.py :

# my_package/module2.py
def function2() :
 return "Fonction 2 du module2"

Importation de modules à partir de paquets :

Pour utiliser les modules d'un paquetage, vous devez les importer à
l'aide de l'instruction import. Vous pouvez importer des modules
directement depuis le paquetage ou depuis des sous-paquetages.
Supposons que nous ayons un script nommé main.py dans le même
répertoire que le paquet my_package.
# main.py
from my_package import module1, module2
print(module1.function1()) # Output : Fonction 1 du module1
print(module2.function2()) # Sortie : Fonction 2 du module2

Dans cet exemple, nous importons module1 et module2 du paquet

my_package et utilisons leurs fonctions.
Importation de sous-paquets :
Vous pouvez également importer des modules à partir de sous-
paquetages en utilisant la notation point.
Supposons que nous ayons un sous-paquet nommé sub_package à
l'intérieur du paquetage my_package avec un module nommé module3.py.
mon_package/
init .py module1.py
module2.py
sub_package/
init .py module3.py

Travailler avec des paquets en Python :

En Python, un paquetage est une collection de modules connexes
organisés dans une hiérarchie de répertoires. Les paquets sont utilisés pour
organiser le code en unités logiques, ce qui permet d'améliorer la gestion et
la réutilisation du code. Travailler avec des paquets implique de créer des
paquets, d'importer des modules à partir de paquets et de comprendre
comment Python gère l'initialisation des paquets.
Création d'un paquet :
 Pour créer un paquet, vous devez créer un répertoire contenant un
fichier spécial appelé init .py. Ce
fichier peut être vide ou contenir du code d'initialisation pour le paquet.
La présence du fichier init .py
indique que le répertoire est un paquet.
Créons un paquet nommé mon_paquet avec deux modules à l'intérieur.
markdown
Copier le code
mon_package/
init .py
module1.py
module2.py
my_package/ init . py :
python
Copier le
code
# my_package/ init . py (laissez-le vide ou ajoutez du code d'initialisation si nécessaire)

my_package/module1.py :

python
Copier le
code
# my_package/module1.py
def function1() :
return "Fonction 1 du module1"

my_package/module2.py :

python
Copier le
code
# my_package/module2.py
def function2() :
return "Fonction 2 du module2"

Importation de modules à partir de paquets :

Pour utiliser les modules d'un paquetage, vous devez les importer à
l'aide de l'instruction import. Vous pouvez importer des modules
directement depuis le paquetage ou depuis des sous-paquetages.
 Supposons que nous ayons un script nommé main.py dans le même
répertoire que le paquet my_package.
python
Copier le
code #
main.py
from my_package import module1, module2
print(module1.function1()) # Output : Fonction 1 du module1
print(module2.function2()) # Sortie : Fonction 2 du module2
Dans cet exemple, nous importons module1 et module2 du paquet my_package et utilisons leurs
fonctions.

Importation de sous-paquets :
Vous pouvez également importer des modules à partir de sous-
paquetages en utilisant la notation point.
Supposons que nous ayons un sous-paquet nommé sub_package à
l'intérieur du paquetage my_package avec un module nommé module3.py.
markdown
Copier le code
mon_package/
init .py module1.py
module2.py
sub_package/
init .py module3.py

my_package/sub_package/module3.py :

# my_package/sub_package/module3.py
def function3() :
return "Fonction 3 du module3"

main.py :

# main.py
from my_package import module1, sub_package
print(module1.function1()) # Output : Fonction 1 de module1
 print(sub_package.module3.function3()) # Sortie : Fonction 3 du module3

Dans cet exemple, nous importons sub_package du paquet my_package

et accédons à la fonction3() de module3 en utilisant la notation point.
Initialisation du paquet :
Lorsqu'un paquetage est importé, Python exécute le code dans le fichier
init .py dans le répertoire du paquetage. Cela vous permet
d'effectuer toutes les tâches d'initialisation nécessaires pour le paquet.
Dans le fichier my_package/ init .py, nous pouvons ajouter du
code d'initialisation :
# my_package/ init .py
print("Initialisation de mon_package")
# Vous pouvez définir des variables ou des fonctions qui doivent être disponibles lorsque le paquet
est importé my_variable = 42
def greet(name) :
return f "Bonjour, {nom} !"

Maintenant, lorsque nous importons le paquet my_package, le code

d'initialisation sera exécuté :
# main.py
import my_package
print(my_package.my_variable) # Output : 42
print(my_package.greet("Nibe")) # Sortie : Bonjour, Nibe !

Dans cet exemple, la fonction init .py du paquet my_package est

exécuté lorsque le paquet est importé, et les variables et fonctions qui y
sont définies peuvent être utilisées.
L'utilisation de paquets en Python vous permet d'organiser votre code en
unités logiques, d'améliorer la réutilisation du code et de rendre vos projets
plus faciles à maintenir. En créant des paquets et en utilisant les instructions
d'importation appropriées, vous pouvez structurer votre base de code de
manière efficace et tirer parti des fonctionnalités de modularité de Python.
8. Gestion des erreurs et exceptions :
8.1. LA GESTION DES ERREURS ET DES EXCEPTIONS

8.2. ESSAYER- SAUF LES BLOCS

8.1. LA GESTION DES ERREURS ET DES
EXCEPTIONS
En Python, les exceptions sont levées lorsque le programme rencontre des
erreurs ou des situations inattendues au cours de l'exécution. Pour éviter
que le programme ne se termine brutalement, Python fournit un mécanisme
permettant de gérer ces exceptions de manière élégante en utilisant des
blocs try, except, else et finally. Cette approche est connue sous le nom de
"gestion des erreurs" ou "gestion des exceptions".
1. Le bloc d'essai et d'exception :
Le bloc try est utilisé pour entourer le code susceptible de soulever une
exception. Si une exception se produit à l'intérieur du bloc try, le
programme passe immédiatement au bloc except correspondant et
l'exécution se poursuit à partir de là.
essayer :
x = 10 / 0
sauf ZeroDivisionError :
print("Erreur : Division par zéro")

Dans cet exemple, si une ZeroDivisionError se produit (division par

zéro), le programme passe au bloc except et le message d'erreur est
imprimé.

2. Gestion des exceptions multiples :

Vous pouvez gérer plusieurs exceptions en incluant plusieurs blocs
except.
essayer :
num = int(input("Enter a number : "))
result = 10 / num
except ValueError :
print("Entrée invalide : Veuillez entrer un nombre
valide.") except ZeroDivisionError :
print("Erreur : Division par zéro.")

Dans cet exemple, nous gérons à la fois l'erreur ValueError (lorsque

l'entrée n'est pas un nombre valide) et l'erreur ZeroDivisionError (lorsque
l'entrée est zéro).
3. L'autre bloc :
 Le bloc else est facultatif et n'est exécuté que si aucune exception n'est
levée dans le bloc try. Il est utile pour ajouter du code qui doit être exécuté
lorsque le bloc try se termine avec succès.
essayer :
num1 = int(input("Enter the first number : "))
num2 = int(input("Enter the second number : "))
result = num1 / num2
except ValueError :
print("Entrée invalide : Veuillez entrer des nombres
valides.") except ZeroDivisionError :
print("Error : Division by zero.")
else :
print(f "Le résultat est : {résultat}")

Dans cet exemple, si aucune exception n'est levée, le programme

imprimera le résultat de la division.
4. Enfin, le bloc :
Le bloc finally est facultatif et sert à définir les actions de nettoyage qui
doivent être exécutées, qu'une exception ait été levée ou non. Il s'exécute
indépendamment du fait qu'une exception se soit produite ou qu'elle ait été
gérée.
essayer :
file = open("example.txt", "r")
content = file.read()
except FileNotFoundError :
print("Error : File not found.")
else :
print("Contenu du fichier :",
contenu) finally :
file.close()
# Cela s'exécutera toujours, qu'une exception se soit produite ou non.

Dans cet exemple, le fichier est fermé dans le bloc final, ce qui garantit
qu'il est fermé correctement, même en cas d'exception.
5. Lever les exceptions :
Vous pouvez lever des exceptions à l'aide de l'instruction raise. Cela
peut s'avérer utile lorsque vous souhaitez gérer certaines situations
manuellement.
def calculate_square_root(number) :
 si nombre < 0 :
raise ValueError("Input must be a non-negative number.")
return number ** 0.5
essayer :
result = calculate_square_root(-9)
except ValueError as ve :
print(ve) # Sortie : L'entrée doit être un nombre non négatif.

Dans cet exemple, nous définissons une fonction

calculate_square_root() qui soulève une ValueError si l'entrée est négative.
La gestion des erreurs et des exceptions en Python est essentielle pour
écrire des programmes robustes et fiables. L'utilisation des blocs try, except,
else et finally vous permet de gérer les erreurs de manière élégante et
d'éviter que votre programme ne se bloque de manière inattendue. En gérant
correctement les exceptions, vous pouvez améliorer l'expérience de
l'utilisateur et vous assurer que votre code se comporte comme prévu,
même dans des circonstances inattendues.
 8.2. ESSAYER- SAUF LES BLOCS
En Python, un bloc try-except est un mécanisme utilisé pour gérer les
exceptions. Il permet de gérer de manière élégante les erreurs et les
exceptions susceptibles de se produire pendant l'exécution d'un bloc de
code. Le bloc try contient le code susceptible de lever une exception, et le
bloc except contient le code qui doit être exécuté si une exception se
produit.
essayer :
# Code susceptible de soulever une
exception except ExceptionType :
# Code pour gérer l'exception

Le bloc try contient le code susceptible de lever une

exception. Le bloc except n'est exécuté que si une exception
de type
ExceptionType (ou sa sous-classe) se produit dans le bloc d'essai.
Prenons un exemple où nous essayons de diviser deux nombres et où
nous voulons gérer le cas où le deuxième nombre est zéro, ce qui
entraînerait une ZeroDivisionError.
essayer :
num1 = int(input("Enter the first number : "))
num2 = int(input("Enter the second number : "))
result = num1 / num2
sauf ZeroDivisionError :
print("Erreur : Division par zéro.")

Dans cet exemple, si l'utilisateur saisit zéro comme deuxième nombre,

une ZeroDivisionError sera levée. Le bloc except capture l'exception et le
message "Error : Division par zéro" sera imprimé.
Vous pouvez gérer plusieurs exceptions en incluant plusieurs blocs
except.
essayer :
# Code susceptible de soulever une
exception except ExceptionType1 :
# Code pour traiter le type
d'exception 1 sauf le type
d'exception 2 :
# Code pour traiter le type d'exception 2
 Gestion des exceptions multiples :

essayer :
num1 = int(input("Enter the first number : "))
num2 = int(input("Enter the second number : "))
result = num1 / num2
except ValueError :
print("Entrée invalide : Veuillez entrer des nombres
valides.") except ZeroDivisionError :
print("Erreur : Division par zéro.")

Dans cet exemple, nous gérons à la fois l'erreur ValueError (lorsque

l'entrée n'est pas un nombre valide) et l'erreur ZeroDivisionError (lorsque
l'entrée est zéro).
L'autre bloc :
Le bloc else est facultatif et n'est exécuté que si aucune exception n'est
levée dans le bloc try. Il est utilisé pour ajouter du code qui doit être
exécuté lorsque le bloc try se termine avec succès.
essayer :
num1 = int(input("Enter the first number : "))
num2 = int(input("Enter the second number : "))
result = num1 / num2
except ValueError :
print("Entrée invalide : Veuillez entrer des chiffres
valides.") except ZeroDivisionError :
print("Error : Division by zero.")
else :
print(f "Le résultat est : {résultat}")

Dans cet exemple, si aucune exception n'est levée, le programme

imprimera le résultat de la division.
Enfin, le bloc :
Le bloc finally est facultatif et sert à définir les actions de nettoyage qui
doivent être exécutées, qu'une exception ait été levée ou non. Il s'exécute
indépendamment du fait qu'une exception se soit produite ou qu'elle ait été
gérée.
essayer :
file = open("example.txt", "r")
content = file.read()
 except FileNotFoundError :
print("Error : File not found.")
else :
print("Contenu du fichier :",
contenu) finally :
file.close() # Cela s'exécutera toujours, qu'une exception se soit produite ou non.

Dans cet exemple, le fichier est fermé dans le bloc final, ce qui garantit
qu'il est fermé correctement, même en cas d'exception.
Les blocs try-except en Python permettent de gérer les exceptions et les
erreurs avec élégance. En utilisant ces blocs, vous pouvez anticiper et gérer
les situations exceptionnelles, ce qui évite à votre programme de se
terminer brutalement et offre une meilleure expérience à l'utilisateur. Ils
constituent un élément essentiel de l'écriture d'un code fiable et robuste.
9. Programmation fonctionnelle :
 9.1. FONCTIONS LAMBDA

9.2. LES FONCTIONS DE

CARTOGRAPHIE, DE FILTRAGE
ET DE RÉDUCTION
 9.1. FONCTIONS LAMBDA
Les fonctions lambda, également connues sous le nom de fonctions
anonymes, sont une fonctionnalité puissante de Python qui vous permet de
créer de petites fonctions d'une ligne sans avoir besoin d'une définition
formelle de la fonction à l'aide du mot-clé def. Ces fonctions concises sont
généralement utilisées pour des opérations simples ou comme arguments de
fonctions d'ordre supérieur qui nécessitent une fonction en entrée. Les
fonctions lambda constituent un moyen rapide et pratique de définir et
d'utiliser des fonctions à la volée, ce qui rend le code Python plus expressif
et plus lisible.
arguments lambda : expression
Dans cette syntaxe, les arguments représentent les paramètres d'entrée
de la fonction, et l'expression est une expression unique qui est évaluée et
renvoyée comme résultat de la fonction. Les fonctions lambda peuvent
avoir un nombre quelconque d'arguments, mais elles ne doivent contenir
qu'une seule expression.
Le principal avantage des fonctions lambda réside dans leur concision
et dans le fait qu'elles peuvent être utilisées en ligne avec d'autres fonctions
ou expressions. Au lieu de définir une fonction nommée à part entière, vous
pouvez utiliser une fonction lambda directement là où elle est nécessaire.
Cela permet d'éviter d'encombrer le code avec de nombreuses petites
fonctions et d'améliorer la maintenabilité du code.
Explorons quelques exemples pour mieux comprendre les fonctions lambda :
add = lambda x, y : x + y
result = add(3, 5) # Le résultat sera 8

Dans cet exemple, nous définissons une fonction lambda add qui prend
deux arguments x et y et renvoie leur somme. Nous appelons ensuite la
fonction lambda avec les arguments 3 et 5, et elle renvoie 8.
nombres = [1, 2, 3, 4, 5]
nombres_carrés = list(map(lambda x : x ** 2, nombres)) #
nombres_carrés sera [1, 4, 9, 16, 25]

Ici, nous utilisons une fonction lambda avec map(), une fonction d'ordre
supérieur qui applique la fonction donnée à chaque élément de la liste des
nombres. La fonction lambda prend un argument x et renvoie son carré.
Bien que les fonctions lambda présentent plusieurs avantages, il
convient de connaître certaines limites :
 Expression unique : Les fonctions lambda sont limitées à une seule
expression, ce qui signifie qu'elles ne peuvent pas contenir plusieurs
instructions ou une logique complexe. Pour des fonctions plus
complexes, vous devez utiliser des fonctions nommées régulières
définies avec def.

Pas de documentation : Les fonctions lambda sont anonymes, ce qui

signifie qu'elles n'ont pas de nom formel et, par conséquent, qu'elles
n'ont pas de documentation associée. Il peut être difficile de
documenter correctement les fonctions lambda, ce qui peut affecter la
lisibilité et la maintenabilité du code.

Cas d'utilisation limités : Si les fonctions lambda sont pratiques pour

les opérations simples, elles ne sont pas forcément idéales pour les
tâches plus complexes qui nécessitent plusieurs lignes de code ou une
récursion.

Problèmes de lisibilité : L'utilisation de fonctions lambda trop

complexes peut rendre le code plus difficile à lire et à comprendre. Il
est essentiel de trouver un équilibre entre concision et lisibilité.

Malgré ces limitations, les fonctions lambda sont un outil essentiel dans
l'arsenal d'un programmeur Python. Elles sont particulièrement utiles
lorsque l'on travaille avec des fonctions qui acceptent d'autres fonctions
comme arguments, telles que les opérations de tri, de filtrage ou de
mappage. En outre, elles contribuent au paradigme de la programmation
fonctionnelle en Python et peuvent rendre le code plus élégant et plus
expressif lorsqu'elles sont utilisées judicieusement.
En résumé, les fonctions lambda en Python sont de petites fonctions
anonymes qui offrent un moyen concis de définir des opérations rapides à
la volée. Elles conviennent mieux pour des tâches simples et lorsqu'elles
sont utilisées en conjonction avec des fonctions d'ordre supérieur. Bien
qu'elles aient leurs limites, la maîtrise des fonctions lambda peut améliorer
vos compétences en matière de codage Python et conduire à un code plus
élégant et plus fonctionnel.
 9.2. LES FONCTIONS DE
CARTOGRAPHIE, DE
FILTRAGE ET DE
RÉDUCTION
"Map", "filter" et "reduce" sont trois fonctions intégrées d'ordre supérieur
en Python qui sont souvent utilisées pour effectuer des opérations de
programmation fonctionnelle sur des itérables, tels que des listes, des
tuples et d'autres types de séquences. Ces fonctions offrent un moyen plus
concis et plus expressif de manipuler des données et d'effectuer des calculs.
Définissons chacune de ces fonctions :
Fonction de carte :
La fonction map() applique une fonction spécifiée à chaque élément
d'un itérable (par exemple, une liste) et renvoie un itérateur qui produit les
résultats. Elle prend deux arguments : la fonction à appliquer et l'itérable.
La fonction peut être une fonction nommée ordinaire ou une fonction
lambda.
Syntaxe :
map(function, iterable)
Code :
# Définir une fonction pour élever un
nombre au carré def square(x) :
retour x ** 2
# Utiliser map() pour appliquer la fonction square à chaque élément de
la liste numbers = [1, 2, 3, 4, 5]
nombres_carrés = map(square, numbers) #
nombres_carrés sera [1, 4, 9, 16, 25]

Dans cet exemple, la fonction map() applique la fonction square() à

chaque élément de la liste des nombres, ce qui donne un nouvel itérateur
contenant les valeurs élevées au carré.
Fonction du filtre :
La fonction filter() applique une fonction spécifiée à chaque élément
d'une table itérative et renvoie un itérateur qui ne contient que les éléments
pour lesquels la fonction renvoie la valeur True. Similaire à map(), elle
prend également deux arguments : la fonction à appliquer et l'itérable.
Syntaxe :
 filter(function, iterable)
Code :
# Définir une fonction pour vérifier si un nombre est pair
def is_even(x) :
return x % 2 == 0
# Utiliser filter() pour ne garder que les nombres pairs de la
liste numbers = [1, 2, 3, 4, 5]
even_numbers = filter(is_even, numbers)
# even_numbers sera [2, 4]

Dans cet exemple, la fonction filter() applique la fonction is_even() à

chaque élément de la liste des nombres, ne renvoyant que les éléments qui
satisfont à la condition d'être pairs.
Réduire la fonction :
La fonction reduce() fait partie du module functools de la bibliothèque
standard de Python. Elle applique une fonction binaire spécifiée aux
éléments d'un itérable de manière cumulative de gauche à droite et renvoie
une seule valeur agrégée. La fonction doit prendre deux arguments.
Syntaxe :
reduce(function, iterable[, initializer])
Code :
from functools import reduce
# Définir une fonction pour additionner
deux nombres def add(x, y) :
retour x + y
# Utiliser reduce() pour additionner tous les
éléments de la liste numbers = [1, 2, 3, 4, 5]
sum_all = reduce(add, numbers)
# sum_all sera 15 (1 + 2 + 3 + 4 + 5)
Dans cet exemple, la fonction reduce() applique la fonction add() de
manière cumulative aux éléments de la liste des nombres, ce qui donne la
somme de tous les éléments.
Il convient de noter que dans Python 3, reduce() a été déplacé de
l'espace de noms intégré vers le module functools. Vous devez donc
l'importer explicitement comme indiqué dans l'exemple ci-dessus.
En conclusion, "map", "filter" et "reduce" sont de puissantes fonctions
d'ordre supérieur en Python qui vous permettent de manipuler et de traiter
des données dans un style de programmation fonctionnelle. Elles offrent un
moyen concis et expressif d'effectuer des opérations sur des itérables, ce
qui peut conduire à un code plus lisible et plus facile à maintenir.
10. Itérateurs et générateurs :
 10.1. PROTOCOLES D'ITÉRATION

10.2. CRÉATION ET UTILISATION DE GÉNÉRATEURS

 10.1. PROTOCOLES D'ITÉRATION
Les protocoles d'itération en Python sont un ensemble de règles qui
définissent comment les objets peuvent être itérés en utilisant la boucle for
ou d'autres constructions de boucle. Ces protocoles sont fondamentaux
pour la prise en charge par Python des objets itérables, leur permettant de
fonctionner de manière transparente avec diverses fonctions et
constructions intégrées qui attendent ou prennent en charge l'itération. Les
deux principaux protocoles d'itération de Python sont le "protocole
itérable" et le "protocole itérateur".
Protocole itérable :
Le protocole itérable définit le comportement nécessaire pour que
les objets soient considérés comme itérables. Un itérable est un objet qui
peut produire un itérateur lorsque la fonction iter() est appelée sur lui.
Un itérable doit implémenter la fonction
iter ( ), qui doit renvoyer un objet itérateur.
Les iter () ne doit pas créer un nouvel objet itérateur à chaque
appel. Elle doit plutôt renvoyer un objet itérateur capable de parcourir les
éléments de l'itérable du début à la fin. Si l'itérable est lui-même son
propre itérateur, il peut renvoyer self dans la méthode iter (), ce qui
simplifie la mise en œuvre.

classe MyIterable :
def init ( self, data) :
self.data = data
def iter (self) :
return iter(self.data)
my_list = [1, 2, 3, 4, 5]
iterable_object = MyIterable(my_list)
for item in iterable_object :
print(item)

Dans cet exemple, MyIterable est une classe itérable qui contient une
liste de données. Lorsque iter () est appelé, il renvoie un objet
itérateur créé à l'aide de la méthode
fonction iter() appliquée à la liste.
Protocole d'itération :
Le protocole itérateur définit le comportement nécessaire pour que les
objets soient considérés comme des itérateurs. Un itérateur est un objet qui
permet de parcourir une séquence d'éléments et de les récupérer un par un à
l'aide de la fonction next(). Les itérateurs doivent implémenter deux
méthodes : iter () et next ().
Les iter () doit renvoyer l'objet itérateur lui-même. Cette méthode
permet d'utiliser des itérateurs dans des contextes où un itérable est attendu.
Les next () doit renvoyer l'élément suivant de la séquence.
S'il n'y a plus d'éléments à renvoyer, il doit lever l'exception StopIteration.
classe MyIterator :
def init ( self, data) :
self.data = data
self.index = 0
def iter ( self) :
return self
def next ( self) :
si self.index >= len(self.data) :
lever StopIteration
value = self.data[self.index]
self.index += 1
valeur de retour
my_list = [1, 2, 3, 4, 5]
iterator_object = MyIterator(my_list)
for item in iterator_object :
print(item)

Dans cet exemple, MyIterator est une classe d'itérateur qui contient une
liste de données. L'itérateur next () nous permet de récupérer chaque
élément un par un, et l'exception StopIteration est levée lorsqu'il n'y a plus
d'éléments à itérer.
 Les objets intégrés de Python, tels que les listes, les tuples, les
dictionnaires et les chaînes, implémentent déjà le protocole itérable. Vous
pouvez créer des objets itérables et itérateurs personnalisés qui
fonctionnent de manière transparente avec les protocoles d'itération de
Python, ce qui vous permet de les utiliser avec des boucles for et d'autres
constructions liées à l'itérabilité. La compréhension et la mise en œuvre de
ces protocoles d'itération sont essentielles pour créer des classes d'itérables
et d'itérateurs efficaces et réutilisables en Python.
10.2. CRÉATION ET UTILISATION DE
GÉNÉRATEURS
Les générateurs en Python sont un type spécial d'itérable qui vous permet
de produire une séquence de valeurs à la volée. Ils constituent un moyen
efficace et peu gourmand en mémoire de générer de grands ensembles de
données ou des séquences infinies sans les stocker en mémoire en une seule
fois. Les générateurs utilisent une syntaxe spéciale et offrent un moyen
pratique de créer des itérateurs en utilisant des fonctions avec le mot-clé
yield.
Pour définir un générateur, vous créez une fonction qui contient une ou
plusieurs instructions yield. Lorsque la fonction est appelée, elle renvoie
un objet générateur. Chaque fois que la méthode next() du générateur est
appelée (implicitement ou explicitement), l'exécution de la fonction est
reprise à partir du point de la dernière instruction yield jusqu'à l'instruction
yield suivante. De cette manière, vous pouvez produire paresseusement
des valeurs sans avoir à calculer toute la séquence à l'avance.
Voyons comment créer et utiliser des générateurs en Python :
Création d'un générateur :
Pour créer un générateur, utilisez le mot-clé yield dans une fonction. La
fonction devient une fonction de générateur et son appel renvoie un objet
générateur.
def my_generator() :
rendement 1
rendement 2
rendement 3
# Créer un objet générateur
gen = my_generator()

Utilisation d'un générateur :

Les générateurs peuvent être utilisés de différentes manières, mais la
plus courante consiste à les utiliser dans une boucle for. La boucle appelle
automatiquement la méthode next() du générateur pour récupérer la valeur
suivante jusqu'à ce que le générateur soit épuisé (plus d'instruction yield).
# Utilisation du générateur dans
une boucle for for item in gen :
print(item)
# Sortie : 1, 2, 3
 Vous pouvez également appeler manuellement la méthode next() du
générateur pour obtenir la valeur suivante.
gen = mon_générateur()
print(next(gen)) # Sortie : 1
print(next(gen)) # Sortie : 2
print(next(gen)) # Sortie : 3
# Appeler next() à nouveau lèvera StopIteration puisque le générateur est épuisé.

Générateurs infinis :
L'un des aspects les plus puissants des générateurs est leur capacité à
créer des séquences infinies. Comme ils produisent des valeurs
paresseusement, vous pouvez créer un générateur qui ne se termine jamais,
ce qui peut être utile dans certains scénarios.
def infinite_generator() :
i=1
pendant que True :
rende
ment i
i += 1
gen = infinite_generator()
print(next(gen)) # Sortie : 1
print(next(gen)) # Sortie : 2
# Cela continuera à imprimer les valeurs suivantes indéfiniment jusqu'à ce que vous arrêtiez la boucle manuellement.

Expressions du générateur :
Outre la définition de fonctions génératrices, vous pouvez également
utiliser des expressions génératrices, dont la syntaxe est similaire à celle
des compréhensions de listes, mais avec des parenthèses à la place des
crochets. Les expressions de générateur sont plus efficaces en termes de
mémoire, car elles produisent des valeurs à la volée, sans créer de liste
complète.
# Expression du générateur
gen = (x ** 2 for x in range(10))
for item in gen :
print(item)
# Sortie : 0, 1, 4, 9, 16, 25, 36, 49, 64, 81

Les générateurs sont extrêmement utiles lorsqu'il s'agit de traiter de

grands ensembles de données ou de générer des valeurs à la volée, ce qui
permet d'économiser de la mémoire et d'améliorer les performances. Ils
sont particulièrement utiles dans les scénarios où il n'est pas nécessaire
d'accéder simultanément à l'ensemble de la séquence de valeurs. En
comprenant
et en utilisant efficacement les générateurs, vous pouvez optimiser votre
code Python et le rendre plus efficace.
11. Décorateurs :
11.1. DÉCORATEURS DE FONCTIONS

11.2. DÉCORATEURS DE CLASSE

 11.1. DÉCORATEURS DE FONCTIONS
Les décorateurs de fonctions en Python sont une fonctionnalité puissante et
flexible qui vous permet de modifier le comportement des fonctions en les
enveloppant d'une autre fonction. Les décorateurs permettent d'étendre les
fonctionnalités des fonctions sans modifier leur code, ce qui favorise la
réutilisation du code et facilite l'ajout de fonctionnalités communes à
plusieurs fonctions.
En Python, un décorateur est implémenté en utilisant le symbole "@"
suivi du nom de la fonction décoratrice. Lorsqu'une fonction est décorée,
elle est transmise en tant qu'argument à la fonction décoratrice, et cette
dernière renvoie une nouvelle fonction (ou un appelable) qui remplace la
fonction d'origine.
@decorator_function
def original_function()
:
# Mise en œuvre de la fonction

Définir la fonction décoratrice :

Une fonction décoratrice est une fonction ordinaire qui prend une autre
fonction comme argument. Elle effectue certaines actions avant ou après
avoir appelé la fonction d'origine et renvoie une nouvelle fonction qui
remplace la première. Le décorateur peut ajouter des fonctionnalités
supplémentaires, modifier le comportement de la fonction d'origine ou
effectuer des tâches telles que la journalisation, la mise en cache ou la
validation des entrées.
def my_decorator(original_function) :
def wrapper() :
# Code à exécuter avant que la fonction originale ne soit
appelée print("Quelque chose se passe avant que la fonction
ne soit appelée.") # Appeler la fonction originale
result = original_function()
# Code à exécuter après l'appel de la fonction originale
print("Quelque chose se passe après l'appel de la fonction.")
# Retourner le résultat de la fonction originale
retourner le résultat
# Retourne la fonction wrapper
return wrapper
Décorer la fonction d'origine :
Pour appliquer le décorateur à une fonction, utilisez le symbole "@"
suivi du nom de la fonction du décorateur directement au-dessus de la
définition de la fonction d'origine.
@my_decorator
def say_hello() :
print("Hello !")

Appeler la fonction décorée :

Lorsque vous appelez la fonction décorée, c'est en fait la fonction
wrapper() renvoyée par le décorateur qui est exécutée. La fonction
wrapper(), à son tour, appelle la fonction originale dans son propre flux
d'exécution.
say_hello()

#Sortie :
Il se passe quelque chose avant que la fonction ne soit
appelée. Bonjour !
Il se passe quelque chose après l'appel de la fonction.

Dans cet exemple, la fonction say_hello() est décorée avec la fonction

my_decorator. Lorsque la fonction say_hello() est appelée, elle invoque en
fait la fonction wrapper(), qui ajoute un comportement supplémentaire
avant et après l'appel à la fonction say_hello() d'origine.
Les décorateurs sont largement utilisés à des fins diverses, telles que :

Journalisation : Enregistrer les appels de fonction, leurs arguments et leurs résultats.

Mise en cache : pour mettre en cache les résultats d'une fonction afin
d'accélérer les appels ultérieurs avec les mêmes arguments.
Autorisation : Pour ajouter des contrôles d'authentification et
d'autorisation avant l'exécution d'une fonction.
Validation des entrées : Valider les arguments d'entrée d'une fonction
avant son exécution.
 Vous pouvez utiliser plusieurs décorateurs sur une seule fonction, et les
décorateurs peuvent eux-mêmes prendre des arguments, ce qui les rend très
flexibles et polyvalents en Python. Comprendre et utiliser les décorateurs
est une compétence clé pour écrire un code Python propre, maintenable et
extensible.
 11.2. DÉCORATEURS DE CLASSE
La programmation orientée objet (POO) est un paradigme puissant du
développement logiciel qui organise le code en classes et en objets,
favorisant ainsi la réutilisation et la maintenance du code. Python, qui est
un langage orienté objet, offre diverses fonctionnalités pour soutenir les
principes de la POO. Les décorateurs de classe sont un aspect fondamental
de Python qui permet aux programmeurs d'étendre le comportement des
classes, les rendant ainsi plus flexibles et dynamiques. Dans cette section,
nous allons nous plonger dans le monde des décorateurs de classe, en
explorant leur objectif, leur syntaxe et leurs applications pratiques.
Introduction aux décorateurs
Avant d'aborder les décorateurs de classe, présentons brièvement les
décorateurs en Python. Les décorateurs sont une fonctionnalité puissante
de Python qui permet aux fonctions (et aux méthodes) d'être modifiées ou
étendues par d'autres fonctions.
Ils suivent un concept simple : une fonction décoratrice enveloppe une
autre fonction, lui apportant des fonctionnalités supplémentaires sans
modifier directement son code source.
def add(a, b) :
return a + b
result = add(2, 3)
print(result) # Sortie : 5

Créons maintenant une fonction décoratrice qui imprime un message

avant et après l'appel à la fonction d'origine :
def decorator(func) :
def wrapper(*args, **kwargs) :
print("Avant l'exécution de la
fonction.") result = func(*args,
**kwargs) print("Après l'exécution de
la fonction.") return result
return wrapper
@decorator
def add(a, b) :
return a + b
result = add(2, 3)
print(result) # Output :
 # Avant l'exécution de la
fonction. # Après
l'exécution de la fonction. #
5

La syntaxe @decorator est un raccourci pour appliquer le décorateur à

la fonction add. Dans cet exemple, la fonction décorateur entoure la
fonction add, en ajoutant les instructions d'impression avant et après.
Présentation des décorateurs de classe
Les décorateurs de classe suivent un concept similaire à celui des
décorateurs de fonction, mais ils appliquent leur magie aux classes plutôt
qu'aux fonctions. Un décorateur de classe est une fonction qui prend une
classe en argument, étend ou modifie la classe et renvoie la classe mise à
jour.
En Python, la syntaxe pour appliquer un décorateur de classe est
similaire à celle des décorateurs de fonction, en utilisant la notation
@decorator directement au-dessus de la définition de la classe.
def decorator(cls) :
classe NewClass(cls) :
def new_method(self) :
print("Ceci est une nouvelle
méthode.") return NewClass
@decorator
classe OriginalClass :
def existing_method(self) :
print("Ceci est une méthode
existante.") obj = OriginalClass()
obj.existing_method() # Sortie : Il s'agit d'une méthode
existante. obj.new_method() # Sortie : Il s'agit d'une nouvelle
méthode.

Dans cet exemple, la fonction décorateur prend la classe OriginalClass

en argument, crée une nouvelle classe appelée NewClass, ajoute une
nouvelle méthode new_method et renvoie la classe mise à jour. La syntaxe
@decorator remplace alors OriginalClass par NewClass, améliorant ainsi la
fonctionnalité de la classe.
 CAS D'UTILISATION ET AVANTAGES DES
DÉCORATEURS DE CLASSE
Les décorateurs de classe offrent plusieurs avantages et cas d'utilisation, ce
qui en fait un outil précieux dans le développement Python. Voici quelques
avantages clés :
1. Réutilisation du code
Les décorateurs de classe permettent aux développeurs d'encapsuler des
fonctionnalités couramment utilisées et de les appliquer à plusieurs classes.
Cela favorise la réutilisation du code et réduit la nécessité de dupliquer le
code dans différentes classes.
2. Fonctionnalité des mixins
Un cas d'utilisation courant des décorateurs de classe est la mise en
œuvre d'une fonctionnalité de mixage. Les mixins sont un moyen d'ajouter
un ensemble spécifique de fonctionnalités à plusieurs classes sans utiliser
l'héritage. Ils permettent une meilleure organisation du code et évitent les
hiérarchies de classes profondes, qui peuvent être difficiles à maintenir.
classe JSONMixin :
def to_json(self) :
import json
return json.dumps(self. dict )
@JSONMixin
classe Personne :
def init ( self, name, age) :
self.name = name
self.age = age
person = Person("Alice", 30)
print(person.to_json())
# Output : {"name" : "Alice", "age" : 30}

Dans cet exemple, le décorateur de classe JSONMixin ajoute la

méthode to_json à la classe Personne, ce qui lui permet de convertir ses
attributs en chaîne JSON.
3. Ajout de propriétés et d'attributs
Les décorateurs de classe peuvent être utilisés pour ajouter
dynamiquement des propriétés et des attributs aux classes. Cela peut
s'avérer utile lorsque vous souhaitez étendre les propriétés et attributs d'une
classe.
sans modifier son code source ou en travaillant avec des bibliothèques
et des classes tierces.
4. Validation et traitement des erreurs
Vous pouvez créer des décorateurs de classe qui valident l'entrée des
méthodes de classe ou gèrent les exceptions de manière globale. La logique
de gestion des erreurs est ainsi centralisée, ce qui rend le code plus facile à
maintenir et à lire.
5. Profil de performance
Les décorateurs de classe peuvent être utilisés pour mesurer le temps d'exécution
des méthodes de la classe, ce qui permet d'identifier les goulets
d'étranglement en matière de performances et de les optimiser.
6. Mise en cache
Vous pouvez mettre en place des mécanismes de mise en cache en
utilisant des décorateurs de classe pour stocker les résultats de calculs
coûteux, ce qui permet d'économiser du temps et des ressources lorsque les
mêmes calculs sont demandés à nouveau.
 LA MISE EN ŒUVRE DE DÉCORATEURS DE
CLASSE
La création de décorateurs de classe en Python consiste à définir une
fonction de décorateur qui prend une classe en argument, renvoie une
classe mise à jour, puis applique le décorateur à l'aide de la syntaxe
@decorator. Voici un guide étape par étape pour mettre en œuvre un
décorateur de classe :
Étape 1 : Définition de la fonction décoratrice
Tout d'abord, définissez la fonction décoratrice qui prend la classe comme argument.
Le décorateur peut étendre la classe, ajouter de nouvelles méthodes,
modifier les méthodes existantes ou effectuer toute autre modification
souhaitée.
def decorator(cls) :
# Effectuer les modifications de la classe ici.
# Vous pouvez créer une nouvelle classe qui hérite de la classe
d'origine et lui ajouter de nouvelles méthodes, propriétés ou
attributs.
# Retourne la classe mise à
jour. return cls

Étape 2 : Appliquer le décorateur

Ensuite, appliquez le décorateur à une classe en utilisant la syntaxe
@decorator directement au-dessus de la définition de la classe. Cela
indique que la fonction du décorateur doit être appelée avec la classe
comme argument, et que le résultat doit remplacer la classe d'origine.
@decorator
classe OriginalClass :
# Les méthodes, propriétés et attributs de la classe vont ici.

Étape 3 : Tester la classe décorée

Enfin, créez des instances de la classe décorée et testez ses méthodes et
attributs pour vous assurer que le décorateur a fonctionné comme prévu.
obj = OriginalClass()
# Tester les méthodes et les propriétés de la classe ici.

Les décorateurs de classe en Python offrent un moyen puissant

d'améliorer la programmation orientée objet. En étendant les classes de
manière dynamique, les décorateurs de classe permettent la réutilisation du
code, la fonctionnalité de mixage, la validation, la gestion des erreurs et
bien d'autres choses encore. Avec une bonne compréhension des
décorateurs de classe, vous pouvez écrire
un code plus flexible et plus facile à maintenir, ce qui rend vos projets
Python plus efficaces et plus robustes.
 12. Travailler avec des dates et des heures :

Manipulation de la date et de l'heure (module datetime)

 MANIPULATION DE LA DATE ET
DE L'HEURE (MODULE
DATETIME)
La manipulation de la date et de l'heure est un aspect crucial de la
programmation, en particulier lorsqu'il s'agit de tâches qui impliquent la
planification, le suivi d'événements ou l'analyse de données sur des
intervalles de temps spécifiques. En Python, le module datetime fournit un
riche ensemble de fonctionnalités permettant de travailler avec des dates,
des heures et des timedeltas. Il simplifie les opérations sur les dates et les
heures, ce qui permet aux développeurs de gérer plus facilement les
différents aspects temporels de leurs applications. Dans cette section, nous
allons explorer le module datetime et ses fonctionnalités essentielles pour
la manipulation de la date et de l'heure en Python.
Importation du module datetime
Avant de nous plonger dans les fonctionnalités du module datetime,
commençons par l'importer dans notre script Python :
import datetime
Création d'objets de date et d'heure
Le module datetime propose plusieurs classes pour représenter les dates et les heures.
Les classes primaires sont les suivantes :

datetime.date : Représente une date (année, mois, jour).

datetime.time : Représente une heure de la journée (heure, minute,
seconde, microseconde).
datetime.datetime : Représente à la fois la date et l'heure (année, mois,
jour, heure, minute, seconde, microseconde).
datetime.timedelta : Représente la différence entre deux dates ou
heures.

Création d'objets date

Pour créer un objet date, vous pouvez utiliser le constructeur de la
classe datetime.date, en passant l'année, le mois et le jour comme
arguments :
# Création d'un objet date pour le 4 juillet
2023 date_obj = datetime.date(2023, 7, 4)
print(date_obj) # Sortie : 2023-07-04
 Création d'objets temporels
Pour les objets temporels, vous pouvez utiliser le constructeur de la
classe datetime.time, en passant l'heure, la minute, la seconde et la
microseconde comme arguments :
# Création d'un objet temporel pour
12:34:56.789 time_obj = datetime.time(12, 34,
56, 789000) print(time_obj) # Sortie :
12:34:56.789000

Création d'objets DateTime

Pour créer un objet datetime qui combine la date et l'heure, vous pouvez utiliser le
constructeur de la classe datetime.datetime :
# Création d'un objet datetime pour le 25 décembre 2023, à 09:15:30
datetime_obj = datetime.datetime(2023, 12, 25, 9, 15, 30)
print(datetime_obj) # Sortie : 2023-12-25 09:15:30

Date et heure actuelles

Le module datetime fournit également des fonctions permettant de
récupérer la date et l'heure actuelles à partir de l'horloge du système :
# Date actuelle
current_date = datetime.date.today()
print(current_date) # Sortie : La date du jour au format : YYYY-MM-DD
# Heure actuelle
current_time = datetime.datetime.now().time()
print(current_time) # Sortie : L'heure actuelle au format : HH:MM:SS.microsecondes
 FORMATAGE ET ANALYSE DES DATES ET
DES HEURES
La méthode strftime des objets datetime vous permet de formater les dates
et les heures en chaînes, tandis que la fonction strptime vous permet
d'analyser les chaînes en objets datetime.
Formatage des dates et des heures
# Formatage d'un objet datetime en tant que chaîne
personnalisée datetime_obj = datetime.datetime(2023, 9, 15,
18, 30, 45)
formatted_str = datetime_obj.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_str) # Output : "2023-09-15 18:30:45"

Analyse des dates et heures

# Parsing a string into a datetime object
date_str = "2023-09-15 18:30:45"
parsed_datetime = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(parsed_datetime) # Output : 2023-09-15 18:30:45

Arithmétique de la date et de l'heure

Le module datetime permet d'effectuer des opérations arithmétiques sur
des dates et des heures à l'aide d'objets timedelta.
Calcul des différences de temps (Timedeltas)
Vous pouvez calculer la différence entre deux dates ou deux heures à
l'aide de timedelta. Cette fonction est utile pour déterminer la durée entre
deux événements ou pour ajouter/soustraire des intervalles à des dates.
# Calcul de la différence de temps entre deux dates
date1 = datetime.date(2023, 8, 20)
date2 = datetime.date(2023, 9, 15)
time_difference = date2 - date1
print(time_difference.days)
# Sortie : 26 (nombre de jours entre les deux dates) #
Ajouter un timedelta à un objet datetime
datetime_obj = datetime.datetime(2023, 9, 15, 12, 0, 0)
time_delta = datetime.timedelta(hours=3, minutes=30)
new_datetime_obj = datetime_obj + time_delta
print(new_datetime_obj) # Output : 2023-09-15 15:30:00
 Prise en charge des fuseaux horaires
Le module datetime comprend également un support limité pour
travailler avec les fuseaux horaires grâce à la bibliothèque pytz. Cela vous
permet de gérer les objets datetime en fonction de différents fuseaux
horaires, en tenant compte de l'heure d'été et d'autres règles spécifiques au
fuseau horaire.
Pour utiliser pytz, vous devez l'installer séparément :
pip install pytz
Après avoir installé pytz, vous pouvez l'utiliser pour créer des objets
de type datetime tenant compte du fuseau horaire :
import pytz
# Création d'un objet datetime tenant compte du fuseau horaire
utc_datetime = datetime.datetime(2023, 9, 15, 12, 0, 0, tzinfo=pytz.UTC)
print(utc_datetime)
# Sortie : 2023-09-15 12:00:00+00:00
# Convertit une date-heure sensible au fuseau horaire en un
fuseau horaire différent local_timezone =
pytz.timezone("America/New_York") local_datetime =
utc_datetime.astimezone(local_timezone)
print(local_datetime)
# Output : 2023-09-15 08:00:00-04:00 (en tenant compte de l'heure d'été)

Le module datetime de Python fournit un ensemble complet d'outils

pour la manipulation de la date et de l'heure. En utilisant ses classes et ses
fonctions, les développeurs peuvent effectuer diverses opérations
temporelles, formater des dates et des heures, calculer des différences de
temps et même travailler avec des fuseaux horaires. Que vous construisiez
des applications web, des outils d'analyse de données ou des systèmes de
planification, le module datetime est un élément essentiel de la boîte à
outils de tout programmeur Python. Sa flexibilité et sa facilité d'utilisation
en font une ressource précieuse pour traiter efficacement les tâches liées à
la date et à l'heure.
13. Bibliothèque standard Python :

Exploration des modules couramment utilisés (os,

sys, math, random, etc.)
 EXPLORER LES MODULES COURAMMENT
UTILISÉS ( OS, SYS, MATH, RANDOM,
ETC.)
En Python, les modules sont des bibliothèques de code pré-écrites qui
fournissent un large éventail de fonctionnalités pour améliorer les capacités
du langage. Ces modules étendent les fonctionnalités de base de Python et
permettent aux développeurs d'effectuer diverses tâches de manière
efficace. Dans cette section, nous allons explorer certains modules
couramment utilisés en Python, notamment os, sys, math, random, et bien
d'autres encore, en mettant en évidence leurs principales fonctionnalités et
leurs cas d'utilisation.
1. Module os
Le module os fournit des fonctions permettant d'interagir avec le
système d'exploitation et de travailler avec des fichiers, des répertoires et
des variables d'environnement.
Fonctionnalités clés :

Opérations sur les fichiers et les répertoires : Le module os fournit des

fonctions telles que os.listdir(), os.path.exists(), os.path.join(),
os.mkdir() et os.remove() pour travailler avec des fichiers et des
répertoires.
Variables d'environnement : Vous pouvez accéder aux variables
d'environnement et les modifier à l'aide de os.environ.
Gestion des processus : Le module os comprend également des
fonctionnalités permettant d'interagir avec les processus, telles que
os.system() et os.spawn*().
import os
# Lister tous les fichiers et répertoires du répertoire
courant files = os.listdir(".")
print(files)
# Vérifier si un fichier existe
if os.path.exists("exemple.txt") :
print("Le fichier existe.")
d'autre part :
print("Le fichier n'existe pas.")
# Obtenir la valeur d'une variable d'environnement
print(os.environ.get("PATH"))

2. Module sys
 Le module sys fournit des fonctions et des variables permettant
d'interagir avec l'interpréteur Python et les fonctionnalités spécifiques au
système.
Fonctionnalités clés :

Arguments de la ligne de commande : Vous pouvez accéder aux

arguments de la ligne de commande transmis au script à l'aide du
fichier sys.argv.
Informations sur le système : Le module sys propose des variables
telles que sys.platform et sys.version pour obtenir des informations sur
le système et la version de Python, respectivement.
Flux standard : sys.stdin, sys.stdout et sys.stderr représentent les flux
standard d'entrée, de sortie et d'erreur, ce qui vous permet de les
rediriger si nécessaire.
import sys
# Accéder aux arguments de la
ligne de commande print("Nom du
script :", sys.argv[0])
print("Arguments :", sys.argv[1 :])
# Obtenir la version de Python
print("Python version :", sys.version)
# Rediriger stdout vers un fichier
with open("output.txt", "w") as f :
sys.stdout = f
print("Ceci sera écrit dans output.txt")
sys.stdout = sys. stdout # Réinitialise stdout à sa valeur par défaut

3. Module mathématique
Le module mathématique fournit des fonctions mathématiques et des
constantes permettant d'effectuer diverses opérations numériques.

Fonctionnalités clés :

Arithmétique de base : Le module mathématique propose des fonctions

telles que math.sqrt(), math.pow(), math.floor(), math.ceil() et
math.round() pour les calculs courants.
 les opérations arithmétiques.
Fonctions trigonométriques : Vous pouvez utiliser math.sin(),
math.cos(), math.tan(), math.degrees() et math.radians() pour les
calculs trigonométriques.
Constantes : math.pi et math.e représentent respectivement les
constantes mathématiques π (pi) et e.
import maths
# Calculer la racine carrée et la puissance
print("Square root :", math.sqrt(25))
print("2 à la puissance 3 :", math.pow(2, 3))
# Fonctions trigonométriques
print("Sinus de 30 degrés :", math.sin(math.radians(30))
print("Cosinus de 45 degrés :", math.cos(math.radians(45)))
# Constantes mathématiques
print("Valeur de π (pi) :", math.pi)
print("Valeur de e :", math.e)

4. Module aléatoire
Le module aléatoire vous permet de travailler avec des nombres
aléatoires et d'effectuer des sélections de manière aléatoire.
Fonctionnalités clés :

Génération de nombres aléatoires : Des fonctions telles que

random.random(), random.randint(), random.uniform() et
random.randrange() génèrent des nombres aléatoires dans des plages
spécifiées.
Faire des choix aléatoires : Vous pouvez sélectionner au hasard des
éléments dans des listes ou des séquences à l'aide de random.choice()
et mélanger des éléments à l'aide de random.shuffle().
import random
# Génère un flottant aléatoire entre 0 et 1
print("Random float :", random.random())
# Génère un entier aléatoire entre 1 et 10
print("Random integer :", random.randint(1, 10))
# Faire un choix aléatoire dans une liste
fruits = ["pomme", "banane", "orange", "raisin", "kiwi"]
print("Fruit aléatoire :", random.choice(fruits))
 # Mélange les éléments d'une liste
random.shuffle(fruits)
print("Shuffled fruits :", fruits)

Les modules os, sys, math, random et d'autres modules couramment

utilisés en Python offrent un large éventail de fonctionnalités permettant de
simplifier diverses tâches. En tirant parti de ces modules, les développeurs
peuvent travailler efficacement avec des fichiers, des répertoires, des
informations système, des calculs mathématiques et des nombres
aléatoires. La compréhension de ces modules et de leurs principales
caractéristiques est essentielle à la maîtrise de la programmation Python et
peut considérablement améliorer votre productivité en tant que
développeur.
Ajoutons quelques points supplémentaires sur chacun des modules
couramment utilisés :
1. os Module :

Navigation dans les répertoires : Le module os vous permet de

changer le répertoire de travail actuel en utilisant os.chdir() et
d'obtenir le répertoire de travail actuel avec os.getcwd().

Permissions de fichiers : Vous pouvez définir les droits d'accès aux

fichiers à l'aide de os.chmod() et vérifier les droits d'accès aux fichiers
à l'aide de os.access().

Fonctionnalité spécifique à la plate-forme : Le module os fournit des

fonctions telles que os.name et os.sep pour récupérer des informations
spécifiques à la plate-forme, telles que le nom du système
d'exploitation et le séparateur de chemin.

2. sys Module :

Sortie du système : La fonction sys.exit() vous permet de mettre fin à

l'interpréteur Python avec un statut de sortie optionnel.

Importation de modules : Vous pouvez manipuler le chemin de

recherche des modules à l'aide de sys.path, ce qui vous permet
d'ajouter des répertoires personnalisés pour l'importation de modules.
 Limite de récursivité : La fonction sys.setrecursionlimit() vous permet
de définir la profondeur de récursion maximale en Python afin d'éviter
les débordements de pile.

3. Module mathématique :

Fonctions trigonométriques inverses : Les fonctions math.acos(),

math.asin() et math.atan() permettent d'effectuer les calculs
trigonométriques inverses.

Fonctions logarithmiques : Les fonctions math.log(), math.log10() et

math.log2() permettent d'effectuer des calculs logarithmiques.

Fonctions d'arrondi : Les fonctions math.floor() et math.ceil()

permettent d'arrondir respectivement au plancher et au plafond, tandis
que math.trunc() tronque vers zéro.

4. Module aléatoire :

Graine aléatoire : vous pouvez définir une graine aléatoire à l'aide de

random.seed() afin de garantir la reproductibilité de la génération de
nombres aléatoires.

Échantillonnage aléatoire : La fonction random.sample() permet

d'échantillonner des éléments d'une séquence sans remplacement,
tandis que random.choices() échantillonne avec remplacement.

Distribution de probabilité : La fonction random.gauss() génère des

nombres aléatoires suivant une distribution gaussienne (normale).

5. datetime Module :

Formatage et analyse de la date : Outre strftime et strptime, le module

datetime propose également les méthodes date.fromisoformat() et
datetime.fromisoformat() pour analyser les chaînes formatées ISO en
objets date et datetime, respectivement.

Prise en compte des fuseaux horaires : En plus de pytz, Python 3.9 a

introduit le module zoneinfo, qui prend en charge les fuseaux
horaires sans nécessiter de bibliothèque tierce.
 Arithmétique de la date : Les objets date et datetime prennent en
charge les opérations arithmétiques telles que l'addition, la
soustraction et les comparaisons, ce qui vous permet de travailler
facilement avec des intervalles de temps.

6. Module de collecte :

Namedtuple : La fonction collections.namedtuple() crée des classes

simples avec des champs nommés, qui constituent des alternatives
efficaces en termes de mémoire aux classes normales.

Compteur : La classe collections.Counter() offre un moyen rapide et

efficace de compter les occurrences d'éléments dans une collection.

Defaultdict : La classe collections.defaultdict() est une sous-classe

du dict intégré qui renvoie une valeur par défaut lors de l'accès à une
clé inexistante.

7. json Module :

Sérialisation et désérialisation : Le module json vous permet de

convertir des objets Python en chaînes JSON (json.dumps()) et des
chaînes JSON en objets Python (json.loads()).

Sérialisation personnalisée : Vous pouvez mettre en œuvre une

sérialisation et une désérialisation personnalisées en utilisant les
classes json.JSONEncoder et json.JSONDecoder.

Traitement des fichiers : Le module json fournit des fonctions telles

que json.dump() et json.load() pour travailler directement avec des
fichiers JSON.

8. Module de temps :

Mesures du temps : Le module temps fournit des fonctions telles que

time.time() et time.perf_counter() pour mesurer les intervalles de
temps et les performances.
Le sommeil : Vous pouvez introduire des délais dans votre code en utilisant time.sleep().

Formatage de l'heure : La fonction time.strftime() permet de formater

l'heure sous forme de chaîne de caractères.

La compréhension et l'utilisation de ces modules couramment utilisés

en Python peuvent améliorer de manière significative votre productivité en
tant que développeur. Chaque module fournit un ensemble de
fonctionnalités puissantes qui simplifient diverses tâches, depuis les
opérations sur les fichiers et les interactions avec le système (os, sys)
jusqu'aux calculs mathématiques (math) et à la génération de nombres
aléatoires (random).
En outre, des modules tels que datetime, collections, json et time offrent
des fonctionnalités spécialisées pour gérer efficacement les dates, les
structures de données, la sérialisation JSON et les tâches liées au temps. En
tirant parti de ces modules, vous pouvez créer des applications Python
robustes, efficaces et riches en fonctionnalités.
14. Travailler avec des bases de données :
 14.1. SQL ( SQLITE)

14.2. CONNECTIVITÉ AVEC LES

BASES DE DONNÉES ( SQLITE 3 )
 14.1. SQL ( SQLITE)
SQL (Structured Query Language) est un langage spécifique utilisé pour
gérer et manipuler les bases de données relationnelles. Il fournit un moyen
standardisé d'interagir avec les bases de données, permettant aux
utilisateurs de créer, de mettre à jour et d'interroger des données de
manière structurée. SQLite est un système de gestion de bases de données
relationnelles (SGBDR) léger, sans serveur, autonome et intégré qui met
en œuvre SQL. Dans cette section, nous allons explorer SQL et son
implémentation dans SQLite, en discutant de ses caractéristiques clés, de la
manipulation des données et des opérations de base de données.
Introduction à SQL
SQL est largement utilisé pour la gestion des bases de données et
constitue l'épine dorsale des systèmes de bases de données relationnelles. Il
permet aux utilisateurs d'effectuer diverses opérations sur les bases de
données, telles que la création de tables, l'insertion de données,
l'interrogation de données, la mise à jour d'enregistrements et la suppression
de données. Le langage SQL utilise une syntaxe déclarative, ce qui signifie
que vous spécifiez ce que vous voulez réaliser et que le moteur de la base
de données détermine comment exécuter l'opération de manière efficace.
Les instructions SQL se classent généralement dans les catégories suivantes :

Langage de définition des données (DDL) : Utilisé pour définir la

structure et le schéma de la base de données. Les instructions DDL
courantes sont CREATE, ALTER, DROP et RENAME.

Langage de manipulation des données (DML) : Utilisé pour

manipuler les données dans la base de données. Les instructions
DML les plus courantes sont INSERT, SELECT, UPDATE et
DELETE.

Langage de contrôle des données (DCL) : Utilisé pour gérer l'accès

aux données. Les instructions DCL courantes sont GRANT,
REVOKE et DENY.

Langage de contrôle des transactions (TCL) : Utilisé pour gérer les

transactions dans la base de données. Les instructions TCL les plus
courantes sont COMMIT, ROLLBACK et SAVEPOINT.
Introduction à SQLite
 SQLite est un SGBDR populaire, léger et autonome, largement utilisé
dans diverses applications, notamment les applications mobiles, les
logiciels de bureau et les applications web. Il est sans serveur, ce qui
signifie qu'il ne nécessite pas de serveur de base de données distinct pour
fonctionner. Au lieu de cela, il stocke l'ensemble de la base de données dans
un seul fichier sur le disque, ce qui le rend facile à configurer et à gérer.
SQLite est écrit en C et est conçu pour être rapide, fiable et efficace.
Caractéristiques principales de SQLite :

Aucune configuration : SQLite ne nécessite aucune configuration ou

installation ; il est prêt à être utilisé dès sa sortie de l'emballage.

Multiplateforme : SQLite est multiplateforme et peut fonctionner sur

différents systèmes d'exploitation, notamment Windows, macOS,
Linux et des plateformes mobiles comme Android et iOS.

Propriétés ACID : SQLite supporte les propriétés ACID (Atomicité,

Cohérence, Isolation, Durabilité), garantissant l'intégrité et la fiabilité
des données.

Fichier de base de données unique : la base de données entière est

contenue dans un seul fichier, ce qui facilite son transfert et sa gestion.

Faible empreinte mémoire : SQLite est conçu pour être économe en

mémoire, ce qui le rend adapté aux systèmes embarqués et aux
environnements à ressources limitées.

Support complet de SQL : SQLite implémente un large sous-ensemble

de la norme SQL92, fournissant un ensemble riche de fonctionnalités
SQL.

Utiliser SQLite avec Python

Pour travailler avec SQLite en Python, vous devez utiliser le module
sqlite3, qui est préinstallé avec Python.
Connexion à une base de données
import sqlite3
# Se connecter à une base de données SQLite ou en créer une si
elle n'existe pas conn = sqlite3.connect("example.db")
 Création d'un tableau et insertion de données
# Créer un tableau
conn.execute('''CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER)''')
# Insérer les données dans le tableau
conn.execute("INSERT INTO users (name, age) VALUES ( ?, ?)", ("Nibe", 20)
conn.execute("INSERT INTO users (name, age) VALUES ( ?, ?)", ("Dita", 21))
# Commit changes
conn.commit()

Interroger les données

# Interroger les données du tableau
cursor = conn.execute("SELECT * FROM users WHERE age > ?", (25,))
rows = cursor.fetchall()
pour row dans rows :
print(f "ID : {row[0]}, Name : {row[1]}, Age : {row[2]}")

Mise à jour et suppression des données

# Mise à jour des données
conn.execute("UPDATE users SET age = ? WHERE name = ?", (26, "Dita"))
conn.commit()
# Effacer les données
conn.execute("DELETE FROM users WHERE name = ?", ("Nibe",))
conn.commit()

Fermeture de la connexion
# Fermer la connexion
conn.close()

SQL (Structured Query Language) est un langage puissant pour la

gestion des bases de données relationnelles, permettant aux utilisateurs
d'effectuer diverses opérations sur les données de manière structurée et
efficace. SQLite, en tant que SGBDR léger et sans serveur, constitue un
excellent choix pour les applications de petite et moyenne envergure, car il
offre un support multiplateforme et une intégration facile avec Python. En
utilisant le module sqlite3 dans Python, les développeurs peuvent travailler
sans effort avec les bases de données SQLite et construire des applications
robustes et axées sur les données.
 14.2. CONNECTIVITÉ AVEC LES
BASES DE DONNÉES (
SQLITE 3 )
La connectivité des bases de données fait référence au processus
d'établissement d'une connexion entre un langage de programmation (tel
que Python) et un système de gestion de base de données (SGBD) tel que
SQLite. Cela permet au langage de programmation d'interagir avec la base
de données, d'effectuer diverses opérations (par exemple, interroger,
insérer, mettre à jour et supprimer des données) et de récupérer les résultats
de la base de données.
Dans cette section, nous allons explorer la connectivité des bases de
données en utilisant SQLite3 en Python. SQLite3 est un système de gestion
de base de données relationnelle léger, sans serveur et autonome qui est
fourni avec la bibliothèque standard de Python, ce qui facilite le travail
avec les bases de données sans nécessiter d'installations externes.
Établissement de la connexion à la base de données
Pour se connecter à une base de données SQLite avec Python, il faut
utiliser le module sqlite3, qui est préinstallé avec Python. La classe
principale de ce module est sqlite3.Connection, qui représente la connexion
à la base de données.
import sqlite3
# Se connecter à une base de données SQLite ou en créer une si
elle n'existe pas conn = sqlite3.connect("example.db")

Dans cet exemple, nous nous connectons à une base de données SQLite
nommée "exemple.db". Si la base de données n'existe pas, SQLite la crée
automatiquement.
Création d'un tableau et insertion de données
Une fois la connexion établie, vous pouvez interagir avec la base de
données en créant des tables et en insérant des données.
# Créer un tableau
conn.execute('''CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER)''')
 # Insérer les données dans le tableau
conn.execute("INSERT INTO users (name, age) VALUES ( ?, ?)", ("Alice", 30))
conn.execute("INSERT INTO users (name, age) VALUES ( ?, ?)", ("Bob", 25)) #
Commit changes
conn.commit()

Dans cet exemple, nous créons une table nommée "users" avec les
colonnes "id", "name" et "age". Nous insérons ensuite deux lignes de
données dans la table en utilisant des requêtes paramétrées pour éviter
les injections SQL.
Interroger les données
Pour extraire des données de la base de données, vous pouvez utiliser
des requêtes SQL. La méthode execute() permet d'exécuter les commandes
SQL et la méthode fetchall() permet de récupérer les résultats.
# Interroger les données du tableau
cursor = conn.execute("SELECT * FROM users WHERE age > ?", (25,))
rows = cursor.fetchall()
pour row dans rows :
print(f "ID : {row[0]}, Name : {row[1]}, Age : {row[2]}")

Dans cet exemple, nous exécutons une requête SELECT pour extraire
les utilisateurs dont l'âge est supérieur à 25, puis nous imprimons les
résultats.
Mise à jour et suppression des données
Pour mettre à jour ou supprimer des données dans la base de données,
vous pouvez utiliser la méthode execute() avec les requêtes UPDATE ou
DELETE appropriées.
# Mise à jour des données
conn.execute("UPDATE users SET age = ? WHERE name = ?", (26, "Alice"))
conn.commit()
# Effacer les données
conn.execute("DELETE FROM users WHERE name = ?", ("Bob",))
conn.commit()

Dans cet exemple, nous mettons à jour l'âge d'Alice (26 ans), puis nous
supprimons l'enregistrement de Bob dans la table "utilisateurs".
Fermeture de la connexion
Une fois les opérations sur la base de données terminées, il est essentiel
de fermer la connexion à la base de données.
# Fermer la connexion
 conn.close()

La fermeture de la connexion garantit que toutes les modifications

apportées à la base de données sont validées et que les ressources sont
libérées.
La connectivité de base de données avec SQLite3 en Python vous
permet d'interagir avec les bases de données SQLite, de créer des tables,
d'insérer, de mettre à jour et de supprimer des données, et de récupérer les
résultats des requêtes. La légèreté de SQLite et son intégration avec Python
en font un excellent choix pour les applications de petite et moyenne taille
qui ne nécessitent pas de serveur de base de données complet. Avec le
module sqlite3, vous pouvez facilement effectuer diverses opérations de
base de données dans vos projets Python et construire des applications
robustes et axées sur les données.
 15. Expressions régulières :

Correspondance de motifs et manipulation de texte (re module)

 RECHERCHE DE MOTIFS ET
MANIPULATION DE TEXTES ( RE
MODULE)
La recherche de motifs et la manipulation de texte sont des tâches
essentielles en programmation, qui permettent aux développeurs de
rechercher des motifs spécifiques dans un texte et d'effectuer diverses
opérations sur la base de ces motifs. Le module re de Python offre de
puissantes fonctionnalités pour la recherche de motifs et la manipulation de
texte à l'aide d'expressions régulières. Les expressions régulières (regex)
sont des séquences de caractères qui définissent un modèle de recherche,
vous permettant d'effectuer des opérations textuelles complexes de manière
efficace.
Dans cette section, nous allons explorer le module re de Python et ses
principales fonctions de recherche de motifs et de manipulation de texte.
Importation du module re
Avant d'utiliser le module re, vous devez l'importer dans votre script
Python :
importer re
 L'APPARIEMENT DE MOTIFS DE BASE
Le module re propose plusieurs fonctions permettant de travailler avec des
expressions régulières. Commençons par quelques exemples basiques de
recherche de motifs :
1. re.match()
La fonction re.match() recherche le motif au début de la chaîne et
renvoie un objet match si le motif est trouvé.
pattern = r "Hello"
text = "Hello, World
!"
match = re.match(pattern, text)
if match :
print("Motif trouvé :", match.group())
else :
print("Motif non trouvé")

2. re.search()
La fonction re.search() recherche le motif dans l'ensemble de la chaîne
et renvoie la première correspondance trouvée.
pattern = r "World"
text = "Hello, World
!"
match = re.search(pattern, text)
if match :
print("Motif trouvé :", match.group())
else :
print("Motif non trouvé")

3. re.findall()
La fonction re.findall() renvoie toutes les occurrences du motif sous la
forme d'une liste de chaînes de caractères.
modèle = r"\d+"
text = "Le prix est de 100 $ et 50 $"
matches = re.findall(pattern, text)
print("Matches :", matches)
 Modèles d'expressions régulières
Les expressions régulières permettent de définir des motifs complexes à
l'aide de caractères spéciaux et de métacaractères. Les métacaractères les
plus couramment utilisés sont les suivants :

... : correspond à tout caractère à l'exception d'une nouvelle ligne.

* : Correspond à zéro ou plusieurs occurrences du caractère
précédent. + : Recherche une ou plusieurs occurrences du
caractère précédent. ? : Correspond à zéro ou une occurrence du
caractère précédent.
^ : Correspond au début d'une chaîne
de caractères. $ : Recherche la fin
d'une chaîne de caractères.
[ ] : Correspond à n'importe quel caractère situé à l'intérieur des crochets.
[^ ] : recherche tout caractère qui ne se trouve pas entre les
crochets. ( ) : Regroupe les expressions.
 MANIPULATION DE TEXTE AVEC RE
Le module re fournit également des fonctions de manipulation de texte à
l'aide d'expressions régulières.
1. re.sub()
La fonction re.sub() permet de remplacer les occurrences d'un motif
par une chaîne de caractères spécifiée.
modèle = r"\d+"
text = "Le prix est de 100 $ et 50 $"
new_text = re.sub(pattern, "X", text)
print("Texte modifié :", new_text)

2. re.split()
La fonction re.split() divise une chaîne de caractères par les
occurrences d'un motif et renvoie une liste de sous-chaînes.
modèle = r"\s+"
text = "Hello World Python"
words = re.split(pattern, text)
print("Words :", words)
 DRAPEAUX EN R
Le module re prend également en charge les drapeaux qui modifient le
comportement des fonctions d'expression régulière.
1. re.IGNORECASE ou re.I
Cet indicateur permet d'activer la correspondance sans tenir compte des majuscules
et des minuscules.
motif = r "hello"
text = "Hello, World !"
match = re.search(pattern, text, re.IGNORECASE)
if match :
print("Motif trouvé :", match.group())
else :
print("Motif non trouvé")

2. re.MULTILINE ou re.M
Cet indicateur permet d'activer la concordance entre plusieurs lignes.
motif = r"^Bonjour"
text = "Hello, World!\NHello, Python !"
matches = re.findall(pattern, text, re.MULTILINE)
print("Matches :", matches)

Le module re de Python est un outil puissant pour la recherche de motifs et

la manipulation de texte à l'aide d'expressions régulières. Il vous permet de
rechercher des motifs spécifiques, d'extraire des données d'un texte et
d'effectuer diverses opérations textuelles de manière efficace. En maîtrisant
les expressions régulières et en comprenant les fonctions fournies par le
module re, vous pouvez traiter efficacement des tâches complexes de
traitement de texte en Python.
16. Débogage et test :
 16.1. TECHNIQUES ET OUTILS DE
DÉBOGAGE ( PDB)

16.2. TESTS UNITAIRES (MODULE UNITTEST)

 16.1. TECHNIQUES ET OUTILS DE
DÉBOGAGE ( PDB)
Le débogage est un aspect crucial du développement logiciel qui consiste à
identifier et à corriger les erreurs ou les problèmes d'un programme. Python
propose plusieurs techniques et outils de débogage pour aider les
développeurs à diagnostiquer et à résoudre les problèmes de manière
efficace. L'un des outils de débogage les plus couramment utilisés en
Python est le débogueur Python (pdb), qui est un débogueur interactif
intégré. Dans cette section, nous allons explorer les techniques de débogage
et la manière d'utiliser pdb pour déboguer les programmes Python.
 TECHNIQUES DE DÉBOGAGE
1. Imprimer les déclarations
Les instructions d'impression constituent l'une des techniques de
débogage les plus simples et les plus anciennes. Vous pouvez insérer des
instructions d'impression dans votre code pour afficher les valeurs des
variables et le flux d'exécution à des points spécifiques.
def calculate_sum(a, b) :
print("Entering calculate_sum function")
print(f "a : {a}, b : {b}")
résultat = a + b
print("Exiting calculate_sum function")
return result

2. Enregistrement
La journalisation est une technique de débogage plus sophistiquée qui
consiste à utiliser le module de journalisation pour enregistrer des messages
à différents niveaux (par exemple, DEBUG, INFO, WARNING, ERROR)
afin d'analyser le comportement du programme.
import logging
logging.basicConfig(level=logging.DEBUG)
def calculate_sum(a, b) :
logging.debug("Entering calculate_sum function")
logging.debug(f "a : {a}, b : {b}")
résultat = a + b
logging.debug("Exiting calculate_sum function")
return result

3. Affirmation
Les assertions sont utilisées pour vérifier si une condition est vraie à un
moment précis du programme. Si la condition est fausse, une erreur
d'assertion (AssertionError) est levée, indiquant un problème dans le code.
def divide(a, b) :
assert b != 0, "La division par zéro n'est pas
autorisée" return a / b
 UTILISATION DE PDB POUR LE DÉBOGAGE
Le débogueur intégré à Python, pdb, fournit un environnement de débogage
interactif qui vous permet de parcourir votre code, d'inspecter les variables
et d'analyser le déroulement du programme. Voici comment utiliser pdb :
1. Importation de pdb
importer pdb
2. Définition des points d'arrêt
Vous pouvez placer des points d'arrêt dans votre code à l'aide de la
fonction pdb.set_trace(). Lorsque l'interpréteur atteint ce point, il
interrompt l'exécution et l'invite interactive pdb est activée.
def calculate_sum(a, b) :
result = a + b
pdb.set_trace()
return result

3. Exécution du débogueur
Vous pouvez exécuter votre script avec l'option -m pdb, ou utiliser la
fonction pdb.run() pour lancer le débogueur.

Bash :

python -m pdb your_script.py

Python :

import pdb
def main() :
# Votre code ici
si nom == " main " :
pdb.run("main()")

4. Commandes Pdb
 Une fois le débogueur activé, vous pouvez utiliser diverses commandes
pdb pour interagir avec le programme :

n ou next : Exécute la ligne de code

actuelle. s ou step : Passer à un appel de
fonction.
c ou continue : Poursuit l'exécution jusqu'au prochain point d'arrêt ou
jusqu'à la fin du programme.
l ou list : Affiche le code source autour de la ligne
courante. p ou print : Affiche la valeur d'une variable.
b ou break : Définit un point d'arrêt à un numéro de
ligne spécifique. q ou quit : Quitte le débogueur et le
programme.

5. Quitter le débogueur
Pour quitter le débogueur, utilisez la commande q ou quit. Si vous
souhaitez poursuivre l'exécution sans déboguer, utilisez la commande c ou
continue jusqu'à la fin du programme ou jusqu'au prochain point d'arrêt.
Le débogage est une compétence essentielle pour tout programmeur. En
utilisant des techniques telles que les instructions d'impression, la
journalisation et les assertions, vous pouvez obtenir des informations sur le
comportement de votre programme et identifier les problèmes potentiels. Le
débogueur interactif pdb de Python constitue un outil puissant pour
parcourir le code, inspecter les variables et analyser le déroulement du
programme. En maîtrisant les techniques de débogage et en utilisant des
outils tels que pdb, vous pouvez diagnostiquer et résoudre efficacement les
problèmes de vos programmes Python, ce qui vous permettra d'obtenir des
logiciels plus robustes et plus fiables. Bon débogage !
 16.2. TESTS UNITAIRES (MODULE UNITTEST)
Les tests unitaires sont une technique de test de logiciels qui consiste à
tester des unités ou des composants individuels d'un programme de manière
isolée afin de s'assurer qu'ils fonctionnent comme prévu. Le module
unittest de Python est un cadre de test intégré qui fournit des outils pour
écrire et exécuter des tests unitaires. Il permet aux développeurs de définir
des cas de test, d'exécuter des tests et de découvrir et d'exécuter
automatiquement des méthodes de test.
Dans cette section, nous allons explorer le module unittest de Python et
apprendre à écrire et à exécuter des tests unitaires pour le code Python.
Création de cas de test
Un cas de test dans le module unittest est une sous-classe de
unittest.TestCase qui contient une ou plusieurs méthodes de test. Chaque
méthode de test doit tester un aspect spécifique du code testé. Les noms des
méthodes de test doivent commencer par le mot "test" pour être reconnus
comme des cas de test.

Python :

import unittest
def add(a, b) :
retour a + b
class TestAddFunction(unittest.TestCase) :
def test_add_positive_numbers(self) :
result = add(3, 5)
self.assertEqual(result, 8)
def test_add_negative_numbers(self) :
result = add(-2, -3)
self.assertEqual(result, -5)
def test_add_zero(self) :
result = add(10, 0)
self.assertEqual(result, 10)
if name == ' main ' :
unittest.main()

Dans cet exemple, nous définissons un cas de test TestAddFunction qui

contient trois méthodes de test, chacune testant un scénario différent pour
la fonction d'ajout.
 Exécution des tests unitaires
Pour exécuter les tests unitaires définis dans un module, vous pouvez
utiliser le programme d'exécution de tests unittest. Si votre scénario de test
est défini dans un fichier nommé test_module.py, vous pouvez exécuter les
tests à partir de la ligne de commande en utilisant :

Bash :

python -m unittest test_module.py

Le programme d'exécution des tests découvrira automatiquement les
cas et les méthodes de test et les exécutera.
Assertions
Le module unittest fournit plusieurs méthodes d'assertion pour vérifier
le comportement attendu du code testé. Les assertions les plus couramment
utilisées sont les suivantes :

assertEqual(a, b) : Vérifie si a et b sont égaux.

assertNotEqual(a, b) : Vérifie si a et b ne sont pas
égaux. assertTrue(expr) : Vérifie si expr est vrai.
assertFalse(expr) : Vérifie si expr est faux.
assertIs(a, b) : Vérifie si a est le même objet que b.
assertIsNot(a, b) : Vérifie si a n'est pas le même objet
que b. assertIsNone(expr) : Vérifie si expr est None.
assertIsNotNone(expr) : Vérifie si expr n'est pas
None. assertIn(a, b) : Vérifie si a est dans b.
assertNotIn(a, b) : Vérifie si a n'est pas dans b.
assertRaises(exception, callable, *args, **kwargs) : Vérifie si l'appel à
callable avec args et kwargs lève une exception de type exception

Découverte du test
Le module unittest peut découvrir et exécuter automatiquement tous les
cas de test définis dans plusieurs fichiers d'un répertoire. Pour ce faire, vous
pouvez lancer la découverte des tests à partir de la ligne de commande :

Bash :
 python -m unittest discover directory
Le programme de test recherchera tous les fichiers nommés test*.py
dans le répertoire spécifié et exécutera tous les tests trouvés.
Dispositifs d'essai
Les montages de test sont des actions de configuration et de
démontage qui sont effectuées avant et après l'exécution de chaque
méthode de test. Le module unittest fournit des méthodes setUp() et
tearDown() dans un scénario de test pour définir les supports de test.

Python :

import unittest
class TestMathOperations(unittest.TestCase) :
def setUp(self) :
# Effectuer les actions de configuration ici (par exemple,
initialiser les ressources) pass
def tearDown(self) :
# Effectuer les actions de démantèlement ici (par exemple,
libérer les ressources) pass
def test_addition(self) :
# Tester l'opération d'addition ici
pass
def test_subtraction(self) :
# Tester l'opération de soustraction
ici pass
si nom == ' main ' :
unittest.main()

La méthode setUp() est appelée avant chaque méthode de test et la

méthode tearDown() est appelée après chaque méthode de test.
Le module unittest de Python fournit un cadre de test puissant pour
l'écriture et l'exécution de tests unitaires. En créant des cas de test avec des
méthodes de test et en utilisant des assertions pour vérifier le comportement
attendu, les développeurs peuvent s'assurer que leur code fonctionne
comme prévu et identifier les problèmes potentiels. En outre, la découverte
des tests et les montages dans unittest facilitent l'organisation et la gestion
des tests pour les projets de plus grande envergure. L'adoption de pratiques
de tests unitaires peut conduire à un code Python plus robuste, plus fiable et
plus facile à maintenir. Bon test !
 17. Optimisation des performances :

Profilage et optimisation du code (timeit, cProfile)

 PROFILAGE ET OPTIMISATION DU
CODE ( TIMEIT, CPROFILE)
Le profilage et l'optimisation du code sont des étapes cruciales dans le
développement de logiciels afin de s'assurer que les programmes
s'exécutent efficacement et répondent aux exigences de performance.
Python fournit des modules intégrés tels que timeit et cProfile qui aident les
développeurs à établir le profil du temps d'exécution du code et à identifier
les goulets d'étranglement en matière de performances. Dans cet article,
nous allons explorer ces modules et apprendre à les utiliser pour profiler et
optimiser efficacement le code Python.
Profilage avec timeit
Le module timeit est utilisé pour mesurer le temps d'exécution de petits
bouts de code. Il est particulièrement utile pour comparer les performances
de différentes implémentations ou approches.
Chronométrage d'une fonction
Pour chronométrer une fonction ou un extrait de code spécifique, vous
pouvez utiliser la fonction timeit.timeit().

Python :

import timeit
def factorial_recursive(n) :
si n <= 1 :
retour 1
return n * factorial_recursive(n - 1)
time_taken = timeit.timeit("factorial_recursive(10)", globals=globals(), number=10000)
average_time = time_taken / 10000
print("Temps moyen :", average_time, "seconds")

Dans cet exemple, nous mesurons le temps d'exécution moyen de la

fonction factorial_recursive pour calculer la factorielle de 10 sur 10 000
itérations.
Timing Fonctions multiples
Vous pouvez également chronométrer plusieurs fonctions ou extraits de
code à l'aide de la classe timeit.Timer.
 Python :

import timeit
def factorial_iterative(n) :
résultat = 1
for i in range(1, n + 1) :
résultat *= i
retour résultat
t = timeit.Timer("factorial_recursive(10)", globals=globals())
time_recursive = t.timeit(number=10000)
t = timeit.Timer("factorial_iterative(10)", globals=globals())
time_iterative = t.timeit(number=10000)
print("Average time for recursive :", time_recursive / 10000, "seconds")
print("Average time for iterative :", time_iterative / 10000, "seconds")
Dans cet exemple, nous comparons les temps d'exécution moyens des
fonctions factorielle_récursive et factorielle_itérative.
Profilage avec cProfile
Le module cProfile fournit un profileur déterministe qui enregistre le
temps passé dans chaque appel de fonction d'un programme. Il permet
d'identifier les fonctions qui consomment le plus de temps, ce qui permet
aux développeurs de se concentrer sur l'optimisation des parties critiques
du code.
Exécuter cProfile à partir de la ligne de commande
Pour profiler un script Python à l'aide de cProfile à partir de la ligne de
commande, vous pouvez utiliser la commande suivante :

Bash :

python -m cProfile script.py

La sortie affichera le nombre d'appels, le temps total et le temps par
appel pour chaque fonction du script.
Exécuter cProfile par programme
Vous pouvez également utiliser cProfile de manière programmatique dans votre code
Python.

Python :
 import cProfil
def fibonacci_recursive(n) :
si n <= 1 :
retourner n
return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
cProfile.run("fibonacci_recursive(30)")

La sortie affichera les informations de profilage pour la fonction

fibonacci_recursive.
Analyse des résultats de cProfile avec pstats
Le module pstats vous permet d'analyser de manière interactive les
résultats de profilage générés par cProfile. Vous pouvez trier et afficher les
données de profilage pour trouver les goulots d'étranglement.

Python :

import cProfile
import pstats
def fibonacci_recursive(n) :
si n <= 1 :
retourner n
return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
cProfile.run("fibonacci_recursive(30)", "profile_stats")
p = pstats.Stats("profile_stats")
p.sort_stats("time").print_stats()

Dans cet exemple, nous enregistrons les résultats du profilage dans un

fichier nommé "profile_stats", puis nous utilisons pstats pour trier et
afficher les résultats en fonction du temps passé dans chaque appel de
fonction.
Techniques d'optimisation
Après avoir profilé votre code et identifié les goulets d'étranglement,
vous pouvez appliquer diverses techniques d'optimisation pour améliorer
son efficacité. Les techniques d'optimisation les plus courantes sont les
suivantes

Mémoïsation : Mise en cache des résultats intermédiaires pour éviter

les calculs redondants.
 Optimisation des algorithmes : Identification et mise en œuvre
d'algorithmes plus efficaces pour des tâches spécifiques.
Éviter les calculs inutiles : Éliminer les boucles ou les calculs inutiles.
Utilisation des fonctions intégrées : Exploiter les fonctions et les
bibliothèques Python intégrées pour optimiser les opérations.

Le profilage et l'optimisation du code sont des étapes essentielles dans

le développement de logiciels afin de garantir que les programmes
s'exécutent efficacement et répondent aux exigences de performance.
Python fournit des modules intégrés tels que timeit et cProfile qui aident les
développeurs à établir le profil du temps d'exécution du code et à identifier
les goulets d'étranglement en matière de performances. En utilisant ces
outils et en appliquant des techniques d'optimisation, les développeurs
peuvent améliorer les performances de leur code Python et fournir des
applications plus rapides et plus efficaces. Bon profilage et bonne
optimisation !
 18. Environnements virtuels et gestion
des paquets :
 18.1. CRÉATION ET GESTION
D'ENVIRONNEMENTS VIRTUELS ( VENV,
CONDA)

18.2. L'INSTALLATION ET LA
GESTION DES PAQUETS ( PIP)
18.1. CRÉATION ET GESTION
D'ENVIRONNEMENTS VIRTUELS (
VENV, CONDA)
La création et la gestion d'environnements virtuels en Python, à l'aide
d'outils tels que venv et conda, est un aspect crucial du développement
moderne en Python. Les environnements virtuels permettent aux
développeurs d'isoler les dépendances de leurs projets, en veillant à ce que
différents projets puissent disposer de leur propre ensemble de
bibliothèques sans conflit. Cette pratique favorise la reproductibilité et la
portabilité, et simplifie la gestion des dépendances, ce qui facilite le partage
du code avec d'autres.
Introduction aux environnements virtuels :
Python, langage de programmation populaire et polyvalent, dispose d'un
vaste écosystème de bibliothèques et de paquets que les développeurs
peuvent utiliser dans leurs projets. Cependant, l'inconvénient de cette
abondance est le risque de conflits entre les dépendances. Différents projets
peuvent nécessiter différentes versions d'une même bibliothèque, ce qui
peut entraîner des problèmes tels que des conflits de versions ou des
comportements involontaires. Pour résoudre ce problème, les
environnements virtuels ont été introduits.
Un environnement virtuel est un répertoire autonome qui contient un
interpréteur Python spécifique et un ensemble de paquets installés pour un
projet particulier.
Lorsqu'il est activé, l'environnement virtuel devient l'environnement
Python principal pour le projet, l'isolant ainsi de l'environnement Python
général.
Le système intégré de Python Venv :
Python dispose d'un module intégré appelé venv, qui permet aux
utilisateurs de créer des environnements virtuels légers. Pour créer un
environnement virtuel à l'aide de venv, vous pouvez exécuter la commande
suivante dans votre terminal ou votre invite de commande :
python -m venv myenv
Cette commande crée un nouveau répertoire nommé myenv, contenant
une copie de l'interpréteur Python et de la bibliothèque standard. De plus,
elle inclut un exécutable pip qui peut être utilisé pour installer des paquets
spécifiques à cet environnement virtuel.
 Pour activer l'environnement virtuel, vous utilisez la commande
appropriée pour votre système d'exploitation :
Sous Windows :
myenv\Scripts\activate

Sur macOS et Linux :

source myenv/bin/activate
Après l'activation, tous les paquets que vous installez à l'aide de pip
seront placés dans l'environnement virtuel, les séparant ainsi de
l'environnement Python global.
Gestion des paquets avec pip :
Une fois l'environnement virtuel activé, vous pouvez installer des
paquets comme d'habitude à l'aide de pip. Les paquets seront installés
localement dans le répertoire de l'environnement virtuel.
Par exemple, pour installer les requêtes de la bibliothèque populaire
dans l'environnement virtuel, vous devez exécuter le programme :
pip install requests
Cela garantit que la bibliothèque de requêtes n'est disponible que dans
l'environnement virtuel et qu'elle n'interfère pas avec d'autres projets ou
avec l'installation de Python sur l'ensemble du système.
Désactivation et suppression des environnements virtuels :
Lorsque vous avez fini de travailler dans un environnement virtuel,
vous pouvez le désactiver à l'aide de la commande de désactivation :
désactiver
Cela vous ramènera à l'environnement Python du système.
Si vous souhaitez supprimer entièrement l'environnement virtuel,
supprimez simplement son répertoire à l'aide de la commande appropriée
pour votre système d'exploitation :
Sous Windows :
rmdir /s /q myenv
 Sur macOS et Linux :
rm -rf myenv

Conda : un gestionnaire de paquets et d'environnement alternatif :

Alors que venv est suffisant pour créer des environnements virtuels
simples, il est limité lorsqu'il s'agit de bibliothèques scientifiques
complexes et orientées données qui ont des dépendances compilées. Conda
est un gestionnaire de paquets et d'environnements open-source qui répond
à ces limitations. Il a été initialement conçu pour gérer les paquets dans le
contexte de la science des données et de l'informatique scientifique, mais il
a depuis gagné en popularité et est largement utilisé pour le développement
général de Python.
Pour créer un nouvel environnement conda, vous utilisez la commande
suivante : conda create-name myenv
Cela créera un nouvel environnement nommé myenv qui contient un
interpréteur Python et des paquets de base. Pour activer l'environnement,
vous utilisez :
conda activate myenv
Conda vous permet d'installer des paquets à partir du dépôt Anaconda
ou de l'écosystème Python au sens large en utilisant la commande conda.
En voici un exemple :
conda install numpy
Vous pouvez également utiliser pip dans un environnement conda pour
installer des paquets qui ne sont pas disponibles dans les dépôts conda :
pip install requests

La caractéristique principale de Conda est sa capacité à gérer les

dépendances et à résoudre les conflits de paquets automatiquement. Il
peut gérer à la fois les paquets Python et les bibliothèques non Python, ce
qui le rend idéal pour l'informatique scientifique où les projets ont
souvent des dépendances complexes au-delà de l'écosystème Python.
 Gestion des environnements avec Conda :
Conda vous permet de gérer non seulement les paquets, mais aussi les
environnements entiers, y compris l'exportation et l'importation
d'environnements sur différents systèmes. Il est ainsi plus facile de
répliquer l'environnement de développement sur plusieurs machines.
Pour exporter l'environnement vers un fichier YAML :
conda env export > environment.yml
Pour créer un environnement à partir du fichier YAML sur un
autre système : conda env create -f environment.yml
Cela est particulièrement utile lorsque vous collaborez avec d'autres
personnes sur un projet ou que vous le déployez sur un autre serveur.
La création et la gestion d'environnements virtuels en Python, que ce
soit à l'aide de l'outil intégré venv ou du puissant conda, est une bonne
pratique pour le développement moderne en Python. Elle permet de
s'assurer que chaque projet dispose d'un environnement isolé, ce qui évite
les conflits de dépendances et facilite la reproductibilité. Que vous
travailliez sur de simples scripts ou sur des applications scientifiques
complexes, l'utilisation d'environnements virtuels contribue à
l'organisation, à la maintenance et à la portabilité de vos projets Python.
 18.2. L'INSTALLATION ET LA
GESTION DES PAQUETS (
PIP)
L'installation et la gestion de paquets à l'aide de pip est une compétence
essentielle pour tout développeur Python. pip est le gestionnaire de paquets
par défaut pour Python, et il vous permet d'installer, de mettre à niveau et
de supprimer des paquets Python à partir du Python Package Index (PyPI)
ou d'autres référentiels de paquets. Dans cette explication, nous allons
couvrir les bases de l'utilisation de pip pour installer et gérer les paquets.
Installation de paquets avec pip :
Pour installer un paquetage à l'aide de pip, ouvrez votre terminal ou
votre invite de commande et exécutez la commande suivante :
pip install nom_du_paquet
Remplacez nom_du_paquet par le nom du paquet que vous souhaitez
installer. Par exemple, pour installer la bibliothèque populaire requests,
vous devez exécuter :
pip install requests
pip téléchargera le paquetage depuis PyPI et ses dépendances, puis
l'installera dans votre environnement Python.

Spécification des versions des paquets :

Par défaut, pip installe la dernière version d'un paquetage. Cependant,
vous pouvez spécifier une version spécifique ou une plage de versions en
utilisant le nom du paquetage suivi du numéro de version :
pip install nom_du_paquet==1.2.3
Ceci installe la version 1.2.3 du paquet. Si vous souhaitez installer
n'importe quelle version dans un intervalle spécifique, vous pouvez utiliser
des opérateurs de comparaison :
pip install nom_du_paquet>=1.2,<2.0
Cela permet d'installer toute version supérieure ou égale à 1.2 mais inférieure à 2.0.
Mise à niveau des paquets :
 Pour mettre à jour un paquetage vers la dernière version disponible,
utilisez l'option-upgrade ou -U :
pip install-upgrade nom_du_paquet
Cela permet de vérifier les mises à jour et d'installer la dernière version si elle est
disponible.
Désinstallation des paquets :
Si vous n'avez plus besoin d'un paquet dans votre environnement Python,
vous pouvez le désinstaller en utilisant la commande uninstall ou son
abréviation un : pip uninstall nom_du_paquet
Cette opération supprime de l'environnement le paquet spécifié et ses
dépendances.
Liste des paquets installés :
Pour obtenir une liste de tous les paquets installés dans votre
environnement, vous pouvez utiliser la commande list ou son raccourci
freeze :
liste des pip
Cela affichera une liste des paquets installés avec leurs versions.
Fichiers requis :
Un fichier d'exigences est un fichier texte qui répertorie tous les
paquets requis pour un projet, y compris leurs versions spécifiques. Ce
fichier peut être partagé avec d'autres personnes afin de reproduire
l'environnement exact utilisé dans le projet. Pour générer un fichier
d'exigences, utilisez la commande freeze et redirigez la sortie vers un
fichier :
pip freeze > requirements.txt
Pour installer des paquets à partir d'un fichier d'exigences, utilisez la
commande install avec l'option -r :
pip install -r requirements.txt
Ceci installera tous les paquets et leurs versions respectives listés dans
le fichier.
Recherche de paquets :
Si vous recherchez un paquet spécifique ou si vous souhaitez découvrir
de nouveaux paquets, vous pouvez utiliser la commande de recherche :
 pip search nom_du_paquet
Ceci affichera une liste de paquets correspondant au nom donné.
pip est un outil indispensable pour les développeurs Python, car il
simplifie le processus d'installation et de gestion des paquets provenant de
PyPI et d'autres dépôts. En maîtrisant pip, vous pouvez gérer efficacement
les dépendances, maintenir vos projets à jour et créer des environnements
de développement reproductibles. Alors que l'écosystème Python continue
de se développer, pip reste l'outil de référence pour gérer les paquets et
permettre une collaboration transparente au sein de la communauté
Python.
19. Meilleures pratiques Python :
 19.1. ORGANISATION ET STYLE DU
CODE ( PEP 8 )

19.2. DOCUMENTATION ( DOCSTRINGS)

19.3. VERSIONNEMENT DU CODE

ET COLLABORATION ( GIT,
GITHUB)
 19.1. ORGANISATION ET STYLE DU
CODE ( PEP 8 )
L'organisation et le style du code jouent un rôle crucial dans le
développement des applications Python. Ils font référence aux pratiques et
aux lignes directrices que les développeurs suivent pour structurer leur base
de code d'une manière claire, maintenable et cohérente. La communauté
Python a établi un ensemble de conventions connues sous le nom de PEP 8
(Python Enhancement Proposal 8) afin de normaliser l'organisation et le
style du code, en veillant à ce que le code soit lisible et facilement
compréhensible par les autres.
Le PEP 8 couvre divers aspects de l'organisation et du style du code,
notamment l'indentation, la longueur des lignes, les conventions de
dénomination, etc. En adhérant à ces lignes directrices, les développeurs
peuvent créer un code qui est non seulement esthétique, mais qui encourage
également la collaboration et réduit la probabilité d'introduire des bogues.
Examinons les principaux aspects de l'organisation et du style du code, tels
qu'ils sont définis dans le PEP 8.
1. Indentation :
Python utilise l'indentation pour définir les structures de bloc, telles que
les boucles et les conditionnelles, au lieu d'accolades explicites. PEP 8
recommande d'utiliser quatre espaces pour l'indentation, ce qui améliore la
lisibilité du code et maintient une structure visuelle cohérente.
2. Longueur de la ligne :
Pour améliorer la lisibilité du code, le PEP 8 suggère de limiter les
lignes à un maximum de 79 caractères. Pour les commentaires et la
documentation, la limite est de 72 caractères. Toutefois, cette limite peut
être portée à 99 caractères si nécessaire.
3. Lignes vierges :
L'utilisation appropriée des lignes vierges améliore l'organisation et la
lisibilité du code. La PEP 8 recommande d'utiliser deux lignes vierges pour
séparer les fonctions et les classes de haut niveau, et une ligne vierge entre
les méthodes d'une même classe.
4. Déclarations d' importation :
 Les déclarations d'importation sont essentielles pour inclure des
modules et des paquets externes. Le PEP 8 suggère d'organiser les
importations dans l'ordre suivant : modules de la bibliothèque
standard, modules tiers et modules locaux spécifiques à
l'application. Chaque catégorie doit être séparée par une ligne vide.
5. Conventions d'appellation :
Un nommage cohérent et descriptif est essentiel pour la lisibilité du
code. Le PEP 8 fournit des conventions pour nommer les variables, les
fonctions, les classes et les modules. Par exemple, les noms de variables et
de fonctions doivent être en minuscules, les mots étant séparés par des traits
de soulignement (snake_case), tandis que les noms de classes doivent être
en CamelCase.
6. Espace blanc :
L'utilisation correcte des espaces blancs peut améliorer considérablement la lisibilité
du code.
Le PEP 8 recommande d'éviter les espaces blancs superflus, tels que les
espaces blancs de fin de ligne.
7. Commentaires et documentation :
Des commentaires et des chaînes de documentation pertinents sont
essentiels pour comprendre la fonctionnalité du code. Le PEP 8 fournit des
lignes directrices pour la rédaction de commentaires et de chaînes de
documentation clairs et concis, ce qui permet aux autres de comprendre
plus facilement l'objectif du code.
8. Arguments de fonction et de méthode :
Lors de la définition de fonctions ou de méthodes, la PEP 8 suggère
d'utiliser des espaces autour du signe "=" pour les valeurs d'argument par
défaut et d'éviter les espaces autour des parenthèses contenant les
arguments.
9. Sauts de ligne :
Pour préserver la lisibilité, la PEP 8 conseille de couper les lignes au
niveau des opérateurs plutôt que d'utiliser des barres obliques inverses pour
la suite de la ligne. En outre, il est recommandé d'ajouter une indentation
supplémentaire sur les lignes de continuation pour une meilleure distinction
visuelle.
10. Éviter les variables globales :
 La PEP 8 encourage à minimiser l'utilisation de variables globales, car
elles peuvent conduire à un code difficile à raisonner et à maintenir.
11. Traitement des exceptions :
Lors de la gestion des exceptions, la PEP 8 conseille d'utiliser une
classe d'exception spécifique plutôt qu'une clause "except" générale. Cette
pratique permet d'identifier et de traiter plus efficacement des conditions
d'erreur spécifiques.
En adhérant aux lignes directrices du PEP 8, les développeurs Python
peuvent créer un code propre, organisé et facile à maintenir. L'adoption de
ces conventions améliore non seulement la collaboration au sein des
équipes de développement, mais favorise également un sentiment de
cohésion plus important au sein de la communauté Python. De nombreux
éditeurs de code et IDE Python prennent également en charge le formatage
automatique du code PEP 8, ce qui permet aux développeurs de respecter
plus facilement ces conventions.
Il est essentiel de noter que, bien que le PEP 8 fournisse des
recommandations précieuses, il peut y avoir des cas où il n'est pas pratique
ou souhaitable d'adhérer strictement aux lignes directrices. Dans de telles
situations, les développeurs doivent donner la priorité à la lisibilité et à la
maintenabilité du code plutôt qu'à une adhésion stricte à la PEP
8. Néanmoins, le respect de la PEP 8 est généralement considéré comme
une bonne pratique, car il permet de garantir que le code Python est de
haute qualité et cohérent d'un projet à l'autre.
DES EXEMPLES DE CODE AVEC DES EXPLICATIONS :
1. Indentation et longueur de ligne :
def print_numbers() :
for i in range(1, 11) :
si i % 2 == 0 :
print(f "Even : {i}")
else :
print(f "Impair :
{i}")
print_numbers()

Dans cet exemple, nous avons une fonction print_numbers() qui

imprime les nombres de 1 à 10 et les étiquette comme pairs ou impairs.
L'indentation est cohérente, avec quatre espaces, et chaque ligne est
maintenue dans la limite de 79 caractères.
2. Conventions d'appellation et espaces blancs :
classe Chien :
def init ( self, name, age) :
self.name = name
self.age = age
def bark(self) :
print(f"{self.name} says : Woof
!") def fetch_ball(self, ball_color) :
print(f"{self.name} récupère la balle {ball_color}.")

Ici, nous avons une classe Dog avec des méthodes bark() et
fetch_ball(). Le nom de la classe suit la convention CamelCase, et les
noms des méthodes utilisent le snake_case. Un espacement correct est
utilisé autour du signe "=" dans le constructeur ( init ).
3. Déclarations d' importation :
import os
import sys
import requests
from utils import helper_function
# Reste du code

Les déclarations d'importation suivent l'ordre recommandé par le PEP 8

: d'abord les modules de la bibliothèque standard (os et sys), puis les
modules tiers (requests),
et enfin des modules locaux spécifiques à l'application (helper_function du
module utils).

4. Commentaires et documentation :
def add_numbers(a, b) :
"""
Cette fonction additionne deux nombres et renvoie le résultat.
Paramètres :
a (int) : Le premier nombre.
b (int) : Le deuxième nombre.
Retourne :
int : La somme des deux nombres.
"""
renvoie a + b

La fonction add_numbers() possède une docstring qui explique son but,

ses paramètres et sa valeur de retour. En documentant correctement les
fonctions de cette manière, il est plus facile pour les autres développeurs de
comprendre et d'utiliser correctement la fonction.
5. Sauts de ligne et continuation :
résultat de l'expression longue = (nom_de_la_variable_longue +
nom_de_la_variable_longue -
some_other_variable_name * yet_another_long_variable)
Dans cet exemple, une longue expression est divisée en plusieurs lignes
afin de maintenir la longueur de ligne dans la limite recommandée. Les
lignes suivantes sont indentées pour que le code soit visuellement clair.
6. Traitement des exceptions :
essayer :
result = perform_calculation(dividend, divisor)
except ZeroDivisionError as e :
print("Error : Cannot divide by zero.")
except ValueError as e :
print(f "Error : Invalid input -
{e}") else :
 print(f "Le résultat est : {résultat}")

Dans cet extrait de code, des classes d'exceptions spécifiques

(ZeroDivisionError et ValueError) sont utilisées pour attraper et gérer des
types d'exceptions spécifiques, conformément à la recommandation du PEP
8.
N'oubliez pas que les lignes directrices du PEP 8 ne sont pas des règles
rigides, mais plutôt des bonnes pratiques qui favorisent la lisibilité et la
maintenance du code. Il est essentiel de les adapter et de les utiliser selon
les besoins tout en maintenant la clarté et la cohérence du code au sein du
projet et de l'équipe.
 19.2. DOCUMENTATION ( DOCSTRINGS)
La documentation, en particulier les docstrings, est un aspect crucial de
l'organisation et du style du code en Python. Les docstrings sont des
chaînes de caractères utilisées pour fournir de la documentation sur les
fonctions, les classes et les modules. Elles servent de documentation en
ligne, fournissant des informations sur le but, l'utilisation, les paramètres et
les valeurs de retour des éléments de code qu'elles décrivent.
La PEP 257, intitulée "Docstring Conventions", fournit des lignes
directrices pour l'écriture de docstrings en Python. Ces directives aident les
développeurs à créer une documentation cohérente et informative qui peut
être facilement comprise par d'autres développeurs et outils.
Explorons les aspects clés de la documentation, y compris l'importance
des chaînes de documentation et les conventions recommandées pour les
écrire.
1. Importance des chaînes de documents :

Améliorer la lisibilité du code : Les docstrings servent de référence

rapide aux développeurs qui essaient de comprendre comment
utiliser une fonction ou une classe. Elles fournissent des
explications claires sur l'objectif et le comportement du code.
Faciliter la maintenance du code : Un code bien documenté est plus
facile à maintenir car les développeurs peuvent rapidement
comprendre l'intention des différents éléments du code.
Promouvoir la collaboration : Lorsque l'on travaille en équipe, des
chaînes documentaires complètes permettent aux membres de l'équipe
de collaborer efficacement en leur donnant un aperçu du code de
chacun.
Faciliter l'inspection du code : Les outils automatisés et les IDE
peuvent utiliser les docstrings pour générer de la documentation ou
afficher une aide contextuelle pendant le codage, ce qui améliore la
productivité.

2. Écrire des chaînes de caractères (Docstrings) :

Triples guillemets : Les chaînes de documents sont généralement

placées entre des guillemets triples (simples ou doubles) pour couvrir
plusieurs lignes.
Emplacement de la Docstring : Les chaînes de texte sont placées
immédiatement sous la définition de la fonction, de la classe ou du
module, et constituent la première déclaration.
 après la définition.
Format : PEP 257 recommande d'utiliser un format cohérent pour les
chaînes de documentation. La docstring doit commencer par une ligne
de résumé, suivie d'une ligne vide, puis d'une description plus
détaillée.
Paramètres : Pour les fonctions et les méthodes, les docstrings doivent
énumérer les paramètres, leurs types et une brève description de
l'objectif de chaque paramètre.
Valeur de retour : Pour les fonctions qui renvoient une valeur, la
docstring doit décrire la valeur de retour attendue et son type.
Exemples : L'inclusion d'exemples d'utilisation dans la documentation
peut fournir des indications pratiques sur la manière d'utiliser
l'élément de code.

def calculate_square(number) :
"""
Calcule le carré d'un nombre donné.
Paramètres :
number (int) : Le nombre d'entrée pour lequel le carré sera calculé. Retourne :
int : Le carré du nombre saisi. """
retour numéro ** 2

Dans cet exemple, la docstring fournit un résumé concis de l'objectif de

la fonction, décrit le paramètre et indique la valeur de retour.
3. Gestion des exceptions relatives à la chaîne de documents :

Omettre les docstrings : Il est acceptable d'omettre les docstrings pour

les fonctions très simples qui s'expliquent d'elles-mêmes. Cependant, il
est de bonne pratique d'inclure les docstrings pour la plupart des
fonctions, en particulier celles qui sont utilisées dans différents
modules ou par d'autres développeurs.
Fonctions non publiques : La documentation des fonctions non
publiques (fonctions dont le nom commence par un seul trait de
soulignement) est facultative. Cependant, il peut être utile de les
documenter, en particulier lorsqu'elles font partie d'une API publique.

Dans l'ensemble, le respect des conventions de la chaîne de

documentation décrites dans la PEP 257 permet de créer une
documentation cohérente et informative, ce qui se traduit par une meilleure
organisation du code, une meilleure collaboration et une meilleure
maintenabilité du code.
En utilisant les docstrings, les développeurs Python peuvent s'assurer que
leur code est bien documenté et facilement compréhensible par les autres,
contribuant ainsi à un processus de développement plus efficace et
productif.
 POINTS SUPPLÉMENTAIRES :
1. Styles Docstring :

Il existe plusieurs styles de docstring utilisés dans la communauté

Python. Les deux styles les plus courants sont le style à une ligne et le
style à plusieurs lignes.
Style à une ligne : Dans ce style, l'ensemble de la docstring tient sur une seule ligne.
Il convient pour des fonctions ou des méthodes simples.

def square(number) :
"""Retourne le carré du nombre saisi."" return
number ** 2

Style multiligne : Ce style inclut une docstring de plusieurs lignes avec

des descriptions détaillées pour chaque paramètre, valeur de retour et
exemples d'utilisation. Il est recommandé pour les fonctions et les
classes plus complexes.

def divide(dividend, divisor) :

"""
Divise le dividende par le diviseur et renvoie le résultat.
Paramètres :
dividende (int) : Le nombre à diviser.
diviseur (int) : Le nombre par lequel le dividende sera divisé. Retourne :
flottant : Le résultat de la
division. """
return dividende / diviseur

2. Traitement des cas exceptionnels :

La documentation doit également mentionner les exceptions ou les

erreurs qu'une fonction ou une méthode peut soulever, afin de donner
un aperçu des scénarios d'erreur potentiels.
Par exemple, si une fonction soulève une exception personnalisée, il est
utile de documenter les situations dans lesquelles cette exception peut
se produire.

3. Outils et normes Docstring :

 Plusieurs outils et bibliothèques existent pour aider à documenter le
code Python. Parmi les plus populaires, on trouve Sphinx, Doxygen et
les docstrings à la Google.
Les chaînes de documentation de style Google suivent une
convention spécifique selon laquelle la chaîne de
documentation commence par une ligne de résumé, suivie de
descriptions plus détaillées, de paramètres et de valeurs de
retour. Ce style est utilisé par Google et adopté par certains
projets open-source.
def multiply(a, b) :
"""
Multiplier deux
nombres.
Args :
a (int) : Le premier nombre.
b (int) : Le deuxième nombre.
Retourne :
int : Le produit de a et b. """"
retour a * b

4. Mise à jour de la documentation :

Au fur et à mesure que le code évolue et se modifie, il est essentiel de

mettre à jour la documentation afin qu'elle reflète le comportement
actuel des fonctions, des méthodes et des classes.
Lorsque le comportement ou l'API d'un élément de code est modifié, la
mise à jour de la documentation permet de s'assurer que les
utilisateurs sont au courant des modifications.

5. Chaînes de caractères et chaînes de documents multilignes :

Python autorise les chaînes de caractères sur plusieurs lignes (chaînes

entre guillemets triples) en dehors des docstrings.
Bien que les chaînes multilignes puissent être utilisées pour les
commentaires et la documentation des blocs, elles n'ont pas la même
fonction que les chaînes de documentation. Les chaînes de
documentation sont spécifiquement destinées à fournir une
documentation en ligne pour les éléments de code.

6. Utilisation des annotations de type dans les chaînes de documents :

 Avec l'introduction des annotations de type dans Python 3.5 et les
versions ultérieures, les chaînes de documentation peuvent également
inclure des informations sur les types attendus des paramètres et des
valeurs de retour.
Cette pratique permet de clarifier davantage les types de données que la
fonction ou la méthode accepte et renvoie.

7. Traduire les chaînes de documents :

Dans les projets multilingues, il est courant d'avoir des documents

traduits dans différentes langues pour une meilleure
internationalisation et localisation (i18n et l10n).
Des outils spéciaux, comme Sphinx, permettent de générer de la
documentation dans plusieurs langues en fournissant des traductions
des chaînes de caractères.

Le respect de ces points et lignes directrices supplémentaires garantit

que votre code Python est bien documenté, ce qui le rend plus accessible
aux autres développeurs et favorise les bonnes pratiques de codage dans
l'ensemble de vos projets. Un code bien documenté aide non seulement à
comprendre votre base de code, mais contribue également au succès
global de vos efforts de développement de logiciels.
 19.3. VERSIONNEMENT DU
CODE ET COLLABORATION ( GIT,
GITHUB)
Le versionnage du code et la collaboration sont des aspects essentiels du
développement de logiciels modernes. Ils impliquent l'utilisation de
systèmes de contrôle de version comme Git et de plateformes comme
GitHub pour gérer et suivre les modifications apportées au code, faciliter le
travail d'équipe et veiller à ce que le processus de développement reste
efficace et organisé. Voyons maintenant l'importance du versionnage du
code et de la collaboration à l'aide de Git et GitHub.
1. Versionnement du code avec Git :

Git est un système de contrôle de version distribué largement utilisé

dans la communauté des développeurs de logiciels.

Le contrôle de version permet aux développeurs de suivre les

modifications apportées à leur code au fil du temps, ce qui leur permet
de revenir aux versions précédentes, de visualiser les différences entre
les versions et de collaborer de manière transparente avec d'autres
personnes.
Avec Git, chaque développeur dispose de son propre dépôt local, et
les modifications sont validées et suivies localement avant d'être
transférées vers un dépôt central ou un service distant tel que GitHub.

2. Avantages du versionnage du code :

Suivi de l'historique : Git conserve un historique complet des

modifications de code, ce qui permet aux développeurs de savoir qui a
effectué une modification, quand et pourquoi.
Branchement et fusion : Git permet aux développeurs de créer des
branches pour travailler sur des fonctionnalités ou des corrections de
bogues de manière indépendante, puis de fusionner les modifications
dans la base de code principale une fois qu'elles sont prêtes.
Collaboration : Git facilite la collaboration entre les membres de
l'équipe, en prévenant les conflits et en fournissant des mécanismes
pour les résoudre lorsqu'ils surviennent.
Sauvegarde du code : En utilisant Git, les développeurs s'assurent que
leur base de code est sauvegardée en toute sécurité, ce qui réduit le
risque de perte de données.
 3. GitHub pour la collaboration :

GitHub est un service d'hébergement en ligne populaire pour les dépôts

Git. Il fournit une plateforme permettant aux développeurs de partager
et de collaborer sur le code.
Les développeurs peuvent pousser leurs dépôts Git locaux vers GitHub,
les rendant ainsi accessibles à d'autres et permettant une collaboration
transparente.
GitHub offre des fonctionnalités telles que les demandes d'extraction,
le suivi des problèmes, les révisions de code et les outils de gestion de
projet, qui rationalisent le flux de travail de développement.

4. Demandes de retrait et examen du code :

Les demandes d'extraction sont le mécanisme de GitHub permettant de

proposer des modifications d'une branche à une autre, généralement
d'une branche de fonctionnalités à la branche principale (par exemple,
de "feature" à "master").
La revue de code est une partie cruciale du processus de demande
d'extraction, où les membres de l'équipe examinent les changements
proposés, fournissent des commentaires et assurent la qualité du code
avant de le fusionner.

5. Suivi des problèmes et gestion des projets :

Le système de suivi des problèmes de GitHub permet aux développeurs

de signaler des bogues, de demander de nouvelles fonctionnalités ou
de discuter des améliorations à apporter à un projet.
Les problèmes peuvent être attribués à des membres spécifiques de
l'équipe, étiquetés et suivis tout au long de leur cycle de vie.
Les outils de gestion de projet de GitHub, tels que les tableaux et les
jalons, aident les équipes à organiser les tâches et à suivre les progrès
réalisés au cours du développement.

6. Intégration continue (CI) et déploiement continu (CD) :

GitHub s'intègre à divers services CI/CD, ce qui permet aux

développeurs d'automatiser les processus de test, de construction et de
déploiement.
L'intégration continue garantit que les modifications sont
régulièrement intégrées dans la base de code principale, ce qui
favorise un environnement de développement stable et fiable.
 Le déploiement continu automatise le processus de mise en production,
ce qui permet aux équipes de mettre en production les modifications
apportées au code de manière rapide et efficace.

7. Communauté et source ouverte :

GitHub héberge une vaste communauté de logiciels libres, où les

développeurs peuvent collaborer à des projets, contribuer à des
dépôts existants et obtenir la reconnaissance de leur travail.
Les projets open-source sur GitHub invitent souvent la communauté à
contribuer par le biais de demandes d'extraction, ce qui favorise une
culture de développement collaborative et inclusive.

En conclusion, le versionnage du code avec Git et la collaboration sur

des plateformes comme GitHub sont essentiels pour les pratiques modernes
de développement de logiciels. En utilisant ces outils, les développeurs
peuvent gérer efficacement leur base de code, collaborer de manière
transparente et assurer un flux de développement fluide et productif. Ces
pratiques permettent non seulement d'améliorer la qualité et la fiabilité du
code, mais aussi de favoriser le dynamisme et la prospérité de la
communauté des logiciels libres.
 ANNEXE : [[ 370 ]]

Exercices et solutions [[371]]

Ressources
 EXERCICES ET SOLUTIONS :
EXERCICES :
1. Séquence de Fibonacci :
Ecrivez une fonction Python pour générer la suite de Fibonacci jusqu'à
un nombre donné "n". La séquence de Fibonacci commence par 0 et 1, et
chaque nombre suivant est la somme des deux précédents. Par exemple, si
"n" est 10, la fonction doit retourner [0, 1, 1, 2, 3, 5, 8].
2. Vérificateur de nombres premiers :
Créez une fonction Python qui prend un entier en entrée et renvoie True
si le nombre est premier et False sinon. Un nombre premier est un nombre
naturel supérieur à 1 qui n'a pas d'autres diviseurs positifs que 1 et lui-
même. Par exemple, si l'entrée est 17, la fonction doit renvoyer True.
3. Vérification des palindromes :
Écrivez une fonction Python qui vérifie si une chaîne donnée est un
palindrome. Un palindrome est un mot, une phrase, un nombre ou une autre
séquence qui se lit de la même manière à l'envers qu'à l'endroit. Par
exemple, si l'entrée est "radar", la fonction doit retourner True.
4. Inverser des mots dans une phrase :
Écrivez une fonction Python qui prend une phrase en entrée et renvoie
la phrase avec l'ordre des mots inversé. Par exemple, si l'entrée est "Python
est génial", la fonction doit retourner "génial est Python".
5. Compréhension des listes :
Créez une fonction Python qui prend une liste d'entiers en entrée et
renvoie une nouvelle liste contenant uniquement les nombres pairs en
utilisant la compréhension de liste.
6. Calcul factoriel :
Ecrivez une fonction Python pour calculer la factorielle d'un entier
positif donné 'n'. La factorielle d'un entier non négatif "n" est le produit de
tous les entiers positifs inférieurs ou égaux à "n". Par exemple, si 'n' est 5,
la fonction doit retourner 120 (1 * 2 * 3 * 4 * 5).
7. Vérificateur d'anagrammes :
 Créez une fonction Python qui prend deux chaînes en entrée et renvoie
True si les deux chaînes sont des anagrammes l'une de l'autre et False dans
le cas contraire.
Les anagrammes sont des mots ou des phrases formés en réarrangeant les
lettres d'un autre mot ou d'une autre phrase, généralement en utilisant
toutes les lettres originales une seule fois. Par exemple, si les entrées sont
"listen" et "silent", la fonction doit renvoyer True.
8. Fichier Compteur de mots :
Écrire une fonction Python qui prend le nom d'un fichier texte en entrée
et renvoie le nombre total de mots dans le fichier.
9. Transposition de la matrice :
Créez une fonction Python qui prend une matrice (liste 2D) en entrée et
renvoie la transposée de la matrice. La transposition d'une matrice est
obtenue en échangeant ses lignes et ses colonnes. Par exemple, si l'entrée
est [[1, 2, 3], [4, 5,
6]], la fonction doit renvoyer [[1, 4], [2, 5], [3, 6]].
10. Générateur de mot de passe aléatoire :
Écrivez une fonction Python qui génère un mot de passe aléatoire d'une
longueur donnée "n". Le mot de passe doit être composé d'un mélange de
lettres majuscules, de lettres minuscules et de chiffres.
11. Somme récursive :
Créez une fonction Python qui prend une liste d'entiers en entrée et
renvoie la somme de tous les éléments de la liste en utilisant la récursivité.

12. Convertisseur de chiffres romains :

Écrivez une fonction Python qui convertit un nombre entier donné en
sa représentation en chiffres romains. Les chiffres romains sont représentés
par des combinaisons de lettres de l'ensemble {I, V, X, L, C, D, M}. Par
exemple, si l'entrée est 2023, la fonction doit retourner "MMXXIII".
13. Préfixe commun le plus long :
Créez une fonction Python qui prend une liste de chaînes en entrée et
renvoie le préfixe commun le plus long parmi toutes les chaînes. Par
exemple, si l'entrée est ["apple", "apricot", "aptitude"], la fonction doit
retourner "ap".
 14. Compter les occurrences de caractères :
Créez une fonction Python qui prend une chaîne et un caractère en
entrée et renvoie le nombre de fois où le caractère apparaît dans la chaîne.
15. Trouver le plus grand élément d'une liste :
Écrire une fonction Python qui prend une liste de nombres en entrée et
renvoie le plus grand élément de la liste.

16. Supprimer les doublons d'une liste :

Créez une fonction Python qui prend une liste en entrée et renvoie une
nouvelle liste dont les doublons ont été supprimés tout en préservant l'ordre
original des éléments.
17. Caractères uniques dans une chaîne :
Écrivez une fonction Python qui prend une chaîne en entrée et renvoie
True si tous les caractères de la chaîne sont uniques, et False s'il y a des
caractères répétés.
18. Recherche binaire :
Implémentez une fonction Python qui effectue une recherche binaire
sur une liste triée d'entiers. La fonction doit renvoyer l'index de l'élément
cible s'il est trouvé, ou -1 si l'élément n'est pas présent dans la liste.
19. Conversion du temps :
Écrire une fonction Python qui prend en entrée une heure au format 12
heures (par exemple, "03:45 PM") et renvoie l'heure au format 24 heures
(par exemple, "15:45").
20. Fusion de dictionnaires :
Créez une fonction Python qui prend deux dictionnaires en entrée et
renvoie un nouveau dictionnaire résultant de la fusion des deux
dictionnaires.
 SOLUTIONS :
1. Séquence de Fibonacci :
def generate_fibonacci_sequence(n) :
séquence = [0, 1]
while séquence[-1] + séquence[-2] <= n :
numéro suivant = séquence[-1] + séquence[-2]
séquence.append(numéro suivant)
séquence de retour
# Tester la
fonction n = 10
print(generate_fibonacci_sequence(n)) # Sortie : [0, 1, 1, 2, 3, 5, 8]
2. Vérificateur de nombres premiers :
def is_prime(number) :
si nombre <= 1 :
retourner Faux
for i in range(2, int(number**0.5) + 1) :
if number % i == 0 :
retour Faux
retour Vrai
# Tester la
fonction num = 17
print(is_prime(num)) # Sortie : Vrai
3. Vérification des palindromes :
def is_palindrome(word) :
return word == word[::-1]
# Tester la fonction
string = "radar" print(is_palindrome(string))
# Sortie : Vrai
4. Inverser des mots dans une phrase :
def reverse_words(sentence) :
words = sentence.split()
phrase_inversée = " ".join(reversed(words)) return
phrase_inversée
# Tester la fonction
sentence = "Python is awesome"
print(reverse_words(sentence)) # Sortie : "awesome is Python"
5. Compréhension des listes :
def get_even_numbers(numbers) :
return [num for num in numbers if num % 2 == 0]
# Tester la fonction
numbers_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(get_even_numbers(numbers_list)) # Sortie : [2, 4, 6, 8, 10]
6. Calcul factoriel :
def factorial(n) :
si n == 0 :
retour 1
autre :
return n * factorial(n - 1)
# Tester la fonction
num = 5
print(factorial(num)) # Sortie : 120
7. Vérificateur d'anagrammes :
def are_anagrams(str1, str2) :
return sorted(str1) == sorted(str2)
# Tester la fonction
mot1 = "écouter"
mot2 =
"silencieux"
print(are_anagrams(word1, word2)) # Sortie : Vrai
8. Fichier Compteur de mots :
def count_words_in_file(file_name) :
with open(file_name, 'r') as file :
content = file.read()
word_list = content.split()
return len(word_list)
# Tester la fonction
nom_du_fichier =
"exemple.txt"
print(count_words_in_file(file_name))
9. Transposition de la matrice :
def transpose_matrix(matrix) :
return [list(row) for row in zip(*matrix)]
# Tester la fonction
matrice = [[1, 2, 3], [4, 5, 6]]
print(transpose_matrix(matrix)) # Sortie : [[1, 4], [2, 5], [3, 6]]
10. Générateur de mot de passe aléatoire :
import random
import string
def generate_random_password(length) :
caractères = string.ascii_lettres + string.chiffres
password = ''.join(random.choice(characters) for _ in range(length))
return password
# Test de la
fonction length =
10
print(generate_random_password(length))
11. Somme récursive :
def recursive_sum(numbers) :
si len(nombres) == 0 :
retour 0
autre :
return nombres[0] + recursive_sum(nombres[1 :])
# Tester la fonction
numbers_list = [1, 2, 3, 4, 5]
print(recursive_sum(numbers_list)) # Sortie : 15
12. Convertisseur de chiffres romains :
def int_to_roman(number) :
val = [
1000, 900, 500, 400,
100, 90, 50, 40,
10, 9, 5, 4,
1
]
syms = [
"M", "CM", "D", "CD",
"C", "XC", "L", "XL",
"X", "IX", "V", "IV",
"I"
]
roman_numeral = ""
i=0
while number > 0 :
for _ in range(number // val[i]) :
roman_numeral += syms[i]
number -= val[i]
i += 1
return roman_numeral
# Tester la fonction
num = 2023
print(int_to_roman(num)) # Sortie : "MMXXIII"
13. Préfixe commun le plus
long : def
longest_common_prefix(strings) : if
not strings :
return ""
prefix = strings[0]
pour string dans
strings[1 :]: i = 0
while i < len(prefix) and i < len(string) and prefix[i] == string[i] :
i += 1
prefix = prefix[:i]
return prefix
# Tester la fonction
words_list = ["apple", "apricot", "aptitude"]
print(longest_common_prefix(words_list))
14. Compter les occurrences de caractères :
def count_occurrences(text, char) :
return text.count(char)
# Tester la fonction
texte = "programmation python"
caractère = "m"
print(count_occurrences(text, character)) # Sortie : 2
15. Trouver le plus grand élément d'une liste :
def find_largest_element(numbers) :
return max(numbers)
# Tester la fonction
numbers_list = [4, 9, 2, 7, 5]
print(find_largest_element(numbers_list)) # Sortie : 9
16. Supprimer les doublons d'une liste :
def remove_duplicates(input_list) :
return list(dict.fromkeys(input_list))
# Tester la fonction
original_list = [1, 2, 2, 3, 4, 4, 5]
print(remove_duplicates(original_list)) # Sortie : [1, 2, 3, 4, 5]
17. Caractères uniques dans une chaîne :
def has_unique_characters(input_string) :
return len(set(input_string)) == len(input_string)
# Tester la fonction
mot = "banane"
print(has_unique_characters(word)) # Sortie : Faux
18. Recherche binaire :
def binary_search(sorted_list, target) :
low, high = 0, len(sorted_list) - 1
while low <= high :
mid = (low + high) // 2
si liste_triée[milieu] == cible :
return mid
elif sorted_list[mid] < target :
low = mid + 1
else :
high = mid - 1
return -1
# Tester la fonction
nombres_triés = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numéro_cible = 5
print(binary_search(sorted_numbers, target_number)) # Sortie : 4
19. Conversion du temps :
def time_conversion(time_string) :
heures, minutes = time_string.split(" :")
am_pm = time_string[-2 :]
if am_pm == "PM" and hours != "12" :
hours = str(int(hours) + 12)
elif am_pm == "AM" et hours == "12" :
hours = "00"
return f"{hours}:{minutes}"
# Test de la fonction
time_12h = "03:45 PM"
print(time_conversion(time_12h)) # Sortie : "15:45"
20. Fusion de dictionnaires :
def merge_dictionaries(dict1, dict2) :
 merged_dict = dict1.copy()
merged_dict.update(dict2)
return merged_dict
# Tester la fonction
dict1 = {"a" : 1, "b" :
2}
dict2 = {"c" : 3, "d" : 4}
print(merge_dictionaries(dict1, dict2))
# Sortie : {'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4}
N'hésitez pas à utiliser ces exercices et solutions pour tester votre
compréhension et améliorer vos compétences en Python. Bon codage !
 RESSOURCES :
1. NSWorldInfo
Site web : https://nsworldinfo.medium.com/

Python Mastery Series : https://nsworldinfo.medium.com/list/python-

mastery-complete-python-series-from-novice-to-pro-59845ee05372
Liste Data Science : https://nsworldinfo.medium.com/list/data-science-
29618c7ebc31

2. Tech NS Arena
Chaîne YouTube : https://youtube.com/@TechNSArena
Cette chaîne fournit des informations sur la science des données,
l'apprentissage automatique, la programmation Python, la technologie et les
domaines connexes grâce à un contenu vidéo attrayant.
3. InfoWorldavecNS
Blog : https://infoworldwithns.blogspot.com/
Ce blog offre des perspectives informatives sur la science des données,
l'apprentissage automatique, la programmation Python, l'intelligence
artificielle, la technologie et les domaines connexes. Il inclut des extraits de
code du monde réel avec des explications faciles à comprendre, ce qui en
fait une ressource précieuse pour les apprenants.
4. Tech NS Oracle
Page : https://bmc.link/technsoracle
Tech NS Oracle fournit des aperçus informatifs sur la science des
données, l'apprentissage automatique, la programmation Python,
l'intelligence artificielle, la technologie et les domaines connexes. Explorez
cette page pour un contenu enrichissant et restez informé des dernières
tendances et évolutions dans le monde de la tech.
Ces ressources supplémentaires complètent "Python Mastery : Du
débutant absolu au professionnel" en offrant aux lecteurs la possibilité
d'explorer des sujets plus approfondis, de s'engager dans un contenu
multimédia et d'accéder à des exemples du monde réel. Que vous préfériez
les articles écrits ou les vidéos attrayantes, ces ressources ne manqueront
pas d'enrichir votre parcours en Python et d'approfondir votre
compréhension du monde fascinant de la technologie.
 DESCRIPTION FINALE :
Félicitations pour avoir terminé votre voyage de transformation à travers
"Python Mastery : Du débutant absolu au professionnel" ! Ce livre
complet et captivant a été méticuleusement conçu pour donner aux
programmeurs en herbe comme vous les moyens d'acquérir les
connaissances et les compétences nécessaires pour exploiter tout le
potentiel de Python.
Dès le début, vous vous êtes plongé dans les principes fondamentaux
de Python, en apprenant les types de données, les variables et les structures
de contrôle. Au fur et à mesure de votre progression, vous avez gagné en
confiance et les mystères des fonctions, des modules et de la
programmation orientée objet sont devenus évidents. Des projets concrets
vous ont permis d'acquérir une expérience pratique et vous avez créé des
applications qui ont mis en évidence les applications pratiques de Python.
Dans les sections avancées, vous avez abordé des concepts plus
complexes, tels que la gestion des fichiers, les interactions avec les bases
de données et le développement web à l'aide de frameworks tels que Flask
et Django. L'exploration de l'apprentissage automatique et de la science
des données avec Python a ouvert des perspectives passionnantes pour
l'analyse et la visualisation des données, l'élaboration de prévisions et la
résolution de problèmes concrets.
Tout au long de cet ouvrage, l'accent a été mis sur la compréhension, et
non sur la simple mémorisation. Vous avez appris à penser comme un
expert Python, en abordant les défis avec créativité et compétences de
résolution de problèmes. Vous êtes maintenant équipé pour relever des
défis de codage, concevoir des applications évolutives et collaborer à des
projets ambitieux. Alors que vous atteignez le dernier chapitre, vous faites
désormais partie de la dynamique communauté Python, où vos
connaissances et votre passion peuvent inspirer et soutenir d'autres
personnes dans leur parcours de codage. Les possibilités qui s'offrent à
vous, en tant que programmeur Python, sont illimitées.
N'oubliez pas que ce livre n'est pas une fin en soi, mais un tremplin
pour un voyage d'apprentissage et de croissance continus tout au long de la
vie. Profitez de la joie de la découverte et de la satisfaction de créer
quelque chose de significatif avec vos compétences en python.
En tant qu'auteur de ce livre, je tiens à vous remercier sincèrement, cher
lecteur. Votre dévouement et votre enthousiasme ont rendu ce voyage
encore plus gratifiant. J'espère que vous trouverez dans ces pages des
connaissances non seulement précieuses, mais aussi enrichissantes.
 Merci d'avoir choisi "Python Mastery : Du débutant absolu au
professionnel". Que votre passion pour Python continue d'alimenter votre
curiosité et votre dynamisme, vous permettant d'atteindre des sommets
encore plus élevés dans le monde de la programmation et de la technologie.
Bon codage !

Maîtrise de Python : Du débutant absolu au professionnel

Nibedita Sahu