====== Quelques notes sur le langage PYTHON ======

> Rédigé à partir de différentes sources :

  * Recherches en ligne,
  * Livres..

> Travaillé sous environnement Linux.\\

===== ECRIRE UN PROGRAMME =====
==== Avec le Shell (ou interpréteur) PYTHON ====
Pour entrer dans le "Shell Python", saisissez  ''python''  ou bien  ''python3''  dans le terminal (ou 3 est le numéro de version).\\
Pour sortir du "Shell Python", saisissez ''Quit()'' ou bien ''exit()'' dans le terminal.
  * Utile pour tester directement des lignes de codes.

>>> A SAVOIR : si plusieurs version de Python sont installés, on peut choisir d'en utiliser une à l'aide de la commande :
<code>
py -lenumérodeversion
</code>
==== Avec un éditeur de texte ====
//..choisir son éditeur de texte préféré..//\\
>> NOTE : UTF8 permet de s'assurer de pouvoir utiliser les caractères spéciaux (accents, cedille..).
==== Mon premier programme PYTHON ====
\\
Créer un nouveau fichier dans son éditeur de texte préféré..
<code>
#!/usr/bin/env python
print("Bonjour, je suis un programme ecrit en Python.")
ChampNom = input("Quel est votre prénom ? ")
print("Salut, " + ChampNom + "!")
</code>
> Ici, s'affiche ''"Salut //prénom// !"''
La dernière ligne de code précédente peut aussi s'écrire ;
<code>
print("Salut, ", ChampNom, " !")
</code>

>>> A SAVOIR : une autre manière d'afficher le contenu d'une variable ;
<code>
print(f"Bien le bonjour {ChampNom} :) prêt à étudier le langage Python ??")
</code>

>>> A SAVOIR : Entre les accolades peut figurer une variable ou une expression

Enregistrer le fichier sous.. "MonProgramme.py"\\
Exécution du programme depuis la ligne de commande\\
  * à l’emplacement du fichier..\\
  * ou avec le chemin complet..\\
Pour exécuter le programme sous environnement Linux.\\
Il faut d’abord rendre le fichier exécutable en saisissant la ligne ci-dessous, dans le répertoire ou est stocké le fichier :
<code>
chmod +x MonProgramme.py
</code>

>> REMARQUE :
- Pour exécuter le programme, si l’on n’est pas positionné dans le répertoire, il faut saisir intégralement le chemin..\\
- On peut aussi exécuter le programme avec la syntaxe :
<code>
python3 MonProgramme.py
</code>
===== LA CASSE =====
\\
Dans Python, la casse est importante.\\
Ainsi :
<code>
print(2+2)
</code>
> affiche bien le résultat, soit 4,

<code>
Print(2+2)
</code>
> "print" avec "P" majuscule, génère une erreur.
===== NOTION D'OBJET =====
\\
:?:**..compréhension à revoir..**\\
Un objet est une information à traiter..\\
Un objet, est tout autre qui n'est pas un "mot clé", "une fonction", "une variable".\\
Pour manipuler un objet avec Python, on peut le stocker/mémoriser dans une variable.
===== LES VARIABLES =====
//SYNTAXES - Affectation d'une variable//\\
<code>
NomDeLaVariable = Valeur
</code>

  * Comparaison ou contrôle de contenu
<code>
NomDeLaVariable == 'contenu'
</code>
==== Type de données ====
Il n'est pas nécessaire de définir le type d'une variable. Elle prend le type du contenu qu'on lui donne.\\
Assigner une valeur s'écrit :
<code>
mois = 'Janvier’
</code>

Connaître le type d'une variable s'écrit :
<code>
print(type(NomDeLaVariable))
</code>

Modifier le type d'une variable s'écrit :
<code>
print LibelléDuType(NomDeLaVariable)
</code>

Exemple :
<code>
print int(s)
</code>
  * dans l'Exemple "s" étant une variable de type caractère,
  * avec "int" elle devient une variable de type numérique (integer). 
==== Déclaration d'une liste (ou tableau) ====
//SYNTAXES d'une liste//
<code>
NomListe = ['Valeur 1', 'Valeur 2', 'Valeur x', ...]
</code>

Exemple :\\
  * La liste des mois peut s'écrire :
<code>
mois = [ 'Jan', 'Fev', 'Mars', 'Avril', 'Mai', 'Juin', 'Juil', 'Aout', 'Sep', 'Oct', 'Nov', 'Dec' ]
</code>

  * Pour afficher "Mars", cela peut s'écrire :
