Cours Python - Programmations: Concepts Fondamentaux - Pratique (PDF)

Programmations : Concepts fondamentaux- Pratique Cours Python Bachelier en informatique– Finalité Télécommunications et réseaux – Bloc 1. Rédigé par : Depreter Johan – [email protected] Desmet Erwin – [email protected]  Ann...

Programmations : Concepts fondamentaux- Pratique Cours Python Bachelier en informatique– Finalité Télécommunications et réseaux – Bloc 1. Rédigé par : Depreter Johan – [email protected] Desmet Erwin – [email protected]  Année académique 2024-2025 Table des matières 1. Introduction / Rappels des concepts................................................. 11 1.1 Introduction................................................................................ 11 1.1.1 Comment fonctionne un programme informatique ?....................... 11 1.1.2 Les langages naturels vs les langages de programmation................ 12 1.1.3 De quoi est composé un langage ?............................................... 13 1.1.4 Compilation ou Interprétation................................................... 14 1.1.5 Que fais un interpréteur ?........................................................ 15 1.1.6 Qu’est-ce que Python ?............................................................ 17 1.1.7 Qui a créé Python ?................................................................. 17 1.1.8 Les objectifs de Python............................................................ 18 1.1.9 Pourquoi Python est si spécial et adapté pour vous ?................... 19 1.1.10 Les concurrents directs de Python au niveau prédisposition........ 20 1.1.11 Ou Python semble peu porteur ?............................................ 20 1.2 Les différents types de Python....................................................... 21 1.2.1 Python 2 ou Python 3 ?.............................................................. 21 1.2.2 Python aka CPython................................................................... 22 1.2.3 Cython..................................................................................... 22 1.2.4 Jython.................................................................................. 23 1.2.5 PyPy et RPython........................................................................ 23 1.3 Comment obtenir Python et l’utiliser ?............................................. 24 1.3.1 Obtenir Python....................................................................... 24 1.3.2 Testons l’installations de Python............................................... 25 1.3.3 Règle importante.................................................................... 26 1.3.4 Ecrire son premier programme................................................. 26 2. Types de données, variables, opérations entrées-sorties, opérateurs de base 27 2.1 Premier programme..................................................................... 27 2.1.1 Hello World.............................................................................. 27 2.1.2 La fonction print().................................................................. 28 2.1.3 La semantique de print()......................................................... 30 2.1.4 Mais à quoi sert ce print ?........................................................ 32 2.1.5 Les instructions...................................................................... 33 2.1.6 Les caractères d’échappement et les nouvelles lignes.................. 34 2.1.7 Ajoutons des arguments.......................................................... 35 2.1.8 Les mots-clés de la fonction print()........................................... 36 2.1.9 Exercices................................................................................. 38 2.1.10 Résumé.............................................................................. 40 2  Année académique 2024-2025 2.2. Les littéraux.................................................................................. 41 2.2.1 Introduction............................................................................. 41 2.2.2 Faisons une expérience........................................................... 41 2.2.3 Les entiers (integers)................................................................. 42 2.2.3 Les Réels ou nombres flottants (float)....................................... 44 2.2.4 La guerre des entiers et des réels............................................. 45 2.2.5 Le codage des nombres flottants............................................... 46 2.2.6 Les strings............................................................................. 47 2.2.7 Valeurs booléénnes (Boolean).................................................. 48 2.2.8 Exercice................................................................................ 49 2.2.9 Résumé................................................................................ 50 2.3 Les opérateurs............................................................................. 51 2.3.1 Python est une calculatrice...................................................... 51 2.3.2 Les opérateurs de bases.......................................................... 51 2.3.3 L’exponentiel......................................................................... 52 2.3.4 La multiplication..................................................................... 52 2.3.5 La division............................................................................. 52 2.3.6 La division entière.................................................................. 53 2.3.7 Le modulo............................................................................. 54 2.3.8 La division par zéro................................................................. 55 2.3.9 L’addition.............................................................................. 55 2.3.10 L’opérateur de soustraction, les opérateurs unaires et binaires... 55 2.3.11 Les priorités des opérations................................................... 56 2.3.12 La liste des priorités............................................................. 57 2.3.13 Les parenthèses.................................................................. 57 2.3.14 Résumé.............................................................................. 58 2.4 Les variables............................................................................... 59 2.4.1 Introduction........................................................................... 59 2.4.2 Les noms corrects.................................................................. 60 2.4.3 Les mots-clés......................................................................... 60 2.4.4 Créaton de variables............................................................... 61 2.4.5 Essayons d’affecter une variable déjà existante........................... 63 2.4.6 Pythagore et les mathématiques............................................... 64 2.4.7 Exercice................................................................................ 65 2.4.8 Les opérateurs raccourcis........................................................ 66 2.4.9 Exercices............................................................................... 67 2.4.10 Résumé.............................................................................. 70 2.5 Les commentaires........................................................................ 71 3  Année académique 2024-2025 2.5.1 Laisser des commentaires dans le code : pourquoi, comment et quand...................................................................................................... 71 2.5.2 Exercice................................................................................ 73 2.5.3 Résumé................................................................................ 74 2.6 Parlons avec notre ordinateur/programme....................................... 75 2.6.1 La fonction input()..................................................................... 75 2.6.2 Ajoutons un argument à notre fonction...................................... 76 2.6.3 Le résultat de notre fonction input ()......................................... 76 2.6.4 La fonction input() - opérations interdites.................................. 76 2.6.5 Formatage des types (cast)...................................................... 77 2.6.6 Bonus sur input() et la conversion de type................................. 78 2.6.7 Opérateurs de chaîne – introduction.......................................... 79 2.6.8 exercices............................................................................... 81 2.6.9 Résumé................................................................................ 84 3. Valeurs booléennes et exécution conditionnelle........................................ 85 3.1 Les comparateurs........................................................................... 85 3.1.1 Questions et réponses................................................................ 85 3.1.2 La comparaison ou l’opérateur d’égalité........................................ 85 3.1.3 L’opérateur d’inégalité............................................................... 86 3.1.4 Opérateur de comparaison : supérieur à...................................... 87 3.1.5 Opérateur de comparaison : supérieur ou égal à............................ 87 3.1.6 Opérateurs de comparaison : inférieure à et inférieur ou égal à....... 87 3.1.7 Que faire des réponses ?............................................................ 88 3.1.8 Exercice................................................................................... 88 3.2 Prendre des décisions en Python....................................................... 89 3.2.1 Les conditions et leur exécution................................................... 89 3.2.2 La condition – if........................................................................ 91 3.2.3 La condition – if-else.................................................................. 91 3.2.4 L’imbrication sorcellerie ou réalité ?............................................. 92 3.2.5 La condition – elif...................................................................... 93 3.2.6 Analyse des exemples de code.................................................... 94 3.2.7 Pseudo-code et introduction aux boucles..................................... 95 3.2.8 Exercices................................................................................. 98 3.2.9 Résumé.................................................................................. 101 4. Les boucles....................................................................................... 104 4.1 La boucle while.............................................................................. 104 4.1.1 La boucle infinie....................................................................... 105 4.1.2 Exemple bonus........................................................................ 106 4  Année académique 2024-2025 4.1.3 Utilisation d’un compteur dans une boucle................................... 107 4.1.4 Exercice.................................................................................. 108 4.2 La boucle for................................................................................. 109 4.2.1 La boucle for et son fonctionnement............................................ 109 4.2.2 Encore plus de pouvoir avec 3 arguments.................................... 110 4.2.3 Exercice.................................................................................. 112 4.2.3 Les mots-clés : break et continue............................................... 113 4.2.4 Quelques exemples.................................................................. 114 4.2.5 Exercices................................................................................ 115 4.2.6 Le else et la boucle while........................................................... 118 4.2.7 Le else et la boucle for.............................................................. 118 4.2.8 Exercices................................................................................ 119 4.3 Résumé........................................................................................ 121 5. La logique informatique....................................................................... 124 5.1 Introduction.................................................................................. 124 5.1.1 Le et...................................................................................... 124 5.1.2 Le ou...................................................................................... 125 5.1.3 Le non.................................................................................... 125 5.2 Les expressions logique.................................................................. 125 5.3 Valeurs logiques vs bits uniques....................................................... 126 5.4 Opérateurs binaires........................................................................ 126 5.5 Résumé........................................................................................ 128 6. Les listes........................................................................................... 130 6.1 La base des listes.......................................................................... 130 6.1.1 Pourquoi les listes sont-elles utiles ?........................................... 130 6.1.2 L’index.................................................................................... 131 6.1.3 Accès au contenu d’une liste...................................................... 132 6.1.4 Supprimer les éléments de la liste.............................................. 133 6.1.5 Les indices négatifs.................................................................. 133 6.1.6 Exercice.................................................................................. 134 6.1.7 Fonctions vs Méthodes.............................................................. 135 6.1.8 Ajout d’éléments à une liste : append() et insert()........................ 136 6.1.9 Utilisons mieux nos listes........................................................... 137 6.1.10 Travaillons avec nos listes........................................................ 138 6.1.11 Exercice................................................................................ 140 6.1.12 Résumé................................................................................. 141 6.2 Trier une liste simple...................................................................... 143 6.2.1 Le tri à bulles........................................................................... 143 5  Année académique 2024-2025 6.2.2 Créons une version interactive du tri........................................... 145 6.2.3 Résumé.................................................................................. 146 6.3 Les opérations sur les listes............................................................. 147 6.3.1 la vie intérieure des listes............................................................. 147 6.3.2 Les indices négatives dans le slice.............................................. 148 6.3.3 Spécificités du slice, les omissions.............................................. 149 6.3.4 Spécificités du slice avec del...................................................... 149 6.3.5 Les opérateurs in et not in......................................................... 150 6.3.6 Quelques exemples de programmes............................................ 151 6.3.7 Exercice.................................................................................. 153 6.3.8 Résumé.................................................................................. 153 6.4 Listes multidimensionnelles............................................................. 156 6.4.1 Une liste dans une liste............................................................. 156 6.4.2 Passons en 2 D........................................................................ 157 6.4.3 Applications avancées du multidimensionnel................................. 159 6.4.4 Le tridimensionnel.................................................................... 161 6.4 Résumé........................................................................................ 162 7. Les fonctions..................................................................................... 164 7.1 Les fonctions................................................................................. 164 7.1.1 Pourquoi en avons-nous besoin ?................................................ 164 7.1.2 La décomposition..................................................................... 165 7.1.3 Mais d’où viennent les fonctions ?............................................... 166 7.1.4 Première fonction..................................................................... 166 7.1.5 Allons plus loin dans le fonctionnement....................................... 168 7.1.6 Résumé.................................................................................. 170 7.2 Les fonctions paramétrées.............................................................. 171 7.2.1 Transmission de paramètres positionnels..................................... 174 7.2.2 Passage d’arguments par mot-clé............................................... 175 7.2.3 Mélange d’arguments positionnels et de mots-clés........................ 175 7.2.4 Fonctions paramétrées, infos complémentaires............................. 177 7.2.5 Résumé.................................................................................. 178 7.3 Effets et résultats des fonctions....................................................... 180 7.3.1 L’instruction de retour............................................................... 180 7.3.2 Quelques mots sur None........................................................... 182 7.3.4 Listes et fonctions.................................................................... 184 7.3.5 Exercices................................................................................ 185 7.3.6 Résumé.................................................................................. 190 7.4 Fonctions et portées....................................................................... 192 6  Année académique 2024-2025 7.4.1 Le mot-clé global...................................................................... 193 7.4.2 L’interaction avec les arguments................................................. 194 7.4.3 Résumé.................................................................................. 196 7.5 Création de fonctions simples.......................................................... 198 7.5.1 Création d’une fonction à deux paramètres.................................. 198 7.5.2 Jouons avec un triangle............................................................. 201 7.5.3 Les factorielles......................................................................... 204 7.5.4 La suite de Fibonaci.................................................................. 205 7.5.5 La récursion............................................................................ 206 7.5.6 Résumé.................................................................................. 207 8 Tuples et dictionnaire........................................................................... 208 8.1 Types de séquences et mutabilité..................................................... 208 8.2 Qu’est-ce qu’un tuple ?................................................................... 209 8.2.1 Comment créer un tuple ?......................................................... 209 8.2.2 Comment utiliser un tuple?........................................................ 210 8.3 Qu’est-ce qu’un dictionnaire?........................................................... 212 8.3.1 Comment faire un dictionnaire?.................................................. 213 8.3.2 Comment utiliser un dictionnaire?............................................... 214 8.3.4 Comment utiliser un dictionnaire: les clés().................................. 215 8.3.5 La fonction sorted()................................................................. 216 8.3.6 Comment utiliser un dictionnaire : méthodes items() et values().. 216 8.3.7 Comment utiliser un dictionnaire : modification et ajout de valeurs. 217 8.3.8 Ajout d’une nouvelle clé............................................................ 217 8.3.9 Suppression d’une clé............................................................... 217 8.4 Les tuples et les dictionnaires peuvent fonctionner ensemble............... 218 8.5 Résumé des tuples......................................................................... 220 8.6 Résumé des dictionnaires................................................................ 222 8.7 Résumé : tuples et dictionnaires...................................................... 224 9. Les exceptions................................................................................... 226 9.1 Le pain quotidien du développeur..................................................... 226 9.2 Erreur de code ou erreur de données................................................ 226 9.3 Quand les données ne sont pas ce qu’elles devraient........................ 227 9.4 le Try-except................................................................................. 228 9.5 L’exception prouve la règle.............................................................. 229 9.6 La gestion de plusieurs erreurs possibles........................................... 230 9.7 L’exception par défaut.................................................................... 231 9.8 Les exceptions les plus courantes..................................................... 231 9.8.1 ZeroDivisionError..................................................................... 231 7  Année académique 2024-2025 9.8.2 ValueError............................................................................... 231 9.8.3 TypeError................................................................................ 232 9.8.4 AttributeError.......................................................................... 232 9.8.5 SyntaxError............................................................................. 232 10 Les tests.......................................................................................... 233 10.1 Tester son code est une obligation, une loi DSTienne !...................... 233 10.2 Quand python ferme les yeux........................................................ 234 10.3 Tests, essais et testeurs................................................................ 235 10.3.1 Bug vs débogage.................................................................... 235 10.4 Débug d’impression...................................................................... 236 10.5 Quelques conseils utiles................................................................ 236 10.6 Les tests unitaires -Le codage de haut niveau.................................. 237 10.7 Résumé chapitre 9 et 10............................................................... 238 10.8 Exercice...................................................................................... 241 11 Les chaînes de caractères et les listes en détails.................................... 245 11.1 La nature des chaînes de caractères en Python................................. 245 11.1.1 Les chaines en détails............................................................. 245 11.1.2 Chaînes multilignes................................................................. 246 11.1.3 Opérations sur les chaînes....................................................... 247 11.1.4 Opérations sur les chaînes : ord()............................................. 248 11.1.5 Opérations sur les chaînes : chr()............................................. 248 11.1.6 Chaînes en tant que séquences: indexation................................ 249 11.1.7 Chaînes en tant que séquences: itération................................... 249 11.1.8 Tranches/plages..................................................................... 249 11.1.9 Les opérateurs in et not in..................................................... 250 11.1.10 Les chaînes Python sont immuables......................................... 252 11.1.11 Opérations sur chaînes : min()............................................... 253 11.1.12 Opérations sur les chaînes : max().......................................... 254 11.1.13 Opérations sur les chaînes : méthode index()........................... 254 11.1.14 Opérations sur les chaînes : fonction list()................................ 255 11.1.15 Opérations sur les chaînes : méthode count()........................... 255 11.1.16 Résumé............................................................................... 255 11.2 Les méthodes des string............................................................... 257 11.2.1 La méthode capitalize().......................................................... 257 11.2.2 La méthode center().............................................................. 258 11.2.3 La méthode endswith()........................................................... 258 11.2.4 La méthode find().................................................................. 259 11.2.5 La méthode isalnum()............................................................ 260 8  Année académique 2024-2025 11.2.6 La méthode isalpha()............................................................. 261 11.2.7 La méthode isdigit()............................................................... 261 11.2.8 La méthode islower()............................................................. 261 11.2.9 La méthode isspace()............................................................. 262 11.2.10 La méthode isupper()........................................................... 262 11.2.11 La méthode join()................................................................ 262 11.2.12 La méthode lower().............................................................. 263 11.2.13 La méthode lstrip().............................................................. 263 11.2.14 La méthode replace()........................................................... 264 11.2.15 La méthode rfind()............................................................... 264 11.2.16 La méthode rstrip().............................................................. 265 11.2.17 La méthode split()............................................................... 265 11.2.18 La méthode startswith()....................................................... 265 11.2.19 La méthode strip()............................................................... 265 11.2.20 La méthode swapcase()........................................................ 266 11.2.21 La méthode title()................................................................ 266 11.2.22 La méthode upper()............................................................. 266 11.2.23 Résumé............................................................................... 267 11.2.24 Exercice.............................................................................. 269 11.3 Les strings en folie.................................................................... 270 11.3.1 Comparaison de chaînes.......................................................... 270 11.3.2 Classement............................................................................ 271 11.3.4 Chaînes et nombres................................................................ 273 11.3.5 Principaux points à retenir....................................................... 274 11.3.6 Exercice................................................................................ 275 11.4 Quelques petits projets................................................................. 277 11.4.1 Le chiffre de César : chiffrer un message................................... 277 11.4.2 Le Chiffrement César : décrypter un message............................. 278 11.4.3 Le processeur de nombres....................................................... 279 11.4.4 Le validateur IBAN.................................................................. 280 11.4.5 Principaux points à retenir....................................................... 282 14.4.6 Exercices............................................................................... 283 11.5 Les erreurs, pain quotidien du programmeur.................................... 289 11.5.1 Erreurs, échecs et autres fléaux................................................ 289 11.5.2 Les exceptions.......................................................................... 290 11.5.3 L’anatomie d’une exception...................................................... 290 15.5.3 Raise.................................................................................... 294 15.5.4 assert................................................................................... 296 9  Année académique 2024-2025 15.5.5 Principaux points à retenir....................................................... 297 15.6 Exception utile.......................................................................... 299 15.6.1 Exceptions intégrées............................................................... 299 IndexError....................................................................................... 300 15.6.2 Exercice................................................................................ 303 15.6.3 Résumé................................................................................. 304 16 Les fichiers....................................................................................... 305 16.1 Accès aux fichiers à partir du code Python....................................... 305 16.2 Noms de fichiers.......................................................................... 305 16.3 Flux de fichiers............................................................................ 308 16.4 Gestion des fichiers...................................................................... 309 16.5 Ouverture des flux....................................................................... 311 16.5.1 Ouverture des flux : modes...................................................... 312 16.5.2 Sélection des modes texte et binaire......................................... 312 16.5.3 Ouverture du flux pour la première fois...................................... 313 16.5.4 Flux pré-ouverts..................................................................... 314 16.5.5 Fermeture des flux................................................................. 315 16.5.6 Diagnostic des problèmes de flux.............................................. 315 16.5.7 Diagnostic des problèmes de flux, la suite.................................. 316 16.5.8 Principaux points à retenir....................................................... 317 16.6 Le travail sur les fichiers texte....................................................... 319 16.6.1 Traitement des fichiers texte.................................................... 319 16.6.2 Traitement des fichiers texte : readline()................................... 322 16.6.3 Traitement des fichiers texte : readlines().................................. 322 16.6.4 Traitement des fichiers texte : on s’accroche !............................ 324 16.6.5 Traitement des fichiers texte : write()....................................... 324 16.6.6 Traitement des fichiers texte : Avec des lignes entières Mr ?......... 325 16.6.7 Exercices............................................................................... 326 16.6.8 Résumé................................................................................. 329 10  Année académique 2024-2025 1. Introduction / Rappels des concepts 1.1 Introduction 1.1.1 Comment fonctionne un programme informatique ? Ce cours vise à vous montrer ce qu’est le langage Python et à quoi il sert. Commençons par les bases absolues. Un programme rend un ordinateur utilisable. Sans programme, un ordinateur, même le plus puissant, n’est rien de plus qu’un objet. De même, sans joueur, un piano n’est rien de plus qu’une boîte en bois. Les ordinateurs sont capables d’effectuer des tâches très complexes, mais cette capacité n’est pas innée. La nature d’un ordinateur est tout à fait différente. Il ne peut exécuter que des opérations extrêmement simples. Par exemple, un ordinateur ne peut pas comprendre la valeur d’une fonction mathématique compliquée par lui-même, bien que cela ne soit pas hors du domaine du possible dans un proche avenir. Les ordinateurs contemporains ne peuvent évaluer que les résultats d’opérations très fondamentales, comme l’addition ou la division, mais ils peuvent le faire très rapidement et peuvent répéter ces actions pratiquement n’importe quel nombre de fois. Imaginez que vous voulez connaître la vitesse moyenne que vous avez atteinte au cours d’un long voyage. Vous connaissez la distance, vous connaissez l’heure, vous avez besoin de la vitesse. Naturellement, l’ordinateur sera capable de calculer cela, mais l’ordinateur n’est pas conscient de choses telles que la distance, la vitesse ou le temps. Par conséquent, il est nécessaire de demander à l’ordinateur de: accepter un nombre représentant la distance; accepter un nombre représentant le temps de déplacement; diviser la première valeur par la seconde et stocker le résultat dans la mémoire ; Affichez le résultat (représentant la vitesse moyenne) dans un format lisible. Ces quatre actions simples forment un programme. Bien sûr, ces exemples ne sont pas formalisés, et ils sont très loin de ce que l’ordinateur peut comprendre, mais ils sont assez bons pour être traduits dans une langue que l’ordinateur peut accepter. La langue est le mot-clé. 11  Année académique 2024-2025 1.1.2 Les langages naturels vs les langages de programmation Une langue est un moyen (et un outil) d’exprimer et d’enregistrer des pensées. Il y a beaucoup de langues tout autour de nous. Certains d’entre eux ne nécessitent ni parler ni écrire, comme le langage corporel; Il est possible d’exprimer vos sentiments les plus profonds très précisément sans dire un mot. Une autre langue que vous utilisez chaque jour est votre langue maternelle, que vous utilisez pour manifester votre volonté et méditer sur la réalité. Les ordinateurs ont aussi leur propre langage, appelé langage machine, qui est très rudimentaire. Un ordinateur, même le plus sophistiqué techniquement, est dépourvu même d’une trace d’intelligence. On pourrait dire que c’est comme un chien bien dressé - il ne répond qu’à un ensemble prédéterminé de commandes connues. Les commandes qu’il reconnaît sont très simples. On peut imaginer que l’ordinateur réponde à des ordres comme « prendre ce nombre, diviser par un autre et enregistrer le résultat ». Un ensemble complet de commandes connues est appelé une liste d’instructions, parfois abrégée en IL. Différents types d’ordinateurs peuvent varier en fonction de la taille de leurs IL, et les instructions peuvent être complètement différentes dans différents modèles. Remarque : les langages machine sont développés par des humains. Aucun ordinateur n’est actuellement capable de créer une nouvelle langue. Cependant, cela pourrait bientôt changer. Tout comme les gens utilisent un certain nombre de langages très différents, les machines ont aussi de nombreux langages différents. La différence, cependant, est que les langues humaines se sont développées naturellement. De plus, ils continuent d’évoluer, et de nouveaux mots sont créés chaque jour à mesure que les anciens disparaissent. Ces langues sont appelées langues naturelles. 12  Année académique 2024-2025 1.1.3 De quoi est composé un langage ? On peut dire que chaque langage (machine ou naturel, peu importe) se compose des éléments suivants : un alphabet : un ensemble de symboles utilisés pour construire des mots d’une certaine langue (par exemple, l’alphabet latin pour l’anglais, l’alphabet cyrillique pour le russe, le kanji pour le japonais, etc.) un lexique : (alias un dictionnaire) un ensemble de mots que la langue offre à ses utilisateurs (par exemple, le mot « computer » vient du dictionnaire de langue anglaise, alors que « mcopture » ne le fait pas ; le mot « chat » est présent dans les dictionnaires anglais et français, mais leurs significations sont différentes) une syntaxe : un ensemble de règles (formelles ou informelles, écrites ou ressenties intuitivement) utilisées pour déterminer si une certaine chaîne de mots forme une phrase valide (par exemple, « Je suis un python » est une phrase syntaxiquement correcte, alors que « Je un python suis» ne l’est pas) sémantique: un ensemble de règles déterminant si une certaine phrase a un sens (par exemple, « J’ai mangé un beignet » a du sens, mais « Un beignet m’a mangé » n’en a pas) L’IL est, en fait, l’alphabet d’un langage machine. C’est l’ensemble de symboles le plus simple et le plus primaire que nous puissions utiliser pour donner des commandes à un ordinateur. C’est la langue maternelle de l’ordinateur. Malheureusement, cette langue est loin d’être une langue maternelle humaine. Nous avons tous (ordinateurs et humains) besoin de quelque chose d’autre, d’un langage commun pour les ordinateurs et les humains, ou d’un pont entre les deux mondes différents. Nous avons besoin d’un langage dans lequel les humains peuvent écrire leurs programmes et d’un langage que les ordinateurs peuvent utiliser pour exécuter les programmes, un langage beaucoup plus complexe que le langage machine et pourtant beaucoup plus simple que le langage naturel. Ces langages sont souvent appelés langages de programmation de haut niveau. Ils sont au moins un peu similaires aux naturels en ce sens qu’ils utilisent des symboles, des mots et des conventions lisibles par les humains. Ces langages permettent aux humains d’exprimer des commandes à des ordinateurs beaucoup plus complexes que ceux proposés par les IL. Un programme écrit dans un langage de programmation de haut niveau est appelé code source (par opposition au code machine exécuté par les ordinateurs). De même, le fichier contenant le code source est appelé fichier source. 13  Année académique 2024-2025 1.1.4 Compilation ou Interprétation La programmation informatique est l’acte de composer les éléments du langage de programmation sélectionné dans l’ordre qui provoquera l’effet désiré. L’effet peut être différent dans chaque cas spécifique - cela dépend de l’imagination, des connaissances et de l’expérience du programmeur. Bien sûr, une telle composition doit être correcte à plusieurs égards: alphabétique - un programme doit être écrit dans un script reconnaissable, tel que romain, cyrillique, etc. lexicalement - chaque langage de programmation a son dictionnaire et vous devez le maîtriser; Heureusement, c’est beaucoup plus simple et plus petit que le dictionnaire de n’importe quel langage naturel; syntaxiquement - chaque langage a ses règles et elles doivent être respectées; Sémantiquement - le programme doit avoir un sens. Malheureusement, un programmeur peut également faire des erreurs avec chacun des quatre sens ci-dessus. Chacun d’eux peut rendre le programme complètement inutile. Supposons que vous avez écrit un programme avec succès. Comment persuadons-nous l’ordinateur de l’exécuter? Vous devez convertir votre programme en langage machine. Heureusement, la traduction peut être effectuée par un ordinateur lui-même, ce qui rend l’ensemble du processus rapide et efficace. Il existe deux façons différentes de transformer un programme d’un langage de programmation de haut niveau en langage machine : COMPILATION - le programme source est traduit une fois (cependant, cet acte doit être répété chaque fois que vous modifiez le code source) en obtenant un fichier (par exemple, un fichier.exe si le code est destiné à être exécuté sous MS Windows) contenant le code machine; vous pouvez maintenant distribuer le fichier dans le monde entier; le programme qui effectue cette traduction est appelé compilateur ou traducteur; INTERPRÉTATION - vous (ou tout utilisateur du code) pouvez traduire le programme source chaque fois qu’il doit être exécuté; le programme effectuant ce type de transformation est appelé un interpréteur, car il interprète le code chaque fois qu’il est destiné à être exécuté; cela signifie également que vous ne pouvez pas simplement distribuer le code source tel quel, Parce que l’utilisateur final a également besoin de l’interpréteur pour l’exécuter. Pour des raisons très fondamentales, un langage de programmation de haut niveau particulier est conçu pour entrer dans l’une de ces deux catégories. Il y a très peu de langages qui peuvent être à la fois compilés et interprétés. 14  Année académique 2024-2025 1.1.5 Que fais un interpréteur ? Supposons une fois de plus que vous avez écrit un programme. Maintenant, il existe sous la forme d’un fichier informatique: un programme informatique est en fait un morceau de texte, de sorte que le code source est généralement placé dans des fichiers texte. Remarque: il doit s’agir de « texte pur », sans aucune « décoration » comme différentes polices, couleurs, images intégrées ou autres médias. Vous devez maintenant appeler l’interpréteur et le laisser lire votre fichier source. L’interprète lit le code source d’une manière courante dans la culture occidentale : de haut en bas et de gauche à droite. Il y a quelques exceptions - elles seront couvertes plus tard dans le cours. Tout d’abord, l’interprète vérifie si toutes les lignes suivantes sont correctes (en utilisant les quatre aspects abordés précédemment). Si l’interprète trouve une erreur, il termine son travail immédiatement. Le seul résultat dans ce cas est un message d’erreur. L’interprète vous indiquera où se trouve l’erreur et ce qui l’a causée. Cependant, ces messages peuvent être trompeurs, car l’interprète n’est pas en mesure de suivre vos intentions exactes et peut détecter des erreurs à une certaine distance de leurs causes réelles. L’erreur n’est donc pas spécifiquement à la ligne précise retournée par l’interpréteur. Par exemple, si vous essayez d’utiliser une entité d’un nom inconnu, cela provoquera une erreur, mais l’erreur sera découverte à l’endroit où elle tente d’utiliser l’entité, et non à l’endroit où le nom de la nouvelle entité a été introduit. En d’autres termes, la raison réelle est généralement située un peu plus tôt dans le code, par exemple, à l’endroit où vous deviez informer l’interprète que vous alliez utiliser l’entité du nom. Si la ligne semble bonne, l’interpréteur essaie de l’exécuter (note: chaque ligne est généralement exécutée séparément, de sorte que le trio « lecture- vérification-exécution » peut être répété plusieurs fois - plus de fois que le nombre réel de lignes dans le fichier source, car certaines parties du code peuvent être exécutées plus d’une fois). Il est également possible qu’une partie importante du code soit exécutée avec succès avant que l’interpréteur ne trouve une erreur. Il s’agit d’un comportement normal dans ce modèle d’exécution. Vous vous demandez peut-être maintenant: quel est le meilleur? Le modèle « compilateur » ou le modèle « interprétatif » ? Il n’y a pas de réponse évidente. S’il y en avait eu, l’un de ces modèles aurait cessé d’exister depuis longtemps. Les deux ont leurs avantages et leurs inconvénients. 15  Année académique 2024-2025 COMPILATION INTERPRÉTATION L’exécution du code traduit est généralement plus Vous pouvez exécuter le rapide ; code dès que vous l’avez terminé - il n’y a pas de seul l’utilisateur doit phases supplémentaires avoir le compilateur - de traduction; l’utilisateur final peut utiliser le code sans le code est stocké à lui; l’aide du langage de programmation, pas AVANTAGES Le code traduit est celui de la machine - cela stocké en langage signifie qu’il peut être machine - comme il exécuté sur des est très difficile à ordinateurs utilisant comprendre, vos différents langages de propres inventions et machine; Vous ne astuces de compilez pas votre code programmation séparément pour chaque resteront architecture différente. probablement votre secret. La compilation elle- même peut être un Ne vous attendez pas à processus très long - ce que l’interprétation vous ne pourrez accélère votre code à peut-être pas grande vitesse - votre exécuter votre code code partagera la immédiatement après puissance de l’ordinateur une modification; INCON- avec l’interpréteur, il ne VÉNIENTS peut donc pas être très Vous devez avoir rapide; autant de compilateurs que de Vous et l’utilisateur final plates-formes devez disposer de matérielles sur l’interpréteur pour lesquelles vous exécuter votre code. souhaitez que votre code soit exécuté. 16  Année académique 2024-2025 Qu’est-ce que tout cela signifie pour vous ? Python est un langage interprété. Cela signifie qu’il hérite de tous les avantages et inconvénients décrits. Bien sûr, il ajoute certaines de ses caractéristiques uniques aux deux ensembles. Si vous souhaitez programmer en Python, vous aurez besoin de l’interpréteur Python. Vous ne pourrez pas exécuter votre code sans lui. Heureusement, Python est gratuit. C’est l’un de ses avantages les plus importants. Pour des raisons historiques, les langages conçus pour être utilisés de manière interprétative sont souvent appelés langages de script, tandis que les programmes sources encodés à l’aide de ces langages sont appelés scripts. 1.1.6 Qu’est-ce que Python ? Python est un langage de programmation largement utilisé, interprété, orienté objet et de haut niveau avec une sémantique dynamique, utilisé pour la programmation à usage général. Et bien que vous connaissiez peut-être le python comme un grand serpent, le nom du langage de programmation Python vient d’une vieille série de sketches comiques télévisés de la BBC appelée Monty Python’s Flying Circus. Au sommet de son succès, l’équipe des Monty Python présentait ses sketches à des publics du monde entier. Et Puisque Monty Python est considéré comme l’un des deux nutriments fondamentaux pour un programmeur (l’autre étant la pizza), le créateur de Python a nommé le langage en l’honneur de l’émission de télévision. 1.1.7 Qui a créé Python ? L’une des caractéristiques étonnantes de Python est le fait qu’il s’agit en fait du travail d’une seule personne. Habituellement, les nouveaux langages de programmation sont développés et publiés par de grandes entreprises employant de nombreux professionnels, et en raison des règles du droit d’auteur, il est très difficile de nommer les personnes impliquées dans le projet. Python est une exception. Il n’y a pas beaucoup de langues dont les auteurs sont connus par leur nom. Python a été créé par Guido van Rossum, né en 1956 à Haarlem, aux Pays-Bas. Bien sûr, il n’a pas développé et fait évoluer tous les composants lui-même. La vitesse à laquelle Python s’est répandu dans le monde entier est le résultat du travail continu de milliers de programmeurs, testeurs, utilisateurs (beaucoup ne sont pas des informaticiens) et de passionnés (très souvent anonymes), mais il faut dire que la toute première idée (la graine à partir de laquelle Python a germé) est venue à une tête, celle de Mr Guido. Les circonstances dans lesquelles Python a été créé sont un peu déroutantes. 17  Année académique 2024-2025 Selon Guido van Rossum : En décembre 1989, je cherchais un projet de programmation « hobby » qui m’occuperait pendant la semaine autour de Noël. Mon bureau (...) serait fermé, mais j’avais un ordinateur à la maison, et pas grand-chose d’autre entre les mains. J’ai décidé d’écrire un interpréteur pour le nouveau langage de script auquel j’avais pensé ces derniers temps : un descendant d’ABC qui plairait aux hackers Unix/C. J’ai choisi Python comme titre de travail pour le projet, étant d’humeur légèrement irrévérencieuse (et un grand fan de Monty Python’s Flying Circus). 1.1.8 Les objectifs de Python En 1999, Guido van Rossum a défini ses objectifs pour Python : un langage simple et intuitif tout aussi puissant que ceux des principaux concurrents ; l’open source, afin que tout le monde puisse contribuer à son développement ; un code aussi compréhensible que l’anglais simple; Convient aux tâches quotidiennes, permettant des temps de développement courts. Environ 20 ans plus tard, il est clair que toutes ces intentions ont été réalisées. Certaines sources disent que Python est le langage de programmation le plus populaire au monde, tandis que d’autres affirment que c’est le deuxième ou le troisième. Quoi qu’il en soit, il occupe toujours un rang élevé dans le top dix du PYPL PopularitY of Programming Language et du TIOBE Programming Community Index. Python n’est plus un langage jeune. Il est mature et digne de confiance. Ce n’est pas une merveille unique. C’est une étoile brillante dans le firmament de la programmation, et le temps passé à apprendre Python est un très bon investissement. 18  Année académique 2024-2025 1.1.9 Pourquoi Python est si spécial et adapté pour vous ? Comment se fait-il que les programmeurs, jeunes et vieux, expérimentés et novices, veuillent l’utiliser? Comment se fait-il que les grandes entreprises aient adopté Python et mis en œuvre leurs produits phares en l’utilisant? Il y a plusieurs raisons - nous en avons déjà énuméré quelques-unes, mais énumérons-les à nouveau de manière plus pratique: c’est facile à apprendre - le temps nécessaire pour apprendre Python est plus court que pour beaucoup d’autres langages; cela signifie qu’il est possible de démarrer la programmation plus rapidement; il est facile d’enseigner - la charge de travail d’enseignement est inférieure à celle requise par d’autres langages; cela signifie que l’enseignant peut mettre davantage l’accent sur les techniques de programmation générales (indépendantes de la langue), sans gaspiller d’énergie sur des astuces exotiques, des exceptions étranges et des règles incompréhensibles; il est facile à utiliser pour écrire de nouveaux logiciels - il est souvent possible d’écrire du code plus rapidement en utilisant Python; c’est facile à comprendre - il est aussi souvent plus facile de comprendre le code de quelqu’un d’autre plus rapidement s’il est écrit en Python; il est facile à obtenir, à installer et à déployer - Python est gratuit, ouvert et multiplateforme; tous les langages ne peuvent pas s’en vanter. Bien sûr, Python a aussi ses inconvénients: ce n’est pas un démon de vitesse - Python n’offre pas de performances exceptionnelles; dans certains cas, il peut être résistant à certaines techniques de test plus simples - cela peut signifier que le débogage du code de Python peut être plus difficile qu’avec d’autres langages; Heureusement que faire des erreurs est toujours plus difficile en Python. Il convient également de préciser que Python n’est pas la seule solution de ce type disponible sur le marché informatique. Il a beaucoup d’adeptes, mais il y en a beaucoup qui préfèrent d’autres langages et ne considèrent même pas Python pour leurs projets. Alors à quelle secte de programmeurs veux-tu donner ton âme ? 19  Année académique 2024-2025 1.1.10 Les concurrents directs de Python au niveau prédisposition Python a deux concurrents directs, avec des propriétés et des prédispositions comparables. Il s’agit de : Perl - un langage de script écrit à l’origine par Larry Wall; Ruby - un langage de script écrit à l’origine par Yukihiro Matsumoto. Le premier est plus traditionnel, plus conservateur que Python, et ressemble à certains des bons vieux langages dérivés du langage de programmation C classique. En revanche, le dernier est plus innovant et plus novateurs que Python. Python lui-même se situe quelque part entre ces deux vagues. Internet regorge de forums avec des discussions infinies sur la supériorité de l’un de ces trois langages sur les autres, si vous souhaitez en savoir plus sur chacun d’eux, libre à vous de voguer sur le flot d’internet. 1.1.11 Ou Python semble peu porteur ? Malgré la popularité croissante de Python, il existe encore des niches où Python est absent, ou rarement vu: programmation de bas niveau :si vous voulez implémenter un pilote ou un moteur graphique extrêmement efficace, vous n’utiliserez pas Python; applications pour appareils mobiles: bien que ce territoire attende toujours d’être conquis par Python, cela arrivera très probablement un jour. 20  Année académique 2024-2025 1.2 Les différents types de Python 1.2.1 Python 2 ou Python 3 ? Il existe deux principaux types de Python, appelés Python 2 et Python 3. Python 2 est une ancienne version du Python original. Son développement a depuis été intentionnellement bloqué, bien que cela ne signifie pas qu’il n’y ait pas de mises à jour. Au contraire, les mises à jour sont publiées régulièrement, mais elles ne sont pas destinées à modifier le langage de manière significative. Elles corrigent plutôt les bugs et les failles de sécurité fraîchement découvertes. Le chemin de développement de Python 2 a déjà atteint une impasse, mais Python 2 lui-même est toujours bien vivant. Python 3 est la version la plus récente (pour être précis, la version actuelle) du langage. Il suit son propre chemin d’évolution, créant ses propres normes et habitudes. C’est bien entendu en Python 3 que nous travaillerons. Ces deux versions de Python ne sont pas compatibles entre elles. Les scripts Python 2 ne fonctionneront pas dans un environnement Python 3 et vice versa, donc si vous voulez que l’ancien code Python 2 soit exécuté par un interpréteur Python 3, la seule solution possible est de le réécrire (sauf exception), pas à partir de zéro, bien sûr, car de grandes parties du code peuvent rester intactes, mais vous devez réviser tout le code pour trouver toutes les incompatibilités possibles. Malheureusement, ce processus ne peut pas être entièrement automatisé. Il est trop difficile, trop long, trop coûteux et trop risqué de migrer une ancienne application Python 2 vers une nouvelle plate-forme. Il est possible que la réécriture du code y introduise de nouveaux bogues. Il est plus facile et plus judicieux de laisser ces systèmes seuls et d’améliorer l’interpréteur existant, au lieu d’essayer de travailler à l’intérieur du code source déjà fonctionnel. C’est un peu comme les banques, elles ne veulent pas investir dans le déploiement d’un nouveau système bancaires alors que l’ancien fonctionne. Python 3 n’est pas seulement une meilleure version de Python 2 - c’est un langage complètement différent, bien qu’il soit très similaire à son prédécesseur. Lorsque vous les regardez de loin, ils semblent être les mêmes, mais quand vous regardez de près, vous remarquez beaucoup de différences. Si vous modifiez une ancienne solution Python existante, il est fort probable qu’elle ait été codée en Python 2. C’est la raison pour laquelle Python 2 est toujours utilisé. Il y a trop d’applications Python 2 existantes pour l’éliminer complètement. Il est important de se rappeler qu’il peut y avoir des différences plus petites ou plus grandes entre les versions ultérieures de Python 3 (par exemple, Python 3.6 a introduit des clés de dictionnaire ordonnées par défaut sous l’implémentation CPython), la bonne nouvelle, est que toutes les nouvelles versions de Python 3 sont rétrocompatibles avec les versions précédentes de Python 3. Chaque fois que cela est significatif, nous essaierons de mettre en évidence ces différences. 21  Année académique 2024-2025 1.2.2 Python aka CPython En plus de Python 2 et Python 3, il existe plus d’une version de chacun. Tout d’abord, il y a les Pythons qui sont maintenus par les personnes rassemblées autour de la PSF (Python Software Foundation), une communauté qui vise à développer, améliorer, étendre et populariser Python et son environnement. Le président du PSF est Guido von Rossum lui-même, et pour cette raison, ces pythons sont appelés canoniques. Ils sont également considérés comme des pythons de référence, car toute autre implémentation du langage doit suivre toutes les normes établies par le PSF. Guido van Rossum a utilisé le langage de programmation « C » pour implémenter la toute première version de son langage et cette décision est toujours en vigueur. Tous les Pythons provenant de la PSF sont écrits dans le langage « C ». Il y a plusieurs raisons à cette approche et elle a de nombreuses conséquences. L’un d’eux (probablement le plus important) est que grâce à lui, Python peut être facilement porté et migré vers toutes les plates-formes avec la possibilité de compiler et d’exécuter des programmes en langage « C » (pratiquement toutes les plates-formes ont cette fonctionnalité, ce qui ouvre de nombreuses possibilités d’expansion pour Python). C’est pourquoi l’implémentation PSF est souvent appelée CPython. C’est le Python le plus influent parmi tous les Pythons du monde. 1.2.3 Cython Cython est l’une des nombreuses solutions possibles au plus douloureux des traits de Python  le manque d’efficacité. Les calculs mathématiques volumineux et complexes peuvent être facilement codés en Python (beaucoup plus facile qu’en « C » ou tout autre langage traditionnel), mais l’exécution du code résultant peut prendre beaucoup de temps. Comment ces deux contradictions sont-elles conciliées ? Une solution consiste à écrire vos idées mathématiques en utilisant Python, et lorsque vous êtes absolument sûr que votre code est correct et produit des résultats valides, vous pouvez le traduire en « C » qui fonctionnera beaucoup plus vite que Python pur. C’est ce que Cython est censé faire - traduire automatiquement le code Python (propre et clair, mais pas trop rapide) en code « C » (compliqué et bavard, mais agile). 22  Année académique 2024-2025 1.2.4 Jython Une autre version de Python s’appelle Jython. « J » est pour « Java ». Imaginez un Python écrit en Java au lieu de C. Ceci est utile, par exemple, si vous développez des systèmes volumineux et complexes écrits entièrement en Java et que vous souhaitez leur ajouter une certaine flexibilité Python. Le CPython traditionnel peut être difficile à intégrer dans un tel environnement, car C et Java vivent dans des mondes complètement différents et ne partagent pas beaucoup d’idées communes. Jython peut communiquer plus efficacement avec l’infrastructure Java existante. C’est pourquoi certains projets le trouvent utilisable et nécessaire. Remarque : l’implémentation actuelle de Jython suit les normes Python 2. Il n’y a pas de Jython conforme à Python 3, jusqu’à présent (début 2023). 1.2.5 PyPy et RPython PyPy - un Python dans un Python. En d’autres termes, il représente un environnement Python écrit dans un langage de type Python nommé RPython (Restricted Python). C’est en fait un sous-ensemble de Python. Le code source de PyPy n’est pas exécuté de manière interprétative, mais est traduit dans le langage de programmation C et ensuite exécuté séparément. Ceci est utile car si vous voulez tester une nouvelle fonctionnalité qui peut être (mais n’a pas à être) introduite dans l’implémentation Python grand public, il est plus facile de la vérifier avec PyPy qu’avec CPython. C’est pourquoi PyPy est plutôt un outil pour les personnes développant Python que pour le reste des utilisateurs. Cela ne rend pas PyPy moins important ou moins sérieux que CPython, bien sûr. De plus, PyPy est compatible avec le langage Python 3. Il y a encore beaucoup plus de sortes de pythons différents dans le monde. Vous les trouverez si vous regardez, mais ce cours se concentrera sur le CPython. 23  Année académique 2024-2025 1.3 Comment obtenir Python et l’utiliser ? 1.3.1 Obtenir Python Il existe plusieurs façons d’obtenir votre propre copie de Python 3, selon le système d’exploitation que vous utilisez. Les utilisateurs de Linux ont probablement déjà installé Python - c’est le scénario le plus probable, car l’infrastructure de Python est utilisée de manière intensive par de nombreux composants du système d’exploitation Linux. Par exemple, certains distributeurs peuvent coupler leurs outils spécifiques avec le système et beaucoup de ces outils, comme les gestionnaires de paquets, sont souvent écrits en Python. Certaines parties des environnements graphiques disponibles dans le monde Linux peuvent également utiliser Python. Si vous êtes un utilisateur Linux, ouvrez-le terminal/la console et tapez : python3 à l’invite du shell, appuyez sur Entrée et patientez. Si vous voyez quelque chose comme ceci : Python 3.4.5 (par défaut, Jan 12 2017, 02:28:40) [GCC 4.2.1 Compatible Clang 3.7.1 (tags/RELEASE_371/final)] sur linux Tapez « aide », « copyright », « crédits » ou « licence » pour plus d’informations. >>> alors vous n’avez rien d’autre à faire. Si Python 3 est absent, reportez-vous à votre documentation Linux afin de savoir comment utiliser votre gestionnaire de paquets pour télécharger et installer un nouveau paquet - celui dont vous avez besoin s’appelle python3 ou son nom commence par cela. Tous les utilisateurs non-Linux peuvent télécharger une copie à https://www.python.org/downloads/. Étant donné que le navigateur indique au site que vous avez entré le système d’exploitation que vous utilisez, la seule étape que vous devez effectuer est de cliquer sur la version appropriée de Python souhaitée. Dans ce cas, sélectionnez Python 3. Le site vous en propose toujours la dernière version. Si vous êtes un utilisateur Windows, démarrez le fichier.exe téléchargé et suivez toutes les étapes. Laissez les paramètres par défaut suggérés par le programme d’installation pour l’instant, à une exception près - regardez la case à cocher nommée Ajouter Python 3.x à PATH et vérifiez-la. 24  Année académique 2024-2025 Si vous êtes un utilisateur macOS, une version de Python 2 a peut-être déjà été préinstallée sur votre ordinateur, mais comme nous travaillerons avec Python 3, vous devrez toujours télécharger et installer le fichier.pkg approprié à partir du site Python. Dans notre formation, nous utiliserons le logiciel Pycharm. Nous vous conseillons d’installer Pycharm Education pour avoir une version aboutie lors de votre cursus : https://www.jetbrains.com/pycharm-edu/ 1.3.2 Testons l’installations de Python Maintenant que Python 3 est installé, il est temps de vérifier si cela fonctionne et d’en faire la toute première utilisation. Ce sera une procédure très simple, mais elle devrait suffire à vous convaincre que l’environnement Python est complet et fonctionnel. Il existe de nombreuses façons d’utiliser Python, surtout si vous décidez d’être un développeur Python. Pour commencer votre travail, vous avez besoin des outils suivants : un éditeur qui vous aidera à écrire le code (il devrait avoir quelques fonctionnalités spéciales, non disponibles dans des outils simples); cet éditeur dédié vous donnera plus que l’équipement standard du système d’exploitation; une console dans laquelle vous pouvez lancer votre code nouvellement écrit et l’arrêter de force lorsqu’il devient incontrôlable; Un outil nommé débogueur, capable de lancer votre code étape par étape et vous permettant de l’inspecter à chaque moment d’exécution. Outre ses nombreux composants utiles, l’installation standard de Python 3 contient une application très simple mais extrêmement utile nommée IDLE. IDLE est un acronyme : Integrated Development and Learning Environment. Naviguez dans les menus de votre système d’exploitation, trouvez IDLE quelque part sous Python 3.x et lancez-le. Voici ce que vous devriez voir: Vous pouvez aussi directement lancer Pycharm 25  Année académique 2024-2025 1.3.3 Règle importante Ne définissez aucune extension pour le nom de fichier que vous allez utiliser. Python a besoin que ses fichiers aient l’extension.py, vous devez donc vous fier aux valeurs par défaut de la fenêtre de dialogue de votre IDLE. L’utilisation de l’extension.py standard permet au système d’exploitation d’ouvrir correctement ces fichiers. 1.3.4 Ecrire son premier programme Dans votre fichier.py, encodez la ligne suivante : print("ce cours est trop coooooolll") Attention ! Les 6 « o » et «3 « l » sont capitaux ! Nous n’allons pas expliquer la signification du programme pour le moment. Regardez de plus près les guillemets. Ce sont les formes les plus simples de guillemets (neutre, droit, muet, etc.) couramment utilisées dans les fichiers sources. N’essayez pas d’utiliser des guillemets typographiques (courbes, bouclés, intelligents, etc.), utilisés par les processeurs de texte avancés, car Python ne les accepte pas. Si vous lancez le programme avec le bouton run ou en faisant RunRun ‘main’ , votre script se lance et affiche le texte en vert. 26  Année académique 2024-2025 2. Types de données, variables, opérations entrées-sorties, opérateurs de base 2.1 Premier programme 2.1.1 Hello World Il est temps de commencer à écrire du vrai code Python fonctionnel. Ce sera très simple pour le moment. Comme nous allons vous montrer quelques concepts et termes fondamentaux, ces extraits de code ne seront ni sérieux ni complexes. Prenons le code suivant : print("Hello, World!") Vous pouvez lancer IDLE, créer un nouveau fichier source Python, le remplir avec ce code, nommer le fichier et l’enregistrer. Maintenant, exécutez-le. Si tout se passe bien, vous verrez la ligne dans la fenêtre de la console IDLE. Le code que vous avez exécuté doit vous sembler familier. Vous avez vu quelque chose de très similaire lorsque nous vous avons guidé dans la configuration de l’environnement IDLE. Maintenant, nous allons passer un peu de temps à vous montrer et à vous expliquer ce que vous voyez réellement, et pourquoi cela ressemble à ceci. Comme vous pouvez le voir, le premier programme comprend les parties suivantes: Le mot clé print; une parenthèse ouvrante; un guillemet; une ligne de texte : Hello, World! ; un autre guillemet; une parenthèse fermante. Chacun des éléments ci-dessus joue un rôle très important dans le code. Voyons- les. 27  Année académique 2024-2025 2.1.2 La fonction print() Regardez la ligne de code ci-dessous : print("Hello, World!") Le mot print que vous pouvez voir ici est un nom de fonction. Cela ne signifie pas que partout où le mot apparaît, il s’agit toujours d’un nom de fonction. Le sens du mot vient du contexte dans lequel le mot a été utilisé. Vous avez probablement rencontré le terme fonction plusieurs fois auparavant, pendant les cours de mathématiques. Vous pouvez probablement aussi énumérer plusieurs noms de fonctions mathématiques, comme sinus ou log. Les fonctions Python, cependant, sont plus flexibles et peuvent contenir plus de contenu que leurs frères et sœurs mathématiques. Une fonction (dans ce contexte) est une partie distincte du code informatique capable de : provoquer un certain effet (par exemple, envoyer du texte au terminal, créer un fichier, dessiner une image, jouer un son, etc.); c’est quelque chose de complètement inconnu dans le monde des mathématiques; évaluer une valeur (par exemple, la racine carrée d’une valeur ou la longueur d’un texte donné) et la renvoyer comme résultat de la fonction; c’est ce qui fait des fonctions Python les parents des concepts mathématiques. De plus, de nombreuses fonctions Python peuvent faire les deux choses ci- dessus ensemble. D’où viennent les fonctions ? Elles peuvent provenir de Python lui-même; la fonction d’impression est de ce type; une telle fonction est une valeur ajoutée reçue avec Python et son environnement (elle est intégrée); vous n’avez rien de spécial à faire si vous voulez l’utiliser; Elles peuvent provenir d’un ou plusieurs modules complémentaires nommés de Python; certains des modules sont livrés avec Python, d’autres peuvent nécessiter une installation séparée - quoi qu’il en soit, ils doivent tous être explicitement connectés à votre code (nous vous montrerons comment le faire bientôt); Vous pouvez les écrire vous-même, en plaçant autant de fonctions que vous le souhaitez et dont vous en avez besoin dans votre programme pour le rendre plus simple, plus clair et plus élégant. Le nom de la fonction doit être significatif (le nom de la fonction print est évident). Bien sûr, si vous utilisez une fonction déjà existante, vous n’avez aucune influence sur son nom, mais lorsque vous commencerez à écrire vos propres fonctions, vous devrez réfléchir attentivement à votre choix de noms. 28  Année académique 2024-2025 Comme nous l’avons dit précédemment, une fonction peut avoir : un effet; un résultat. Il y a aussi un troisième composant de fonction, très important : le(s) argument(s). Les fonctions mathématiques prennent généralement un argument, par exemple, sin(x) prend un x, qui est la mesure d’un angle. Les fonctions Python, en revanche, sont plus polyvalentes. Selon les besoins individuels, ils peuvent accepter n’importe quel nombre d’arguments  autant que nécessaire pour effectuer leurs tâches. Remarque: tout nombre inclut zéro Certaines fonctions Python n’ont besoin d’aucun argument. Malgré le nombre d’arguments nécessaires/fournis, les fonctions Python exigent fortement la présence d’une paire de parenthèses - respectivement ouvertes et fermantes. print("Hello, World!") Si vous souhaitez fournir un ou plusieurs arguments à une fonction, placez-les entre parenthèses. Si vous utilisez une fonction qui ne prend aucun argument, vous devez toujours avoir les parenthèses, elles seront juste vides. Remarque : pour distinguer les mots ordinaires des noms de fonction, placez une paire de parenthèses vides après leur nom, même si la fonction correspondante veut un ou plusieurs arguments. Il s’agit d’une convention standard. La fonction dont nous parlons ici est print(). La fonction print() de notre exemple a-t-elle des arguments ? Bien sûr que oui, mais quels sont-ils? Le seul argument fourni à la fonction print() dans cet exemple est une chaîne de caractères : print("Hello, World!") Comme vous pouvez le voir, la chaîne est délimitée par des guillemets  en fait, les guillemets font la chaîne de caractères, ils découpent une partie du code et lui attribuent une signification différente. Vous pouvez imaginer que les guillemets disent quelque chose comme: le texte entre nous n’est pas du code. Il n’est pas destiné à être exécuté, et vous devriez le prendre tel quel. 29  Année académique 2024-2025 Presque tout ce que vous mettez entre guillemets sera pris littéralement, non pas comme code, mais comme des données. Essayez de jouer avec cette chaîne particulière et modifiez-la, entrez du nouveau contenu, supprimez une partie du contenu existant, … Nous verrons plus tard qu’il y a plus d’une façon de spécifier une chaîne dans le code de Python, mais pour l’instant, cependant, celle-ci est suffisante. Sans le savoir vous venez d’apprendre un type de données : les chaînes de caractères (ou String) mais on en reparle plus tard ! Ici nous ne parlions que de syntaxe mais qu’en est-il de la sémantique ? 2.1.3 La semantique de print() Le nom de la fonction (en caractères d’imprimerie dans ce cas) ainsi que les parenthèses et les arguments forment l’appel de la fonction. print("Bonjour, Monde!") Que se passe-t-il lorsque Python rencontre un appel comme celui-ci ci-dessous ? function_name(argument) Détaillons cela : Tout d’abord, Python vérifie si le nom spécifié est légal (il parcourt ses données internes afin de trouver une fonction existante avec ce nom; si cette recherche échoue, Python abandonne le code); deuxièmement, Python vérifie si les exigences de la fonction pour le nombre d’arguments vous permettent d’invoquer la fonction de cette manière (par exemple, si une fonction spécifique exige exactement deux arguments, tout appel ne fournissant qu’un seul argument sera considéré comme erroné et interrompra l’exécution du code); troisièmement, Python quitte votre code pendant un moment et saute dans la fonction que vous souhaitez invoquer; Bien sûr, il prend aussi vos arguments et les transmet à la fonction; quatrièmement, la fonction exécute son code, provoque l’effet désiré (le cas échéant), évalue-le(s) résultat(s) souhaité(s) et termine sa tâche; enfin, Python retourne à votre code (à l’endroit juste après l’appel) et reprend son exécution. 30  Année académique 2024-2025 Temps estimé 5-10 minutes Niveau de difficulté Très facile Objectifs se familiariser avec la fonction print() et ses capacités de formatage; expérimenter avec du code Python. Scénario La commande print(), qui est l’une des directives les plus simples en Python, imprime simplement une ligne à l’écran. Dans votre premier laboratoire : utilisez la fonction print() pour imprimer la ligne Hello, mon ,nouvel ami! à l’écran. Utilisez des guillemets doubles autour de la chaîne; Cela fait, utilisez à nouveau la fonction print(), mais cette fois imprimez votre prénom; Supprimez les guillemets doubles et exécutez votre code. Regardez la réaction de Python. Quel genre d’erreur est généré? Ensuite, supprimez les parenthèses, remettez les guillemets doubles et exécutez à nouveau votre code. Quel genre d’erreur est généré cette fois- ci? Expérimentez autant que vous le pouvez. Remplacez les guillemets doubles par des guillemets simples, utilisez plusieurs fonctions print() sur la même ligne, puis sur différentes lignes. Voyez ce qui se passe. 31  Année académique 2024-2025 2.1.4 Mais à quoi sert ce print ? Trois questions importantes doivent trouver réponses à vos yeux dès que possible(et cela pour toutes les fonctions que vous utiliserez) : 1. Quel est l’effet de la fonction print() ? L’effet est très utile et très spectaculaire. La fonction : prend ses arguments (il peut accepter plus d’un argument et peut également accepter moins d’un argument) les convertit en forme lisible par l’homme si nécessaire (comme vous pouvez vous en douter, les chaînes ne nécessitent pas cette action, car la chaîne est déjà lisible) Envoie les données résultantes au périphérique de sortie (généralement la console); en d’autres termes, tout ce que vous mettez dans la fonction print() apparaîtra sur votre écran. Il n’est donc pas étonnant qu’à partir de maintenant, vous utilisiez print() de manière très intensive pour voir les résultats de vos opérations et évaluations. 2. Quels arguments print() attend-il? Quelconque. Nous vous montrerons bientôt que print() est capable de fonctionner avec pratiquement tous les types de données offertes par Python. Chaînes, nombres, caractères, valeurs logiques, objets, … n’importe lequel d’entre eux peut être passé avec succès à print(). 3. Quelle valeur la fonction print() renvoie-t-elle? Aucun. Son effet(afficher) suffit. 32  Année académique 2024-2025 2.1.5 Les instructions Nous avons donc un programme informatique qui contient un appel de fonction. Ce qui est l’un des nombreux types possibles d’instructions Python. Bien sûr, tout programme complexe contient généralement beaucoup plus d’instructions. La question est : comment coupler plus d’une instruction dans le code Python ? La syntaxe de Python est assez spécifique dans ce domaine. Contrairement à la plupart des langages de programmation, Python exige qu’il ne puisse y avoir plus d’une instruction dans une ligne. Une ligne peut être vide (c’est-à-dire qu’elle ne peut contenir aucune instruction), mais elle ne doit pas contenir deux, trois instructions ou plus. Ceci est strictement interdit. Remarque : Python fait une exception à cette règle : il permet à une instruction de s’étaler sur plus d’une ligne (ce qui peut être utile lorsque votre code contient des constructions complexes). Développons un peu. Exécutez le code suivant et notez ce que vous voyez dans la console. print("Les etudiants parlent de plus en plus fort.") print("Le professeur se doit de crier encore plus fort pour les calmer.") Votre console Python devrait maintenant ressembler à ceci : Les étudiants parlent de plus en plus fort. Le professeur se doit de crier encore plus fort pour les calmer. C’est une bonne occasion de faire quelques observations : Le programme appelle la fonction print() deux fois, et vous pouvez voir deux lignes distinctes dans la console - cela signifie que print() commence sa sortie d’affichage à partir d’une nouvelle ligne chaque fois qu’il commence son exécution; vous pouvez modifier ce comportement, mais vous pouvez également l’utiliser à votre avantage; Chaque invocation print() contient une chaîne différente, car son argument et le contenu de la console le reflètent - cela signifie que les instructions du code sont exécutées dans le même ordre dans lequel elles ont été placées dans le fichier source ; aucune instruction suivante n’est exécutée tant que la précédente n’est pas terminée (il y a quelques exceptions à cette règle, mais vous pouvez les ignorer pour l’instant) Changeons un peu l’exemple, nous allons ajouter un appel de fonction print() vide. Nous l’appelons vide parce que nous n’avons fourni aucun argument à la fonction. Plaçons-le entre les deux autres lignes. Que se passe-t-il ? 33  Année académique 2024-2025 Si tout se passe bien, vous devriez voir quelque chose comme ceci: Les étudiants parlent de plus en plus fort. Le professeur se doit de crier encore plus fort pour les calmer. Comme vous pouvez le voir, l’appel print() vide n’est pas aussi vide que vous auriez pu vous y attendre, il génère une ligne vide, ou (cette interprétation est également correcte) sa sortie est juste une nouvelle ligne. Ce n’est pas la seule façon de produire une nouvelle ligne dans la console de sortie. 2.1.6 Les caractères d’échappement et les nouvelles lignes Modifions à nouveau le code pour obtenir : print("Les étudiants parlent \nde plus en plus fort") print() print("Le professeur se doit de crier\n encore plus fort pour les calmer.") Il y a deux changements, nous avons inséré une étrange paire de caractères. Ils ressemblent à ceci : \n. Il est intéressant de constater que, alors que vous pouvez voir deux caractères, Python n’en voit qu’un. La barre oblique inverse ( \ ) a une signification très particulière lorsqu’elle est utilisée à l’intérieur de chaînes, c’est ce qu’on appelle le caractère d’échappement. Le mot échappement doit être compris spécifiquement, il signifie que la série de caractères dans la chaîne s’échappe pour le moment (un moment très court) pour introduire une inclusion spéciale. En d’autres termes, la barre oblique inverse ne signifie rien en soi, mais n’est qu’une sorte d’annonce, que le caractère suivant après la barre oblique inverse a également une signification différente. La lettre n placée après la barre oblique inverse provient du mot newline. La barre oblique inverse et le n forment un symbole spécial appelé caractère de nouvelle ligne, qui incite la console à démarrer une nouvelle ligne de sortie. Comme vous pouvez le voir en exécutant le programme, deux nouvelles lignes apparaissent dans votre console, aux endroits où les \n ont été utilisés. Cette convention sur la barre oblique, a deux conséquences importantes : 1. Si vous voulez mettre une seule barre oblique inverse à l’intérieur d’une chaîne, n’oubliez pas sa nature d’échappement, vous devrez la doubler !! 34  Année académique 2024-2025 par exemple, un tel appel provoquera une erreur: print(« \ ») alors que celui-ci ne le fera pas: print(« \\ ») 2. Toutes les paires d’échappement (la barre oblique inverse couplée à un autre caractère) ne signifient pas quelque chose. 2.1.7 Ajoutons des arguments Jusqu’à présent, nous avons testé le comportement de la fonction print() sans argument ou avec un seul argument. Il vaut également la peine d’essayer d’alimenter la fonction print() avec plusieurs arguments. Regardez le code suivant : print("Les étudiants" , "parlent" , "trop fort.") Il existe un appel de fonction print(), mais il contient trois arguments. Tous sont des chaînes de caractères. Les arguments sont séparés par des virgules. Nous les avons entourés d’espaces pour les rendre plus visibles, mais ce n’est pas vraiment nécessaire, et nous ne le ferons plus à l’avenir. Dans ce cas, les virgules séparant les arguments jouent un rôle complètement différent de la virgule à l’intérieur de la chaîne de caractères. Le premier fait partie de la syntaxe de Python, le second est destiné à être affiché dans la console. Si vous regardez à nouveau le code, vous verrez qu’il n’y a pas d’espaces à l’intérieur des chaînes (entre les derniers mots et les guillemets par exemple). Exécutez le code et voyez ce qui se passe. La console doit maintenant afficher le texte suivant : Les étudiants parlent trop fort. Les espaces, supprimés des chaînes, sont réapparus. Pouvez-vous expliquer pourquoi? Deux conclusions se dégagent de cet exemple : une fonction print() appelée avec plus d’un argument les affiche tous sur une seule ligne ; La fonction print() place un espace entre les arguments sortis de sa propre initiative. Python fonctionne avec ce que l’on appelle la manière positionnelle, c’est-à-dire, que l’argument sortira à la place ou il a été mis, le premier, suivi du deuxième, … 35  Année académique 2024-2025 2.1.8 Les mots-clés de la fonction print() Python offre un autre mécanisme pour le passage d’arguments, ce qui peut être utile lorsque vous voulez spécifié à la fonction print() de changer un peu son comportement. Nous n’allons pas l’expliquer en profondeur pour le moment. Nous prévoyons de le faire lorsque nous parlons des fonctions. Pour l’instant, nous voulons simplement vous montrer comment cela fonctionne. N’hésitez pas à l’utiliser dans vos propres programmes. Et à le tester dans tous les sens pour voir faire la main. Le mécanisme est appelé « Keywords arguments »(arguments de mot-clé). Le nom provient du fait que la signification de ces arguments n’est pas tirée de son emplacement (position) mais du mot spécial (mot-clé) utilisé pour les identifier. La fonction print() possède deux arguments de mot-clé que vous pouvez utiliser pour vos besoins. Le premier d’entre eux est nommé end. Dans l’éditeur, vous pouvez voir encoder l’exemple très simple d’utilisation d’un argument de mot-clé fourni ci-dessous. print("My name is", "Python.", end=" ") print("Monty Python.") Pour l’utiliser, il est nécessaire de connaître quelques règles: Un argument de mot-clé se compose de trois éléments : un mot-clé identifiant l’argument (end dans ce cas) ; un signe égal (=) ; et une valeur affectée à cet argument ; Tous les arguments de mot-clé doivent être placés après le dernier argument positionnel (c’est très très important) Dans notre exemple, nous avons utilisé l’argument de mot-clé end et l’avons défini sur une chaîne contenant un espace. Exécutez le code pour voir comment il fonctionne. La console doit maintenant afficher le texte suivant : Je m’appelle Python. Monty Python. Comme vous pouvez le voir, l’argument mot-clé end détermine les caractères que la fonction print() envoie à la sortie une fois qu’elle atteint la fin de ses arguments positionnels. Le comportement par défaut reflète la situation dans laquelle l’argument de mot-clé end est implicitement utilisé de la manière suivante : end="\n" Le mot clé end peut aussi être utilisé pour annulé le caractère de saut de ligne à la fin d’un print. 36  Année académique 2024-2025 Par exemple le code : print("My name is ", end="") print("Monty Python.") Nous afficherons dans la console, la phrase : My name is Monty Python. En effet, comme l’argument end a été défini sur rien, la fonction print() ne produit rien non plus, une fois que ses arguments positionnels ont été épuisés. Un autre mot clé, est le mot clé sep qui va nous permettre de séparer les arguments de sorties autrement que par des espaces. print("My", "name", "is", "Monty", "Python.", sep="-") Ce code nous donnera : Mon-nom-est-Monty-Python. Il est évident qu’il est possible de mélanger dans un même print() ces deux mots-clés. print("My", "name", "is", sep="_", end="*") print("Monty", "Python.", sep="*", end="*\n") Si nous regardons cet exemple, qui nous sommes d’accord n’a aucun sens logique, nous pouvons voir la combinaison de nos deux mots-clés et le résultat de ceux-ci en console : My_name_is*Monty*Python.* 37  Année académique 2024-2025 2.1.9 Exercices 1. Temps estimé 5-10 minutes Objectifs Se familiariser avec la fonction print() et ses capacités de formatage; expérimenter avec du code Python. Scénario Créer un code dans l’éditeur, à l’aide des mots-clés sep et end, pour qu’il corresponde à la sortie attendue. Utilisez deux fonctions print(). Ne changez rien dans le deuxième appel print(). Bout de code de base : print("Les Profs","sont","géniaux") print("surtout Mr Mandoux") Résultats escomptés Les Profs***sont***géniaux... surtout Mr Mandoux 38  Année académique 2024-2025 2. Temps estimé 5-15 minutes Objectifs Expérimenter avec du code Python existant, la découverte et la correction d’erreurs de syntaxe de base; Se familiariser avec la fonction print() et ses capacités de formatage. Scénario Nous vous encourageons fortement à jouer avec le code que nous avons écrit pour vous (faites en ce que vous souhaitez dans un premier temps pour tester votre compréhension) et à y apporter quelques modifications (peut-être même destructrices). N’hésitez pas à modifier n’importe quelle partie du code, mais il y a une condition: apprendre de vos erreurs et tirer vos propres conclusions. Essayez de : Réduire le nombre d’appels de la fonction print() en insérant la séquence \n dans les chaînes Rendre la flèche deux fois plus grande (mais garder les proportions) Dupliquer la flèche, en plaçant les deux flèches côte à côte; Remarque: une chaîne peut être multipliée en utilisant l’astuce suivante: "string" * 2 produira « stringstring » (nous vous en dirons plus bientôt) Supprimez toutes les guillemets et examinez attentivement la réponse de Python; faites attention à l’endroit où Python voit une erreur - est-ce l’endroit où l’erreur existe vraiment? Faites de même avec certaines parenthèses; Changer le mot print en quelque chose d’autre, ne différant que dans le cas (par exemple, Print) - que se passe-t-il maintenant? Remplacer certains guillemets par des apostrophes; Observez attentivement ce qui se passe. 39  Année académique 2024-2025 2.1.10 Résumé 1. La fonction print() est une fonction intégrée. Elle imprime / envoie un message spécifié à la fenêtre d’écran / console. 2. Les fonctions intégrées, contrairement aux fonctions définies par l’utilisateur, sont toujours disponibles et n’ont pas besoin d’être importées. Python 3.8 est livré avec 69 fonctions intégr?