Ficha de revisão: Introduction à la programmation Python

📋 Plan du Cours

1. Objectifs et caractéristiques de Python
2. Variables en Python et typage dynamique
3. Opérateurs arithmétiques et d’incrémentation
4. Opérations sur les chaînes de caractères
5. Affichage avec print et mise en forme f-string
6. Listes Python : indices, tranches et opérations
7. Boucle for et itération avec range
8. Boucle while et conditions d’arrêt
9. Tests conditionnels if, elif et else
10. Modules et importation de bibliothèques
11. Jupyter Notebook : cellules, exécution et magic

📖 1. Objectifs et caractéristiques de Python

🔑 Notions clés & Définitions

• Python : Langage de programmation utilisé pour écrire des programmes exécutables sur de nombreuses plateformes.
• Langage interprété : Type de langage où le code s’exécute sans étape de compilation préalable.
• Langage de haut niveau : Langage qui demande moins de connaissances matérielles pour écrire des instructions.
• Programmation orientée objet : Approche où l’on modélise des entités du monde réel sous forme d’objets avec des règles et interactions.
• Python en IA et analyse de données : Usage fréquent de Python pour développer des solutions en intelligence artificielle et traiter des données.

📝 Points essentiels

• Python est multiplateforme : Windows, Mac OS X, Linux, Android, iOS, et aussi Raspberry Pi jusqu’aux supercalculateurs.
• Python est gratuit et s’installe sur autant d’ordinateurs que souhaité, y compris sur un téléphone.
• Python est interprété : un script n’a pas besoin d’être compilé avant exécution.
• Python est orienté objet : on peut concevoir des entités qui imitent des objets du monde réel.
• Python est relativement simple à prendre en main et très utilisé en IA et en analyse de données.

💡 Astuce mémo

Interprété = pas de compilation ; Orienté objet = on modélise des entités.

📖 2. Variables en Python et typage dynamique

🔑 Notions clés & Définitions

• Variable : Zone de mémoire identifiée par un nom, qui stocke une valeur pendant l’exécution.
• Typage dynamique : Caractéristique où le type d’une variable est déterminé automatiquement par la valeur affectée.
• Type de variable : Nature d’une variable (entier, réel, chaîne, booléen, etc.) qui influence les opérations possibles.
• Fonction type(x) : Fonction qui renvoie le type de la valeur contenue dans x.
• Règles de nommage : Contraintes sur la forme des noms de variables en Python (pas de chiffre initial, pas de caractère souligné initial).

📝 Points essentiels

• En Python, déclaration et initialisation d’une variable se font en même temps.
• Python déduit le type à partir de la valeur : c’est un langage à typage dynamique.
• Une variable peut être de type int, float, str (chaîne), booléen, etc.
• Le type correspond à la nature de la valeur stockée.
• Le nom d’une variable Python ne commence pas par un chiffre ni par un « _ », et l’espace n’est pas utilisé dans la déclaration (ex. ma_variable=3).
• La fonction type(x) renseigne sur le type d’une variable x.

💡 Astuce mémo

type(x) te dit la nature ; typage dynamique = le type suit la valeur.

📖 3. Opérateurs arithmétiques et d’incrémentation

🔑 Notions clés & Définitions

• Opérateur puissance : Opérateur qui élève un nombre à une puissance donnée.
• Opérateur quotient : Opérateur qui calcule une division avec résultat entier.
• Opérateur modulo : Opérateur qui renvoie le reste d’une division entière.
• Opérateur d’incrémentation += : Opérateur d’affectation qui augmente une variable de la valeur indiquée.

📝 Points essentiels

• L’opérateur puissance s’écrit **.
• Le quotient entier s’obtient avec //.
• Le modulo (reste) s’obtient avec %.
• L’incrémentation se fait avec += (ex. ajouter une valeur à une variable).

💡 Astuce mémo

** puissance ; // quotient entier ; % reste ; += additionne et réaffecte.

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

🔑 Notions clés & Définitions