<code>
print mois[2]
</code>

Exemple :\\
  * Créé une liste à partir d'une chaine, peut s'écrire :
<code>
list("Que donne cette ensemble de caractères dans une liste")
</code>
  * A pour effet de mettre chaque caractère et espace dans une "case"..
\\
On peut remplacer l'élément d'une liste.\\
Exemple :
<code>
mois[3] = "En avril fait ce qu'il te plaît"
</code>
  * Pour le vérifier, on peut afficher la liste, cela s'écrit :
<code>
print(mois)
</code>
\\
On peut afficher un ensemble d'éléments, en exprimant une plage (de x à y-1).\\
Exemple :
<code>
print(mois[2:8])
</code>
  * A pour effet d'afficher les éléments 2, 3, 4, 5, 6 et 7.
\\
On peut afficher un ensemble d'éléments, tout ou partie d'une plage, dit le slicing.\\
Exemple 01 :
<code>
print(mois[:2])
</code>
  * A pour effet d'afficher les valeurs dans les index inférieur à 2.
\\
Exemple 02 :
<code>
print(mois[2:])
</code>
  * A pour effet d'afficher les valeurs dans les index supérieur à 2.
\\
On peut imbriquer plusieurs listes dans une variable liste.\\
Exemple 01 :
<code>
MesListes = [Liste1, Liste2]
</code>
  * Les listes sont ici distinctes, il y a bien 2 listes.
\\
Exemple 02 :
<code>
MesListes = Liste1 + Liste2
</code>
  * A pour effet de concaténer les listes, il n'y a plus qu'une seule liste.
\\
On peut ajouter des éléments à une liste.\\
Exemple :
<code>
mois.append("Bonne année !!!")
</code>
\\
On peut supprimer un éléments d'une liste.\\
Exemple :
<code>
del mois[6]
</code>
\\
On peut supprimer le dernier élément ajouté.\\
Exemple :
<code>
mois.pop()
</code>
\\
//CURIOSITE//\\
Inverser les informations/les caractères.\\
Exemple :
  * Inverser les lettres d'une phrase, peut s'écrire :
<code>
"Bonjour tout le monde"[::-1]
</code>
==== Déclaration d'un tuple ====
//SYNTAXES d'un tuple//\\
<code>
NomTuple = ('Valeur 1', 'Valeur 2', 'Valeur x', ...)
</code>

Un tuple ou n-uplet est une liste non modifiable.\\
Exemple :
  * La liste des jours, peut s'écrire :
<code>
ListeJours = (Lun, Ma, Me, Je, Ve, Sam, Dim)
</code>
==== Déclaration d'un dictionnaire ====
//SYNTAXES d'un dictionnaire//
<code>
NomDictionnaire = {'Clé 1' : ('Valeur 1', 'Valeur 2', 'Valeur x'), 'Clé 2' : 'Valeur 1', 'Clé 3' : 'Valeur 1', ...}
</code>

Un "dictionnaire" est :
  * Une "liste particulière", il est constitué d'ensemble de "clés" et "valeurs", il peut y avoir plusieurs valeurs elles sont alors mises entre parenthèses et séparées par des virgules,
  * Une collection non ordonnées.\\
Exemples :
  * Pour créer une liste des sports préférés de personnes/personnages :
<code>
sports_favoris = { 'Frédéric Chopin' : ('Football', 'Ping-Pong'), 'Ludwig van Beethoven' : 'Basket-ball', 'Wolfgang Amadeus Mozart' : 'Base-ball', 'Antonio Vivaldi' : 'Volley ball', 'Jean-Sébastien Bach' : 'Badminton', 'Hector Berlioz' : 'Rugby' }
</code>

  * Pour afficher le sport favoris de Hector Berlioz :
<code>
print(sports_favoris['Hector Berlioz'])
</code>

  * Pour supprimer une clé et sa/ses valeur(s) :
<code>
del sports_favoris['Ludwig van Beethoven']
</code>

  * Pour remplacer la ou les valeur(s) :
<code>
sports_favoris['Frédéric Chopin'] = 'Hockey sur glace'
</code>

  * Pour ajouter "Footsal" à l'existant :
<code>
sports_favoris['Frédéric Chopin'] = 'Hockey sur glace', 'Footsal'
</code>
>>> VOIR FICHIER : 20231218_page46pkids-dict.py

  * Pour savoir si une clé existe, on peut écrire :
<code>
"terme-recherché" in sports_favoris
</code>
> Il est alors retourné la valeur TRUE ou FALSE.

