Python_quelques-bases.md

@@ -5,7 +5,8 @@ Normalement, on commence par les bases et on évoque ensuite des propriétés pl
 :books: Pour commencer, vous pouvez tester le [tuto officiel :three:.:one: :zero:](https://docs.python.org/3.10/tutorial/index.html) ou trouver un cours en ligne qui vous correspondra ; vous pouvez consulter [ma sélection](Tutographie).
 
 :bulb:  PYTHON TUTOR est votre allié ! :bulb:
-:bulb: n'hésitez pas à tester des bouts de code sur le site [PYTHON TUTOR](http://pythontutor.com) ! C'est est un outil pédagogique, qui exécute du code en ligne, pas à pas, en représentant graphiquement tous les **objets** créés (chiffres, chaînes de caractères et conteneurs (listes, tuples...) ), et ceci dans leurs espaces de nommage respectifs, avec les liens avec les noms de variables. 
+
+:bulb: n'hésitez pas à tester des bouts de code sur le site [PYTHON TUTOR](http://pythontutor.com) ! C'est un outil pédagogique, qui exécute du code en ligne, pas à pas, en représentant graphiquement tous les **objets** créés (chiffres, chaînes de caractères et conteneurs (listes, tuples...) ), et ceci dans leurs espaces de nommage respectifs, avec les liens avec les noms de variables. 
 Cela vous permettra en particulier de voir comment la modification d'une variable impacte (ou pas) certaines autres. 
 Il est limité par le nombre d'instructions, et ne permet pas l'import de modules (en particulier, pas de matplotlib...)
 
@@ -273,42 +274,70 @@ L'exécution du code fait afficher : <kbd>(5, 10, 25)</kbd>
 
 Ma variable resultat est un tuple  autrement dit `resultat = (5, 10, 25)`
 Un *tuple* est un conteneur, comme *list* mais avec des caractéristiques différentes.
-Pour récupérer tous les termes on « déballe » le tuple  (unpacking) :`(x,y,z) = resultat` ; les parenthèses ne sont pas obligatoires, on peut aussi écrire  `x,y,z = resultat`. 
+Pour récupérer tous les termes, quand on en connaît le nombre exact, on « déballe » le tuple  (unpacking) :`(x,y,z) = resultat` ; les parenthèses ne sont pas obligatoires, on peut aussi écrire  `x,y,z = resultat`. 
 
 On aura dans les 2 cas  `x=5` ; `y=10` et `z=25`
 
-Si on n’a besoin que du premier terme : on peut se contenter d'écrire `x, le_reste = resultat`
+Si on n’a besoin que du premier terme : on peut se contenter d'écrire `x, *le_reste = resultat`
 
-:warning: vérification à faire !
-test avec python 3.7 : besoin d'un * avant "le_reste" pour  "déballer" -   
- VERIFIER en Python 3.7 et 3.10 !
+- :warning: ça ne marche pas sans le '*' devant  !
+- :warning: `le_reste`, bizarrement, est de type "list", même s'il ne comporte qu'un seul élément
+- :warning: si a déjà extrait tous les termes, `le_reste` est une liste vide.
 
-Vous pourrez vérifier que dans ce cas le_reste est un *tuple* équivalent à (y,z), c'est logique !
-Mais on peut faire encore plus succinct, pour bien montrer que le reste ne nous intéresse vraiment pas :
-  `x, _ = resultat`  ou  même `x,  = resultat  `
-( `_` = nom de variable valide (!) , mais par convention on sait qu'on ne s’en servira pas )
+`x,y,z, *le_reste = resultat`  => `le_reste =  []`
 
-:warning: vérification à faire !
-test en cours avec python 3.7 pour "déballer" 
+```
+>>> truc = (1,2,3,4,5)
+>>> type(truc)
+<class 'tuple'>
+>>> a,*b = truc
+>>> b
+[2, 3, 4, 5]
+>>> type(b)
+<class 'list'>
+>>>
+>>> c,d = truc
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: too many values to unpack (expected 2)
+>>> xyz= (1,2,3)
+>>> x,y,z, *le_reste = xyz
+>>> le_reste
+[]
+```
 
-Petit exercice avec les tuples, A VERIFIER en Python 3.7 et 3.10 !
+**Cas des tuple composés d'un seul élément** 
+Un tuple peut être composé d'un seul élément, mais il faut bien être sûr de l'avoir défini comme tel : `tuple_un=(5,)`, ou `tuple_un = 5,`.
+La **virgule** est importante : la syntaxe sans les parenthèses mais avec la virgule donne bien un tuple, mais sans la virgule on définit un entier : `tuple_un=(5)` donne un objet de type entier.
+
+```
+>>> tuple_un=(5)
+>>> type(tuple_un)
+<class 'int'>
+>>> tuple_un=(5,)
+>>> type(tuple_un)
+<class 'tuple'>
+>>> tuple_un = 5,
+>>> tuple_un
+(5,)
+>>> type(tuple_un)
+<class 'tuple'>
+```
+Pour **récupérer la valeur** unique d'un tuple, on fait appel à l'unpacking avec... un seul terme :   `x, = resultat`  .
+
+**Petit exercice avec les tuples:**
+:warning: vérification en cours 
+ligne est une chaîne de caractères contenant 3 coordonnées pouvant être suivies d'un code, qui peut être composé de un ou plusieurs mots
 ```python
-# ligne est une chaîne de 4 "mots" minimum séparés par des espaces
-x, y, z, *autres = tuple(ligne.split())
+# ligne est une chaîne de 3 "mots" minimum séparés par des espaces
+# on sépare les mots avec split ; l'argument par défaut correspond à tous les "blancs" possibles
+x, y, z, *autres = ligne.split()  # avec les virgules, on définit un tuple
 print("il y a un ou plusieurs mots après xyz : ", autres)
-# on concatène les derniers mots si besoin pour faciliter le traitement 
-if len(autres) > 1:
-    fin_de_ligne = ""
-    for mot in autres:
-        fin_de_ligne += mot 
+# si elle la liste autres est non vide, on en concatène les mots pour reconstituer le code 
+if mots_ld:
+    code = " ".join([mot for mot in autres])
 else:
-    fin_de_ligne, = autres  # on extrait l'élément du tuple
-# le caractère '#" indique un commentaire, il faut donc couper avec split ; si # est en début de chaîne le résultat vaut ""
-avant_commentaire = fin_de_ligne.strip().split("#")[0]
-
-if avant_commentaire:
-    print("les 3 coordonnées sont  =", x,y,z, " suivies du mot", avant_commentaire, "avant un commentaire éventuel" )
-    
+    code = None    
 ```
       
 Si aucune variable ne récupère le résultat ce n’est pas gênant mais ce qui a été retourné est « perdu » _a priori_ car on n'a pas affecté de nom ; plus exactement on ne peut agir dessus (on pourrait épiloguer un peu plus, mais pour débuter cela suffira).