• Concaténation : Opération qui joint deux chaînes de caractères pour former une chaîne plus longue.
• Réplication de chaîne : Opération qui duplique une chaîne un certain nombre de fois.
• Opérateur + sur les chaînes : Opérateur qui concatène deux chaînes de caractères.
• Opérateur * sur les chaînes : Opérateur qui duplique une chaîne lorsqu’il est multiplié par un entier.
• Opérations illicites : Cas où une opération n’est pas autorisée car les types ou l’usage ne correspondent pas aux règles du langage.

📝 Points essentiels

• L’opérateur + concatène les chaînes de caractères.
• L’opérateur * duplique une chaîne quand le multiplicateur est un entier.
• Exemple de logique : “2 ” + “2“ produit une chaîne concaténée.
• Exemple de logique : “2 ” * 2 duplique la chaîne.
• Les opérations illicites à éviter concernent notamment l’usage de + et * quand les types ne sont pas compatibles avec l’intention (concaténer ou dupliquer).

💡 Astuce mémo

• = coller ; * = répéter (avec un entier).

📖 5. Affichage avec print et mise en forme f-string

🔑 Notions clés & Définitions

• print() : Fonction qui affiche l’argument fourni à l’écran.
• Mot clé end : Option de print() qui contrôle le caractère de fin d’affichage (notamment le retour à la ligne).
• sep : Option de print() qui sépare plusieurs arguments affichés.
• f-string : Écriture formatée qui permet d’insérer des valeurs dans une chaîne via des accolades {}.
• Spécification de format : Syntaxe à l’intérieur d’une f-string qui fixe la précision ou la forme d’affichage (décimales, notation scientifique, etc.).

📝 Points essentiels

• print() affiche l’argument entre parenthèses et ajoute par défaut un retour à la ligne.
• Le mot clé end annule le retour à la ligne.
• On peut afficher une variable avec print() ou plusieurs variables en une seule instruction.
• Le mot clé sep permet de séparer plusieurs arguments affichés.
• Une f-string s’écrit avec des accolades {} pour insérer des valeurs numériques.
• La lettre f dans la f-string sert à la fois à marquer l’écriture formatée et à définir la précision via le format (ex. {.xf}).

💡 Astuce mémo

print() = affiche + saut de ligne ; f-string = {} pour injecter des valeurs.

📖 6. Listes Python : indices, tranches et opérations

🔑 Notions clés & Définitions

• Liste : Structure de données qui contient une série de valeurs, pouvant être de types différents.
• Indice : Position d’un élément dans une liste, utilisée pour accéder à cet élément.
• Tranche de liste : Sous-ensemble d’une liste obtenu avec une syntaxe de type [m:n+1] où la borne haute est exclue.
• Pas de tranche : Valeur qui contrôle l’espacement entre les éléments sélectionnés dans une tranche.
• append() : Méthode qui ajoute un élément à la fin d’une liste.

📝 Points essentiels

• Python permet des listes contenant des valeurs de types différents.
• Les indices commencent toujours à 0.
• L’accès à un élément se fait avec des crochets, par exemple animaux[4].
• L’indice négatif permet d’accéder depuis la fin (ex. animaux[-1]).
• La tranche suit le modèle [m:n+1] : l’élément n+1 est exclu.
• Une tranche avec pas suit [début:fin:pas] pour choisir des éléments espacés.

💡 Astuce mémo

Indice 0 au début ; tranche borne haute exclue ; -1 = dernier élément.

📖 7. Boucle for et itération avec range

🔑 Notions clés & Définitions

• Boucle for : Structure de contrôle qui répète un bloc d’instructions pour chaque élément d’une séquence.
• Variable d’itération : Variable qui prend successivement les valeurs issues de la liste ou de l’itérable.
• Indentation : Décalage de lignes qui délimite le bloc d’instructions exécuté par une structure (for, if, etc.).
• range() : Fonction qui génère une suite d’entiers sur un intervalle.
• range(début, fin, pas) : Forme de range qui permet de choisir le début, la fin et l’incrément.