>>> A SAVOIR : Il ne doit pas y avoir de doublons de clé, soit de libellé identique.

  * Pour lister toutes les clés et les valeurs. On utilise la méthode "items".\\
Exemple :
<code>
sports_favoris.items()
</code>
> A pour effet d'afficher en une ligne (soit l'équivalent d'une "liste" de "tuples"), l'ensemble de clés/valeurs du dictionnaire.

  * Pour parcourir toutes les clés et valeurs, on peut l'écrire :
<code>
for elements in sports_favoris.items():
  print(elements)
</code>

> Le résultat de l'affichage permet de voir que chaque ligne est un tuple, cela peut donc s'écrire aussi :
<code>
for elements in sports_favoris.items():
  print(type(elements))
</code>

Aussi, on peut énumérer les clés ou les valeurs à l'aide de l'indexation :
  * Soit pour les clés ;
<code>
for elements in sports_favoris.items():
  print(elements[0])
</code>
  * Soit pour les valeurs ;
<code>
for elements in sports_favoris.items():
  print(elements[1])
</code>

Ou bien l'on peut, énumérer les clés et les valeurs à l'aide de variables, respectivement ici "personnage" et "sport", ce qui peut s'écrire ;
<code>
for personnage, sport in sports_favoris.items():
  print(personnage)
</code>
<code>
for personnage, sport in sports_favoris.items():
  print(sport)
</code>

>>> A SAVOIR : Les éléments d'un dictionnaire ne sont pas ordonnés (classés par ordre alphabétique ou alphanumérique par Exemple) ainsi ils ne peuvent être lu/parcouru dans l'ordre alphabétique ou alphanumérique.
==== Imbriquer les listes, les tuples et les dictionnaires ====
//SYNTAXES//\\
UNE LISTE
<code>
NomListe = ['Valeur 1', 'Valeur 2', 'Valeur x', ...]
</code>
UN TUPLE
<code>
NomTuple = ('Valeur 1', 'Valeur 2', 'Valeur x', ...)
</code>
UN DICTIONNAIRE
<code>
NomDictionnaire = {'Clé 1' : ('Valeur 1', 'Valeur 2', 'Valeur x'), 'Clé 2' : 'Valeur 1', 'Clé 3' : 'Valeur 1', ...}
</code>

Un tuple dans une liste.\\
Exemple ;
<code>
L = ['a', 'b', ('2', '4', '6')]
</code>

Les listes et les tuples étant indexés, on peut interroger chaque éléments. Cela peut s'écrire :\\
''L[0]'' affiche 'a',\\
''L[1]'' affiche 'b',\\
''L[2][0]'' affiche '2',\\
''L[2][1]'' affiche '4',\\
''L[2][2]'' affiche '6',\\

Exemple, pour illustrer :
>>> VOIR FICHIER : < 20240225_elephorm_test-liste.py >
==== Substitution ====
\\
''%s '' : pour substituer une variable de type caractère, soit "string",\\
''%d '' : pour substituer une variable de type numérique, soit "integer".\\
Exemple :
<code>
Mois = ['Jan','Fév','Mars','Avr','Mai','Juin','Juil','Août','Sept','Oct','Nov','Déc']
JoursDansMois = [31,28,31,30,31,30,31,31,30,31,30,31]
 for cmptr in range(0,12):
 print('%s a %d jours.' % (Mois[cmptr],JoursDansMois[cmptr])) 
</code>

Le résultat de ce code est :
> Jan a 31 jours.
> Fév a 28 jours.
> Mars a 31 jours.
> Avr a 30 jours.
> Mai a 31 jours.
> Juin a 30 jours.
> Juil a 31 jours.
> Août a 31 jours.
> Sept a 30 jours.
> Oct a 31 jours.
> Nov a 30 jours.
> Déc a 31 jours.
===== LES BOUCLES =====
\\
..en construction..
===== LES CARACTÈRES D’ÉCHAPPEMENTS =====
\\
Exemple :
<code>
chaine = ’La syntaxe est importante en Python’
</code>
<code>
chaine = ”La syntaxe est importante en Python”
</code>
> Produit le même résultat à l’affichage.

Au sein d’une chaîne si l’on veut intégrer le guillemet simple ou le guillemet double, il faut entourer la chaîne du guillemet qui n’a pas besoin d’être affiché.\\
Exemple :\\
  * Pour afficher le guillemet simple, on l'entoure du guillemet double.
<code>
chaîne = ”Dis s’il te plaît”
</code>

