#!/usr/bin/env python # coding: utf-8 # # Quelques bases de programmation en Python 3 # # Nous avons découvert la programmation en Python 3 en nous appuyant sur les activités de [futurecoder.io](https://fr.futurecoder.io/) ; # # Après une présentation rapide du langage [Python](#généralité), de l'outil [futurecoder.io](#un-mot-sur-furturcoderio) et des [notebook jupyter](#utilisation-des-notebook-jupyter), vous trouverez ci-dessous un résumé de ce qu'il vous faudra retenir pour la suite de votre apprentissage ainsi que quelques exercices d'application et des précisions complémentaires... # ## Généralité # [Python](https://fr.wikipedia.org/wiki/Python_(langage)) est un langage de programmation moderne imaginé par [Guido Van Rossum](https://fr.wikipedia.org/wiki/Guido_van_Rossum) , [multi-plateforme](https://fr.wikipedia.org/wiki/Logiciel_multiplate-forme), [open-source](https://fr.wikipedia.org/wiki/Open_source), [généraliste](https://fr.wikipedia.org/wiki/Langage_d%C3%A9di%C3%A9), [orienté objet](https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet) et de [haut niveau](https://fr.wikipedia.org/wiki/Langage_de_haut_niveau). # # ![Guido Van Rossum](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Guido-portrait-2014-drc.jpg/390px-Guido-portrait-2014-drc.jpg) # # > Python n'a rien à voir avec le reptile du même nom, mais avec le groupe d'humoristes anglais des années 1970 [Monty Python](https://fr.wikipedia.org/wiki/Monty_Python). # # C'est un langage à la fois simple et puissant : # # * simple car facile à apprendre, son code est réputé concis et clair, sa syntaxe est très proche d'une notation algorithmique, base de toute programmation. # # * puissant car il possède une importante bibliothèque standard et un très grand nombre de paquets complémentaires dédiés au calcul scientifique et aussi pour de nombreux autres domaines d'application. C'est le langage retenu en Classe Préparatoire aux Grandes Ecoles... # # > Python est considéré comme un langage de conception rapide (Rapid Application Development). # # C'est un langage **interprété** : pas besoin de compiler tout le programme source en code machine pour l'exécuter. L'interpréteur Python lit et exécute ligne après ligne un script codé en Python. # Ce qui est un très gros avantage pour l'apprentissage d'un langage informatique car on peut tester progressivement des portions de code au cours du développement d'un programme plus complet. # ## Un mot sur furturcoder.io # #
# logo futurcoder.io #
# # Parce que **"Le code du futur, c'est vous !"**, Alex HALL ([alexmojaki](https://github.com/alexmojaki)) a développé [`futurcoder.io`](https://github.com/alexmojaki/futurecoder) un projet 100% open source d’envergure internationale de découverte de Python. # Il s’agit d'un interpréteur Python en ligne associé à un cours moderne et assez complet pour débutant, avec des exercices interactifs, un système d’aide très bien fait et des débugueurs variés. # # # In[2]: from IPython.display import HTML HTML('''
''') # La traduction française officielle a été réalisée par une poignée d'enseignants de NSI membres très actifs de l'[AEIF](https://aeif.fr/index.php/accueil/). # Une copie hébergée en France (plus RGPD et sans tracker) est maintenue disponible à l'adresse [https://futurecoder.forge.aeif.fr/](https://futurecoder.forge.aeif.fr/). # # > A l'instar d'[autres développements](https://pyodide.org/en/stable/project/related-projects.html#notebook-environments-ides-and-repls) tels que Basthon, JupyterLite, ou encore PyScript, que nous utiliserons par la suite, `furturcoder.io` est basé sur la récente technologie [Pyodide](https://pyodide.org) qui permet d'interpréter des instructions Python directement dans un navigateur de façon interactive coté client... # ## Utilisation des notebook Jupyter # # Ce document est un [jupyter notebook](https://ericecmorlaix.github.io/adn-Tutoriel_lab_si/IDE/notebook/), il permet d'exécuter du code cellule après cellule et ainsi d'expérimenter progressivement les portions d'un programme plus complet au cours de son développement. # # > Vous pouvez télécharger ce fichier avec son extension `.ipynb` en cliquant sur le bouton en haut à droite afin de l'éditer sur votre iPad en local avec l'application [Carnets](https://holzschu.github.io/Carnets_Jupyter/) ou dans votre navigateur avec [Basthon](https://notebook.basthon.fr/), ou encore avec [Visual Studio Code pour le Web](https://vscode.dev) en y installant les [extensions nécessaires](https://ericecmorlaix.github.io/adn-Tutoriel_lab_si/IDE/VSCode/#extensions-pour-vscode)... # >> - Pour l'ouvrir dans l'application [Carnets](https://holzschu.github.io/Carnets_Jupyter/), il faut préalablement déplacer le fichier téléchargé avec l'application [Fichier](https://apps.apple.com/fr/app/fichiers/id1232058109) dans le dossier `Carnets` sur votre iPad ; # >> - Potentiellement, Safari peut ajouter une extension `.txt`, il faut alors ouvrir votre fichier avec l'application [Carnets](https://holzschu.github.io/Carnets_Jupyter/) et choisir dans le menu "File>Rename" pour supprimer cette extension puis cliquer sur `<` pour revenir dans l'explorateur des fichiers... # # La façon habituelle de lire l'ensemble du notebook consiste à exécuter successivement les instructions de la première cellule de code jusqu'à la fin du notebook. # # **Mais attention, il est important que les cellules de code soient évaluées dans le bon ordre. Si vous ne respectez pas l'ordre dans lequel les cellules de code sont présentées, le résultat peut être inattendu.** # # > En fait, évaluer un programme sous forme de notebook revient à le découper en petits fragments, et si on exécute ces fragments dans le désordre, on obtient naturellement le résultat d'un programme différent. # # ### Entrée **In[ ]:** et Sortie **Out[ ]:** # # En cliquant sur le bouton (ou en appuyant sur les touches d'un clavier **``**, ou encore en utilisant dans le menu **`Cell>Run Cells and Select Below...`** cela a pour effet **d'exécuter le code** Python de la cellule sélectionnée et de présélectionner la cellule suivante... # #
Essayez vous-même :
# In[ ]: 1+1 # In[ ]: "Bonjour ! " # Une ligne **Out[ ]:** apparait en dessous des instructions de code, affichant le résultat de celles-ci en sortie... # # On peut rappeler le résultat de la dernière sortie dans la cellule suivante et le réutiliser ainsi : # In[ ]: _ # In[ ]: _ * 2 # On peut rappeler le résultat d'une sortie particulière dans une autre cellule pour le réutiliser : # In[ ]: Out[1] * 2 # > Rejouer les cellules précedentes, puis essayer de le refaire encore mais dans un ordre différent... # # > Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton pour essayer autre chose. # # > Un des avantages principaux des notebooks est de vous permettre de modifier le code que nous avons préalablement écrit, et de voir par vous-même comment se comporte le code modifié. # Pour cette raison chaque élève dispose de sa **propre copie** de chaque notebook, ainsi vous pouvez bien sûr apporter toutes les modifications que vous souhaitez à vos notebooks sans affecter ceux des autres élèves et revenir à la version originale en rechargeant un notebook à partir du lien fourni. # ## Notions de programmation à retenir # ### Les Commentaires # Lorsque l'on rédige un programme informatique il est essentiel de le commenter pour expliquer des intentions de développement, pour cela en Python on utilise le caractère **`#`** qui permet d'indiquer que tous les caractères suivants sur la même ligne ne doivent pas être interprétés comme du code d'instruction : # In[3]: ########################################## # Un programme pour saluer doublement # ########################################## # Out[2] * Out[1] # Décommenter l'instruction précédente... # >Remarque: Le simple fait d'ajouter un **`#`** permet de désactiver une ligne d'instruction sans avoir à l'effacer. Elle ne sera donc pas prise en compte par Python lors de l'exécution du programme. Aussi, il suffira de la décommenter en enlevant ce **`#`** pour la réactiver plus tard si besoin... # > # > Pour cela on peut utiliser la combinaison de touches **``**. # #

Essayez vous-même :

# # - Décommenter l'instruction `Out[2] * Out[1]` # ### Opération de calcul sur les nombres # # Les opérateurs arithmétiques de Python sont : # # | Symbole | Opération | # |---------|--------------| # | + | Addition | # | - | Soustraction | # | * | Multiplication | # | / | Division | # | // | Division entière (renvoie le quotient) | # | ** | Puissance | # | % | Modulo (renvoie le reste) | # # Pour observer les fonctionnalités de la machine à calculer Python, rendez-vous sur le bloc note [Arithmetique](https://nbviewer.org/urls/ericecmorlaix.github.io/bn/Arithmetique-Le_BN_pour_calculer.ipynb) # #

A faire vous-même :

# # - Faire sur brouillon les calculs des instructions suivantes puis vérifier vos résultats en exécutant les cellules. # In[ ]: (-4 + 13 * 2) // 20 # In[ ]: (-4 + 13 * 2) % 20 # ### Opération sur les chaines de caractères alphanumériques : # # > Une chaîne de caractères est une suite de caractères. # > Un caractère est un symbole tel qu'une lettre, un chiffre, un symbole de ponctuation, etc... # # Pour délimiter le début et la fin d'une chaine de caractères, on l'encadre par des guillemets simples (apostrophes) `'` ou doubles `"`. # # > Ce qui permet d'intégrer une **`'`** ou des **`"`** dans une chaine de caractères. # > Une autre solution consiste à utiliser un caractère spécial d'échappement **`\`** # # En Python, les chaines de caractères sont des données **immutables** (non modifiables). # #

Essayez vous-même :

# # - Les deux cellules suivantes produisent le même résultat : # In[ ]: 'ma chaine' # In[ ]: "ma chaine" #

A faire vous-même :

# # - Vérifiez que l'instruction suivante produit une erreur puis trouvez une solution pour y remédier : # In[ ]: 'Demat d'an holl' # #### Concaténation # # On peut concaténer deux chaines grâce à l'opérateur **`+`**. # # > Il faut saisir un caractère espace dans une chaine pour laisser une espace entre deux portions de chaines. # In[ ]: 'Hello'+' '+'World'+' !' # #### Répétition # # On peut répéter une chaine grâce à l'opérateur **`*`**. # In[ ]: "to"*2 # ### Variables : # # Pour définir une **variable** en Python, il suffit : # # - de la nommer (_directement, sans autre mot clé comme `var`, `int`, contrairement à d'autres langages_), # # > Il est recommandé de choisir pour les variables des noms significatifs de ce qu'elles représentent ; # > Pour former un nom de variable avec plusieurs mots on remplace les espaces par des tirets du bas `_` (le caractère underscore) ; # # - et de lui associer une valeur en utilisant l'opérateur d'**affectation** : **`=`**. # In[2]: ma_premiere_variable = 'Hello World !' # L'exécution d'une instruction constituée du nom d'une variable renvoie la valeur qu'elle référence # In[ ]: ma_premiere_variable # # L'exécution d'une instruction comportant une variable non définie renvoie systématiquement une erreur. # In[ ]: ma_seconde_variable # Mais rien n'est définitif, car l'intérêt des variables est de pouvoir changer de valeur # In[3]: ma_seconde_variable = 5 # > **initialiser** une variable consite à lui affecter une valeur de départ comme par exemple : # > - `mot = ''` => une chaine vide, aucun caractère au départ ; # > - `score = 0` => un nombre nul, début à partir de zéro... # #

Permutation de variables version 1 :

# # Soit les variables `a` et `b` définies telles que : # In[ ]: a = 5 b = 'toto' # In[ ]: a # In[ ]: b # Dans la cellule suivante, écrire un script qui, en utilisant une variable tampon nommée `c`, va intervertir les valeurs de `a` et de `b` : # In[ ]: # #### Typage dynamique # # La fonction **`type()`** renvoie le type d'une valeur (ou celui de la valeur associée à une variable) : # #
Essayez vous-même :
# # In[ ]: type("Demat d'an holl !") # In[ ]: type(ma_premiere_variable) # In[ ]: type(ma_seconde_variable) # In[6]: ma_troisieme_variable = 5.0 ma_troisieme_variable, type(ma_troisieme_variable) # > Voici donc quelques types de valeurs : # >* **`str`** pour string, une chaine de caractères alphanumériques ; # >* **`int`** pour integer, un nombre entier ; # >* **`float`** un nombre [flottant](https://fr.wikipedia.org/wiki/Virgule_flottante), représentant un nombre réel. # Python attribue de façon dynamique à une variable le **type** correspondant à la valeur qu'elle référence. # #### Opérations entre variables # # Les opérations vues précédemment s'appliquent aussi entre des variables à condition que leur types soient compatibles et on peut alors en mémoriser le résultat dans une autre variable : # #

Essayez vous-même :

# In[ ]: (ma_premiere_variable + " ") * ma_seconde_variable # In[ ]: v = 5 u = 12 t = v + u t # In[ ]: ma_premiere_variable + ma_seconde_variable # In[ ]: (ma_premiere_variable + " ") * ma_troisieme_variable # #### Incrémentation et décrémentation d'une variable # #
Essayez vous-même :
# # - Initialisez la variable `i` puis, # - Exécutez les cellules des codes d'incrémentation et de décrémentation suivantes plusieures fois de suite ; # - Essayez aussi pour des valeurs de $pas\neq1$... # In[ ]: # initialisation de la variable i = 0 i # In[ ]: # incrémentation de la variable d'un pas de 1, code de base i = i + 1 i # In[ ]: # incrémentation de la variable d'un pas de 1, code condensé i += 1 i # In[ ]: # incrémentation de la variable d'un pas de -1, code de base i = i - 1 i # In[ ]: # incrémentation de la variable d'un pas de -1, code condensé i -= 1 i # > D'autres langages possèdent des notations encore plus condensées pour l'incrémentation **`i++`** et la décrémentation **`i--`** par pas de 1. #

Permutation de variables version 2 :

# # Soit les variables `a` et `b` définies telles que : # In[ ]: a = 5 b = 3 # In[ ]: a # In[ ]: b # Dans la cellule suivante, écrire un script qui, par une suite d'opérations arithmétiques, va intervertir les valeus de `a` et de `b` : # In[ ]: # ### Fonction d'entrée de données : # # Il est parfois nécessaire de demander à l'utilisateur d'entrer des données pour attribuer une valeur à une variable. On utilise pour cela la fonction **`input()`**. # #

Essayez vous-même :

# # - Exécuter cette cellule plusieurs fois pour essayer avec des entrées de différents types... # In[ ]: ma_variable = input("Entrer une valeur d'un type quelconque : ") ma_variable, type(ma_variable) # > On observe que le type renvoyé par cette cellule est toujours une chaines de caractères alphanumériques. # Il sera donc nécessaire de changer ce type en nombre pour pouvoir utiliser cette variable dans des opérations de calculs arythmétiques, et inversement pour des opérations de concaténation sur des chaines de caractères. # # Les fonctions de conversion de type (transtypage ou cast) qui nous seront utiles ici sont **`int()`**, **`float()`**, **`str()`**. # In[ ]: ma_nouvelle_variable = float(input("Entrer un réel : ")) ma_nouvelle_variable, type(ma_nouvelle_variable) # ### Fonction d'affichage en sortie : # # La fonction **`print()`** permet d'afficher du contenu : # #

Essayez vous-même :

# In[ ]: print("L'heure est venue de programmer") print("au","lycée","Notre","Dame","du","Mur") print(maPremiereVariable) print(maSecondeVariable) print(maTroisiemeVariable) print(0x1A) print(0b1100) print("Python...\n" + ">" * 10, 'c\'est "cool" !') # > On observe que les chaines de caractères s'affichent sans guillemets # > et qu'un nombre indiqué en hexadécimal ou en binaire est affiché en décimal... # # La fonction **`print()`** admet deux arguments interessants : # # * **`sep`** qui permet de séparer les valeurs par un texte de votre choix. Par défaut le séparateur est une espace **`" "`**. # * **`end`** qui permet d'ajouter à la fin un texte de votre choix. Par defaut la fin de ligne est un retour à la ligne **`"\n"`**. # In[ ]: print("L'heure est venue de programmer", end = " ") print("au","lycée","Notre","Dame","du","Mur") print(maPremiereVariable, end=" | ") print(maSecondeVariable, end=" | ") print(maTroisiemeVariable, end=" | ") print(0x1A, end=" | ") print(0b1100) print("Python...", ">" * 10 + ' c\'est "cool" !', sep = "\n") # Pour afficher un résultat avec du texte combiné avec des variables, il existe plusieurs méthodes : # In[ ]: u = 15 i = 1 print("u",i," = ",u,sep='') # > Par défaut sep est un espace, si on souhaite que l'indice soit acollé à la variable u, il faut redéfinir sep... # In[ ]: u = 15 i = 1 print("u"+str(i)+" = "+str(u)) # > Il faut convertir les nombres en **`string`** pour pouvoir les **concaténer** avec du texte. # # Avant Python 3.6, le plus élégant consistait à utiliser la méthode **`format()`**, en voici un exemple : # In[ ]: a=4 b=5 print("Le produit de {0} par {1} est {2}\nLa division de {1} par {0} donne {3}".format(a,b,a*b,b/a)) # > On remplace **`{ }`** par le contenu de la variable. Peu importe son type, le résultat sera affiché. # # Depuis Python 3.6, on peut utiliser les **`f-strings`** pour formatter une chaine de caractères : # In[ ]: a=4 b=5 print(f"Le produit de {a} par {b} est {a*b}\nLa division de {b} par {a} donne {b/a}") #

A faire vous-même :

# # - Vérifiez que la cellule suivante produit une erreur puis trouvez une solution pour y remédier en remplaçant toutes les concaténations de chaine par une seule f-string : # In[ ]: nom = "Alice" age = 20 print("Bonjour " + nom + ". Vous avez " + age + " ans.") # ## Structure séquentielle : une ligne de code <=> une instruction # # Un programme informatique est une séquence d'instructions. # # L'instruction 3 sera exécutée seulement après l'exécution de l'instruction 2. L'ordre des instructions est donc important. # # > Dans de nombreux langages de programmation comme Java, C, PHP ou JavaScript, les instructions sont séparées par un point-virgule. # > # > On observe qu'il n'y a pas de **`;`** à la fin d'une instruction Python, c'est donc le retour à la ligne qui marque la fin de l'instruction et donc le début de la suivante. # #

France IOI - Algoréa - Séquence d'instructions

# # [![SequencePythonAlgorea.png](https://ericecmorlaix.github.io/img/SequencePythonAlgorea.png)](https://parcours.algorea.org/fr/a/5538868055472359160;p=4702,5794277797719192711,204136604821791621,540678427040899806,3080878003834387961,7555157999148281392;a=0) # **Est-ce la première, la seconde, la troisième ou la quatrième grille en partant de la gauche ?** # # _Votre réponse :_ # > En réalité Python autorise le **`;`** pour séparer des instructions et permet ainsi d'écrire une séquence d'instructions sur une même ligne tel que : # In[ ]: maPremiereVariable='Hello World!';maPremiereVariable # > Le résultat est bien évidemment le même, mais cette pratique, très rarement utilisée, est à éviter car cela devient vite illisible. # Elle est à réserver pour des tests temporaires pour son coté pratique car il suffit alors d'un seul **`#`** pour désactiver toute une séquence... # ## Structure itérative : boucle de répétitions avec for # # La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions qui ne sont inscrites qu'une seule fois dans le code. # # La boucle **_for_** prend ses valeurs dans un ensemble itératif : # # ```python # for variable in iterable # ``` # À chaque itération (un tour de boucle), la variable prendra pour valeur un élément de l'itérable (un caractère d'une chaine, un élément d'une liste, ...). # # Pour créer une boucle équivalente aux boucles traditionnelles (pour **_i_** allant de **_m_** à **_n_**, faire...), nous utiliserons la fonction **`range()`** pour créer un itérable égal à une suite de valeurs entières. # # La syntaxe générale est # ```python # for i in range(m,n,p): # ``` # **_i_** prend alors toutes les valeurs de **_m_** à **_n-1_** par pas de **_p_** # #

Essayez vous-même :

# In[ ]: for i in range(1,4): print(i) # In[ ]: for i in range(4): print(i) # In[ ]: for i in range(0,6,2): print(i) # In[ ]: for i in range(4,0,-1): print(i) # On peut aussi parcourir une chaîne de caractères : # In[ ]: for lettre in "Bonjour": print(lettre) #

A faire vous-même :

# # - Modifier le programme de la cellule suivante pour qu'il affiche ` d, l, r, o, W,` # In[1]: nom = 'World' ligne = '' for caractere in nom: ligne = ligne + caractere print(ligne) # In[2]: nom = 'World' ligne = '' for caractere in nom: ligne = # zone à modifier print(ligne) #

France IOI - Algoréa - Boucle for :

# # [![BoucleForAlgorea.png](https://ericecmorlaix.github.io/img/BoucleForAlgorea.png)](https://parcours.algorea.org/fr/a/4714154749630652771;p=4702,5794277797719192711,204136604821791621,540678427040899806,3080878003834387961,1831974898040186897;pa=0) # **Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?** # # _Votre réponse :_ # ### Indentation obligatoire en Python : # # Python oblige donc le développeur à structurer son code a l'aide des **indentations** : ce sont elles qui, après les **`:`**, détermineront les limites du bloc de la séquence d'instructions répétées dans la boucle et non pas les accolades comme dans la majorité des langages comme par exemple en JavaScript: # ``` javascript # for (initialisation ; condition ; modification) { # Instruction 1 ; # Instruction 2 ; # ... ; # } # ``` # > L'indentation n'est donc pas ogligatoire dans tous les langages informatiques. Par exemple en Javascript on pourrait programmer tel que : # > # ``` javascript # for(var i=0;i<8;i++){ellipse(positionX+entraxe*i,positionY,diametre,diametre);Instruction 2 ; Instruction 3 ; Instruction 4 ... ;} # ``` # > Ce qui devient bien évidemment rapidement illisible pour un humain normalement constitué... # # Python oblige donc par nature à produire du code clair et lisible donc plus facilement maintenable... # #
# # # # > Il convient de toujours indenter avec 4 espaces. D'autres valeurs sont possibles, dans un bloc, de manière cohérente, mais 4 espaces est la convention adoptée par presque tout le monde. Remarquez que l'éditeur vous simplifie la tâche. Si vous pressez "Tab" dans l'éditeur, il va insérer 4 espaces pour vous. # # >_Que ceux qui souhaiteraient coder avec des accolades en Python, exécutent l'instruction suivante dans un interpréteur :_ # In[ ]: from __future__ import braces # > _et constatent que les développeurs de Python, avec ce genre d'"easter egg", ne manquent pas d'humour à l'instar des Monty..._ # >_https://stackoverflow.com/questions/17811855/syntax-error-not-a-chance_ # > # > Essayer aussi avec : # ```python # import this # ``` # ```python # import __hello__ # ``` # ```python # import antigravity # ``` # In[ ]: import this # ## Opérateurs relationnels, les comparateurs : # # | Symbole | Opération | # |---------|-----------| # | == | égal | # | != | différent | # | < | inférieur | # | > | supérieur | # | <= | inférieur ou égal | # | >= | supérieur ou égal | # # Ces opérateurs permettent de faire des tests conditionnels : # #

Essayez vous-même :

# In[ ]: condition1 = ( 0 == 1 ) condition1,type(condition1) # In[ ]: condition2 = ( 0 <= 1 ) condition2,type(condition2) # > On découvre là un nouveau type de variable **`bool`** pour booléen, leur valeur est soit **`True`** soit **`False`**. # > # > Nous verrons plus tard plus en détails la logique booléenne que l'on doit à [George](https://fr.wikipedia.org/wiki/George_Boole) # ## Structure conditionnelle (alternatives), si ... alors ... sinon : # # # ```python # if condition: # # Traitement bloc 1 # else: # # Traitement bloc 2 # ``` # # Pour les tests multiples, il faudra enchaîner les if en cascade grâce à l'instruction elif, contraction de else if : # # # ```python # if condition: # # Traitement bloc 1 # elif: # # Traitement bloc 2 # else: # # Traitement bloc 3 # ``` # # #

France IOI - Algoréa - Alternative :

# # [![AlternativeAlgorea.png](https://ericecmorlaix.github.io/img/AlternativeAlgorea.png)](https://parcours.algorea.org/fr/a/8662634313287387278;p=4702,5794277797719192711,204136604821791621,540678427040899806,3080878003834387961,3942152020288861336;pa=0) # # **Est-ce la première, la seconde, la troisième ou la quatrième instruction en partant de la gauche ?** # # _Votre réponse :_ #

Autre exemple à tester vous-même :

# # - Essayez le script de la cellule suivante et trouver une stratégie qui permet de réduire le nombre de tentatives : # In[ ]: # L'ordinateur génère un nombre secret compris entre 1 et 100 de façon aléatoire from random import randint nombre_secret = randint(1,100) print("Saurez-vous trouver le nombre secret en moins de 10 coups ?") for i in range (10) : # On demande au joueur de saisir un nombre entier compris entre 1 et 100 proposition_du_joueur = int(input("\nSaisir un nombre entier compris entre 1 et 100 = ")) if proposition_du_joueur < nombre_secret : print(f"C'est plus grand...\nIl vous reste {9-i} tentatives.") elif proposition_du_joueur > nombre_secret : print(f"C'est plus petit...\nIl vous reste {9-i} tentatives.") else : print(f"Bravo, vous avez trouvez le nombre secret en {i+1} coups !") break if i+1 == 10 : print(f"Dommage, vous n'avez pas trouvez le nombre secret en moins de {i+1} coups !\nRéfléchissez à une stratégie pour trouvez en réduisant vos tentatives...") # > Ce script utilise la méthode `randint()` du module `random` : # In[ ]: from random import randint help(randint) # In[ ]: randint(1,6)# Simule le lancé d'un dé à six faces #

Chi Fou Mi à coder vous même :

# # - Programmer un jeu de [Pierre-Feuille-Ciseau](https://fr.wikipedia.org/wiki/Pierre-papier-ciseaux) entre un joueur et l'ordinateur. Le meilleur des cinqs manches remporte la partie : # In[ ]: # ## Autres boucles avec while (TANT QUE ou JUSQU'A) : # # # # ``` python # Initialisation # # Début de la boucle # while Condition : # Instruction 1 # Instruction 2 # ... # Dernière Instruction # Modification # # fin de la boucle et suite du programme # ``` # Les instructions inscrites dans la boucle forment un bloc d'instructions. Elles seront répétées tant que la condition de répétition est vrai. # Dès que la condition de répétition est fausse le programme sort de la boucle et se poursuit au delà. # L'initialisation déclare une variable et lui affecte une valeur initiale par exemple **`i = 0`**. # La modification fait évoluer cette variable de façon régulière à chaque tour de boucle, par exemple par incrémentation **`i+=1`**. # La condition consiste donc à faire un test binaire (vrai ou faux) sur la valeur de la variable **`i`**. Puisque **`i`** évolue à chaque tour de boucle, le résultat du test deviendra donc faux au bout d'un nombre fini d'itération. # Ce test s'appuie sur des opérateurs relationnels afin d'établir une comparaison entre la variable **`i`** et la valeur limite de répétition, par exemple **`i < 8`**. # # Ce qui donne par exemple : # In[ ]: i=0 print('Début de la boucle') while i<8 : print(' Mon') print(' Bloc') print(" d'instructions") i+=1 print(' ',i) print('Fin de la boucle, prêt pour la suite du programme') #

France IOI - Algoréa - Boucle while :

# # [![BoucleWhileAlgorea.png](https://ericecmorlaix.github.io/img/BoucleWhileAlgorea.png)](https://parcours.algorea.org/fr/a/3171240146208380275;p=4702,5794277797719192711,204136604821791621,540678427040899806,3080878003834387961,685075010475402917;pa=0) # **Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?** # # _Votre réponse :_ # ## Les fonctions : # # Les fonctions se définissent de la façon suivante : # # ```Python # def maFonction(parametre1, parametre2): # instructions # return valeur1, valeur2 # ``` # Exemple : # In[ ]: def max(x,y): if (x > y): return x else : return y # Pour l'utiliser, il faut l'appeler : # In[ ]: max(6,3) # On peut ensuite la rapeller autant de fois qu'on le souhaite : # In[ ]: max(-9,1) #

France IOI - Algoréa - Fonction :

# # [![FonctionAlgorea.png](https://ericecmorlaix.github.io/img/FonctionAlgorea.png)](https://parcours.algorea.org/fr/a/3914526968809474817;p=4702,5794277797719192711,204136604821791621,540678427040899806,3080878003834387961,8898346518305397231;pa=0) # **Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?** # # _Votre réponse :_ #

Formes creuses en console à coder vous même :

# # **Ce que doit faire votre programme :** # # Écrivez un programme qui affiche une ligne de « X », un rectangle de « # », et un triangle de « @ ». Les deux formes doivent être creuses (remplies avec des espaces). # # L'entrée comporte quatre entiers, un par ligne : # # le nombre de « X » de la ligne à afficher ; # le nombre de lignes du rectangle de « # » ; # le nombre de colonnes du rectangle ; # le nombre de lignes du triangle de « @ ». # # Vous devez afficher les trois formes successivement, avec une ligne blanche entre chaque forme, comme le montre l'exemple. # # Votre objectif doit être d'obtenir le code source le plus simple et clair possible, en le décomposant en fonctions. # # **Exemple** # # entrée : # # ``` # 15 # 5 # 12 # 6 # # ``` # # sortie : # # ``` # XXXXXXXXXXXXXXX # # ############ # # # # # # # # # # ############ # # @ # @@ # @ @ # @ @ # @ @ # @@@@@@ # # ``` # # **Commentaires** # # Attention : le nombre de lignes ou de colonnes peut être égal à 1. # In[ ]: # ## Outils # # ### Interpréteur en ligne # # - [L'ide de futurecoder](https://fr.futurecoder.io/course/#ide) peut être utilisé à tout moment avec ses débuggeur propres que sont **snoop** et **birdseye** pour tester du code et cela indépendemment de votre progression dans le flux normal des pages du [cours de futurecoder](https://futurecoder.forge.aeif.fr/course/#toc) # # - [La console de basthon](https://console.basthon.fr/) offre également un ide en ligne. # # ### Notebook en ligne # # - [Le notebook de basthon](https://notebook.basthon.fr/) # # - [Le lab de jupyterLite](https://jupyter.org/try-jupyter/lab/) # # ### Python tutor : # # [Python tutor](http://pythontutor.com/) permet de visualiser pas à pas ce que fait votre script. # # Il est possible de l'utiliser dans un notebook jupyter pour cela il faut : # 1. l'installer (si ce n'est pas déjà fait) : ``%pip install metakernel`` # 1. puis exécuter les instructions de la cellule suivante : # In[ ]: from metakernel import register_ipython_magics register_ipython_magics() # 3. inscrire la commande ``%%tutor`` devant le script à tester dans la cellule : # In[ ]: get_ipython().run_cell_magic('tutor', '', '# Script à tester :\nfor i in range(0,6,2):\n print(i)\n') # ## Vocabulaire # # - **expression** : une portion de code qui possède une valeur ; # - **évaluer** : calculer la valeur d'une expression ; # - **instruction** : une ligne de code qui commande d'exécuter une action ; # - **affectation** : action de donner une valeur à une variable ; # - **itération** : un tour de boucle ; # - **concaténer** : joindre des chaines de caractères ; # - **incrémenter/décrémenter** : Augmenter/diminuer une variable d'une valeur fixée ; # - **indentation** : ajout de tabulation ou d'espaces (x4) pour délimiter des blocs d'instructions ; # # # ## Autres ressources : # # - [Documentation python 3](https://docs.python.org/fr/3/) # - [France IOI](http://www.france-ioi.org/algo/chapters.php) # - [Fabrice DUMONT](http://python.lecoinduprogrammeur.org/) # - [Jean-Daniel Bonjour](https://enacit1.epfl.ch/introduction-python/) # - [Débuter avec python au lycée](http://python.lycee.free.fr/)- # - # **** # ## Références aux programmes : # # # #

Langages et programmation

# # # # # # # # # # # # # # # # #
ContenusCapacités attenduesCommentaires
Constructions # élémentairesMettre en évidence un corpus # de constructions élémentaires.Séquences, affectation, # conditionnelles, boucles bornées, # boucles non bornées, appels de # fonction
Diversité et unité des # langages de # programmation # Repérer, dans un nouveau # langage de programmation, les # traits communs et les traits # particuliers à ce langage.Les manières dont un même # programme simple s’écrit dans # différents langages sont # comparées. #
# Licence Creative Commons
Ce document est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International. # # Pour toute question, suggestion ou commentaire : eric.madec@ecmorlaix.fr # ##