📝 Points essentiels

• La boucle for est utilisée pour répéter des instructions un grand nombre de fois de façon structurée.
• La variable d’itération prend successivement les valeurs de la liste parcourue (ex. animaux).
• La boucle for se termine par deux points : et attend un bloc d’instructions.
• Python délimite le début et la fin du bloc via l’indentation.
• Avec range(n), on obtient de 0 à n-1.
• Avec range(début, fin, pas), on choisit le début et le pas (la fin reste exclue dans l’intervalle décrit).

💡 Astuce mémo

for = pour chaque ; range = suite d’entiers ; indentation = frontières du bloc.

📖 8. Boucle while et conditions d’arrêt

🔑 Notions clés & Définitions

• Boucle while : Structure de contrôle qui exécute un bloc tant qu’une condition reste vraie.
• Condition de boucle : Expression testée à chaque itération pour décider de continuer ou d’arrêter la boucle while.
• Initialisation d’itération : Mise en place de la variable avant d’entrer dans la boucle while.
• Mise à jour d’itération : Modification de la variable dans le corps de la boucle pour faire évoluer la condition.
• input() : Fonction qui lit une entrée utilisateur sous forme de chaîne de caractères.

📝 Points essentiels

• Une boucle while exécute des instructions tant que la condition est vraie.
• Elle nécessite : initialisation, test de la condition, puis mise à jour dans le corps.
• Si la condition est toujours vraie, la boucle ne s’arrête jamais.
• On peut stopper une boucle non finissante avec CTRL - C.
• while est souvent combinée à input() : on lit une chaîne puis on peut convertir en entier avec int(response).
• Pour sortir de la boucle, il faut casser la condition (la faire devenir fausse).

💡 Astuce mémo

while = tant que vrai ; si rien ne change, boucle infinie.

📖 9. Tests conditionnels if, elif et else

🔑 Notions clés & Définitions

• if : Instruction qui exécute un bloc seulement si une condition est vraie.
• elif : Instruction qui ajoute des conditions supplémentaires après un if.
• else : Instruction qui exécute un bloc lorsque toutes les conditions précédentes sont fausses.
• Bloc conditionnel : Ensemble d’instructions exécutées sous if/elif/else, délimité par l’indentation.
• Tests imbriqués : Cas où une condition contient une autre condition à l’intérieur de son bloc.

📝 Points essentiels

• Les tests permettent à l’ordinateur de prendre une décision via l’instruction if.
• Le test se termine par « : » et attend un bloc d’instructions.
• En cas de plusieurs tests, on utilise if et else pour gérer les alternatives.
• Avec if et elif, dès qu’une condition est vraie, le test s’arrête.
• L’indentation détermine quel bloc appartient à quel if/for (erreur fréquente).
• Les tests peuvent être multiples et même imbriqués, avec des indentations à plusieurs niveaux.

💡 Astuce mémo

if/elif/else = une seule branche s’exécute ; indentation = qui appartient à qui.

📖 10. Modules et importation de bibliothèques

🔑 Notions clés & Définitions

• Module : Programme Python réutilisable qui regroupe des fonctions liées à un thème.
• import : Instruction qui charge un module ou des éléments depuis un module.
• Alias : Nom raccourci donné à un module pour réduire la longueur des appels.
• help() : Fonction qui affiche de l’aide sur un objet (ici un module importé).
• Module os : Module qui gère l’interface avec le système d’exploitation.

📝 Points essentiels

• Les modules contiennent des fonctions réutilisables, appelées librairies dans le langage courant.
• Avant de coder from scratch, il faut vérifier si une fonctionnalité existe déjà sous forme de module.
• Il existe plus de 300 modules.
• La fonction import permet d’importer des éléments organisés par thème.
• On peut importer un thème particulier ou importer toute la librairie puis utiliser ses fonctions.
• On peut définir un alias pour écourter l’appel d’un module (selon l’import).

💡 Astuce mémo