Mais pour afficher : Elle a dit ”Ne t’inquiète pas”\\
  * Il faudra utiliser le caractère dit d’échappement, soit l’anti-slash ”\”
<code>
chaîne = ’Elle a dit ”Ne t\'inquiète pas”’
</code>
>>> A SAVOIR : il existe d’autres caractères d’échappements utiles, par Exemple le retour à la ligne et aussi la tabulation. On peut aussi encadrer une chaîne de caractère avec trois guillemets simple, ce qui a pour effet de traiter tous ce qui est encadrés comme du "texte brut".
===== LES OPÉRATEURS =====
^ Opérateur		^ Signe ^
| Égalité		| == |
| Supérieur à		| > |
| Supérieur ou égal à	| >= |
| Inférieur à		| < |
| Inférieur ou égal à	| <= |
| Différent de		| != |
===== LES MODULES =====
Un module, contient un ensemble de fonctions. Ils correspondent en général à une thématique précise.\\
Ils peuvent être réutiliser, on dit "être appeler".\\
Exemples de modules :
  * "random", qui permet de générer des nombres aléatoirement.
  * "SQLite", pour le traitement de base de données.
==== Créer un module ====
C'est écrire un ensemble de fonctions. Enregistrées dans un fichier ".py".
==== Déclarer un module ====
\\
//SYNTAXES//\\
<code>
import NomDuFichierPython
</code>
sans l'extension, à condition d'être dans le même répertoire que le fichier appelant.\\

Exemple à voir :
  * VM linux mint /home/temujin/Documents/exercices-python/20231111_FONCTIONtest04.py

>> REMARQUE : l'usage de l'underscore dans le nom d'un fichier est déconseillé, cela peut faire bugger le code..
> Sinon il faudra éditer la variable d'environnement PYTHONPATH pour faire figurer un chemin dans lequel trouver les fichiers py créer pour être des modules. Soit saisir dans le shell linux :
<code>
export PYTHONPATH=$PYTHONPATH: /chemin/vers/mes/modules
</code>

Pour vérifier, saisir :
<code>
echo $PYTHONPATH
</code>

>> INTERROGATION : Comment lister les modules par défaut, fournis avec l'installation de python ???
> Pour avoir une idée des modules présent, lire sommaire < D:\hdd-hvm\Documents\Gestion personnel\Culture SIC\Dossiers PRO\FAE\DOCINFO\Coding\Programmation Python - Tarek Ziadé - Eyrolles (2ème Ed.) 2009.pdf >
> Pour tâcher de mieux comprendre "les modules", lire (autour de la page 47..) < D:\hdd-hvm\Documents\Gestion personnel\Culture SIC\Dossiers PRO\FAE\DOCINFO\Coding\tuto python.pdf >
===== LES FONCTIONS =====
Dès lors que l'on a besoin du même ensemble de lignes de code, la fonction permet de le réutiliser sans avoir à le réécrire.\\
Elle s'utilise au sein d'un même fichier ".py".
>> INTERROGATION : Peut-elle être appelée dans un autre fichier "py" ? Oui, avec le principe de "module", voir précédent.
==== Déclarer une fonction ====
//SYNTAXES//\\
<code>
NomDeLaFonction(Argument1,Argument2,..)
</code>
Exemple à voir :
  * /home/temujin/Documents/exercices-python/20231111_FONCTIONtest03.py

__EXERCICE SUR LES MODULES__\\
../Culture%20personnel/Lecture/FullCircleMagazine/NS_PythonFullfr.pdf, PAGE 14,\\
Sur la base de ce qui a été vue précédemment,\\
**Objectif**\\
Création d'un programme qui affiche une liste d'achat, mise en forme.\\
Afficher :
  * Le coût de chaque objet,
  * Le total général, formaté en Euros et Centimes,

Personnalisation :
  * La largeur du tableau doit pouvoir être modifiée,
  * Les valeurs à gauche et à droite doivent pouvoir être variables.

Création de 3 fonctions :
  - Affichage des lignes du haut et du bas,			> "HautOuBas",
  - Affichage du détails des objets et le total général,	> "PartieCentrale"
  - Affichage de la ligne de séparation.			> "LigneIntermediaire"

Espaces de travail ;
  * Premier espace de travail (pour travailler avec les fonctions) :	/home/temujin/Documents/exercices-python/
  * Second espace de travail (pour appliquer la notion de module) :	/home/temujin/Documents/exercices-python/liste-achats/

>> NOTE "HautOuBas" est un premier essai de compréhension, "LigneIntermediaire" est devenu utiles à point 1. et point 3.