Modules = fonctions prêtes ; import = chargement ; help() = mode d’emploi.

📖 11. Jupyter Notebook : cellules, exécution et magic

🔑 Notions clés & Définitions

• Jupyter Notebook : Environnement interactif qui regroupe texte et code dans un même document.
• Cellule : Élément de base d’un notebook pouvant contenir du texte Markdown ou du code exécutable.
• État d’exécution In [*] : Indication que la cellule est en cours d’exécution ou non encore terminée.
• État d’exécution In [nombre] et Out [nombre] : Indication que la cellule a été exécutée et que son résultat est affiché.
• Magic commande : Commande spéciale préfixée par % ou ! pour piloter Jupyter ou exécuter des actions système.

📝 Points essentiels

• Un notebook rassemble texte, documents, images, formules et code informatique.
• La cellule peut contenir du Markdown ou du code exécutable.
• L’exécution se fait directement sur l’éditeur dans l’environnement Jupyter.
• Run exécute une cellule et l’état passe de In [*] à In [nombre] avec un Out [nombre] si un résultat est produit.
• Il est recommandé d’exécuter les cellules dans l’ordre (manuellement ou Kernel à Restart & Run all).
• %matplotlib inline permet d’incorporer les figures dans un notebook et se lance une seule fois au début (1ère cellule).

💡 Astuce mémo

Cellule = unité ; Run = exécuter ; %matplotlib inline = figures intégrées.

📊 Tableaux de synthèse

for vs while

Structure	Condition	Arrêt
for	Parcours d’une séquence	Fin quand la séquence est épuisée
while	Condition vraie	Fin quand la condition devient fausse (sinon boucle infinie)

⚠️ Pièges & confusions fréquents

1. Confondre l’indice négatif avec un indice invalide : animaux[-1] renvoie le dernier élément.
2. Oublier l’indentation : elle détermine quel bloc appartient à for/if/else et peut changer totalement le résultat.
3. Faire une boucle while avec une condition toujours vraie sans mise à jour : la boucle ne s’arrête jamais.
4. Utiliser une f-string sans valeur entre {} : cela provoque une erreur.
5. Mélanger les types dans min(), max(), sum() : les fonctions attendent des éléments compatibles (int/float/list ne doivent pas être mélangés comme argument).

✅ Checklist Examen

1. Citer les caractéristiques de Python : multiplateforme, gratuit, haut niveau, interprété, orienté objet, usage IA/analyse de données.
2. Définir une variable et expliquer le typage dynamique (déduction du type à partir de la valeur) et le rôle de type(x).
3. Savoir reconnaître et utiliser **, //, % et += pour la puissance, le quotient entier, le modulo et l’incrémentation.
4. Décrire l’effet de + et * sur les chaînes (concaténation et duplication) et éviter les opérations illicites.
5. Expliquer print() : retour à la ligne par défaut, usage de end pour supprimer le saut, usage de sep pour séparer plusieurs arguments.
6. Construire une f-string avec {} et appliquer une spécification de format (précision décimale et notation scientifique via e).
7. Accéder aux éléments d’une liste avec des indices (0 au début, -1 pour le dernier) et extraire des tranches [m:n+1] et [début:fin:pas].
8. Utiliser len() pour la longueur, range() pour générer des entiers, et list() si nécessaire pour convertir une séquence en liste.
9. Calculer min(), max() et sum() sur une liste en respectant la compatibilité des types des éléments.
10. Écrire une boucle for correcte : variable d’itération, deux points :, et indentation du corps.
11. Écrire une boucle for avec range(n) et range(début, fin, pas) en comprenant l’intervalle décrit.
12. Écrire une boucle while avec initialisation, test, mise à jour, et savoir qu’une condition toujours vraie mène à une boucle infinie.
13. Combiner while avec input() et convertir une entrée en entier avec int(response) quand demandé.
14. Écrire des tests if/elif/else avec : et indentation, et comprendre que dès qu’une condition est vraie dans if/elif, on sort du test (une seule branche).