Modification de Python

=1. Exécuter des commandes Python depuis un terminal Linux. :=

Pour démarrer l'interpréteur Python :
 python3
Pour quitter l'interpréteur :
 quit()
On peut également faire '''[CTRL]''' + '''[D]'''.

=2. Les en-têtes de fichiers sous Linux (à adapter en fonction de votre version de Python). :=

Je travaille sous Linux Mint (version de Python 3.10.12) et mes scripts Python commence toujours par les deux lignes suivantes :

 <nowiki>#!/usr/bin/env python3.10</nowiki>
 <nowiki>#-*- coding: utf-8 -*-</nowiki>

Pour rendre le script exécutable :
 chmod +x ''fichier.py''

Pour exécuter le script depuis le dossier où il se trouve :
 ./fichier.py

<span style="color: #0000FF;"><big>'''Commandes Shell Linux pour connaître ses versions de Python :'''</big>
 python2 --version

 python3 --version

<span style="color: #0000FF;"><big>'''Éditeur de fichiers :'''</big>

Pour éditer mon fichier Python sous Linux j'utilise Sublime Text : https://www.sublimetext.com/

<span style="color: #0000FF;"><big>'''Mettre un programme en pause :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 print("Bienvenue chez Mémoire Vive")
 print("[Entrée] pour continuer !")
 input()

=3. Print :=
 print(Hello World !')

 print('Hello\nWorld !')
Retour à la ligne \n.

 print('Hello\tWorld !')
Tabulation \t.

 print('What\'s up ?')
Caractère d'échappement \.

<span style="color: #0000FF;"><big>'''Afficher le contenu d'une variable :'''</big>
 variable = 'test'
 print(variable)

 age = '5'
 print('Bonjour, j\'ai', age, 'ans.')
On peut utiliser les simple quote ' ou les double quote ".

<span style="color: #0000FF;"><big>'''Les chaînes de caractères formatées :'''</big>
 prénom = "Dominique"
 âge = 59
 phrase = f"Je m'appelle {prénom} et j'ai {âge} ans."
 print(phrase)

Autre syntaxe pouvant être utilisée également lors de la création d'objets :

 print("{} {} a dit : {}".format(self.prénom, self.nom, message))

=4. Input :=
 user_name = input('What is your name ?')
 print(user_name)

=5. Les variables :=
<big>'''Les différents types de variables.'''</big>

<span style="color: #0000FF;"><big>'''Types de Base :'''</big>

Integer ('''int''') : Nombres entiers.

Float ('''float''') : Nombres à virgule flottante (décimaux) - ''On utilise des points pas des virgules.''

String ('''str''') : Chaînes de caractères (texte).

Boolean ('''bool''') : True ou False.

<span style="color: #0000FF;"><big>'''Types Composés :'''</big>

'''List''' : Représente une collection ordonée de valeurs modifiables. Exemple : fruits = ["apple","banana","cherry"]

'''Tuple''' : Représente une collection ordonnée de valeurs immuables. Exemple : coordinate = (10.0, 20.0)

Dictionary ('''dict''') : Représente une collection de paires clé-valeur. Exemple : person = {"name": "Alice", "age": 30}

'''Set''' : Représente une collection non ordonnée de valeurs uniques. Exemple : unique_numbers = {1, 2, 3, 4}

<span style="color: #0000FF;"><big>'''Types Spéciaux :'''</big>

'''NoneType''' : Valeur nulle ou vide. Exemple : result = None

'''Complex''' : Représente des nombres complexes. Exemple : z = 1 + 2j

<span style="color: #0000FF;"><big>'''Connaître le type d'une variable :'''</big>

 type(''variable'')

<span style="color: #0000FF;"><big>'''Supprimer une variable :'''</big>

 del variable

<span style="color: #0000FF;"><big>'''Conversion entre Type de Variables :'''</big>

Convertir en entier ('''int''') : Exemple : x = int("123) ou y = int(3.14)

On peut également utiliser '''float()''', '''str()''', '''bool()''', '''list()''', '''tuple()''', '''set()''', '''dict()'''

<span style="color: #0000FF;"><big>'''Plus d'informations :'''</big>

 name = 'Dominique'

 firstname, lastname = 'Dominique', 'Renaudeau'

 variable1 = variable2 = True

'''Incrémenter une variable'''

 i = i+1

ou

 i += 1

Dans le même ordre d'idées il existe par exemple '''i /= 2''' et '''i *= 2''' à vous de tester !

'''Permutation'''

a, b = b, a

=6. Les opérateurs mathématiques :=

{| class="wikitable" style="margin:auto"
|+ Les opérateurs mathématiques
|-
! Opérateurs !! Légendes
|-
| + || Adition
|-
| - || Soustraction
|-
| * || Multiplication
|-
| / || Division
|-
| ** || Puissance
|-
| % || Modulo, retourne le reste de la division.
|-
| // || Quotient d’une division, partie entière.
|}

=7. Les instructions conditionnelles :=

Exemple de programme testé sous Linux Mint avec son en-tête (à adapter). Vous pouvez tester les modifications des valeurs de var1 et var2. Le fichier .py doit être exécutable : chmod +x ''fichier.py''  

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 var1 = 3
 var2 = 1
 if var1 < var2:
     print('var1 inférieure')
 elif var2 < var1:
     print('var2 inférieure')
 else:
     print('var1 et var2 égales')

''Indentation (4 espaces) pour indiquer les blocs de code.''

Un exemple de code avec une "fourchette".

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 age = 8
 if 10 <= age <= 50:
     print('vous avez entre 10 et 50 ans.')
 else:
     print('vous n\'avez pas entre 10 et 50 ans.')

=8. Les opérateurs de comparaison :=

{| class="wikitable" style="margin:auto"
|+ Les opérateurs de comparaison
|-
! Opérateurs !! Légendes
|-
| == || Égalité
|-
| < || Inférieur
|-
| > || Supérieur
|-
| <= || Inférieur ou égal
|-
| >= || Supérieur ou égal
|-
| != || Différent
|}

=9. Les opérateurs logiques :=

{| class="wikitable" style="margin:auto"
|+ Les opérateurs logiques
|-
! Opérateurs !! Légendes
|-
| and || Et logique
|-
| or || Ou logique
|-
| is || Affirmation
|-
| not || Négation
|-
| in || Appartient
|}


'''and''' Et logique

'''or''' Ou logique

'''is''' Affirmation

'''not''' Négation

'''in''' Appartient

=10. Les boucles :=

<span style="color: #0000FF;"><big>'''La boucle while - Tant qu'une condition est vraie :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 i = 1 # Initialisation de la variable
 while i <= 10: # Condition - Tant que i est inférieure ou égale à 10
     print(i) # Afficher la valeur de la variable i
     i += 1 # Incrémenter i

''Exemple de boucle infinie en utilisant une variable booléenne. On utilise les mots-clés break et continue.''

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Ma_Boucle = True
 while Ma_Boucle: # Ma_Boucle = True la boucle est infinie
     Choix = input('Continuer ou Stop : ')
     if Choix == 'Stop':
         break
     elif Choix == 'Continuer':
         continue
     else:
         print('Commande inconnue !')

<span style="color: #0000FF;"><big>'''La boucle for - On parcourt une chaîne de caractères :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive" # La chaîne de caractères que l'on va parcourir
 for lettre in chaîne:
     print(lettre)

<big>'''Le mot-clé continue'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 for chiffre in [1,2,3,4,5]:
     if chiffre == 2:
         continue
     print('Chiffre : ', chiffre)
 # Affichera 1 3 4 5

<big>'''Le mot-clé break'''</big>

''Permet d'interrompre une boucle while ou for.''

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 for chiffre in [1,2,3,4,5]:
     if chiffre == 4:
         break
     print('Chiffre : ', chiffre)
 # Affichera 1 2 3

=11. Les fonctions :=

def est le mot-clé qui constitue le prélude à toute construction de fonction. Suivent le nom de la fonction et les paramètres.

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 # ******** Fonction addition ***********
 def addition(chiffre1, chiffre2):
     # Remplacer les , par des .
     chiffre1 = chiffre1.replace(",",".")
     chiffre2 = chiffre2.replace(",",".")
     """ Convertir les chaînes de caractères en décimaux avec float()
         Gestion des erreurs de saisies avec try except else """
     try:
         chiffre1 = float(chiffre1)
     except ValueError:
         print('valeur incorrecte')
         exit() 
     try:        
         chiffre2 = float(chiffre2)
     except ValueError:
         print('valeur incorrecte')
         exit()   
     else:
         # Retourner le résultat
         return chiffre1 + chiffre2
 # **************************************
 print('Saisir les deux chiffres à aditionner.')
 chiffre1 = input('Premier chiffre : ')
 chiffre2 = input('Deuxième chiffre : ')
 # Appeler la fonction addition
 résultat = addition(chiffre1, chiffre2)
 # Afficher le résultat
 print(résultat)

''Il existe également les fonctions lambda (une seule ligne).''

=12. Les modules :=

<span style="color: #0000FF;"><big>'''La méthode import :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 import math # Importer le module math
 Résultat = math.sqrt(64) # Renvoie la racine carrée
 print(Résultat) # Afficher le résultat

Dans ce cas on doit mentionner '''math.sqrt'''.

Si on veut des informations, on peut taper '''help(math.sqrt)''' dans l'interpréteur Python après un import math.

La documentation en français du module math : https://docs.python.org/fr/3.5/library/math.html 

<span style="color: #0000FF;"><big>'''La méthode from... import... :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 from math import fabs# importer la fonction valeur absolue du module math
 Résultat = fabs(-64) # Renvoie la valeur absolue
 print(Résultat) # Afficher le résultat

Dans ce cas on mentionne directement '''fabs'''.

On peut appeler toutes les variables et fonctions d'un module avec * :

 from math import *

''On peut créer nos propres modules, des fichiers .py hébergeant des fonctions.''

=13. Les exceptions :=

la forme la plus simple try except :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Nombre = input('Entrez un nombre entier : ')
 try:
     Nombre = int(Nombre) # Conversion en entier
     print(Nombre) # Afficher le nombre
 except:
     print('Je veux un nombre entier!') # Si ce n'est pas un nombre entier

La forme avec try except else finally :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Nombre = input('Entrez un nombre entier : ')
 try:
     Nombre = int(Nombre) # Conversion en entier
 except:
     print('Je veux un nombre entier !') # Si ce n'est pas un nombre entier
 else:
     print(Nombre) # Afficher le nombre
 finally:
     print('Le programme est terminé !') # Afficher quel que soit le résultat

Un exemple simple pour notre exception '''ValueError''' :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Nombre = input('Entrez un nombre : ')
 try:
     Nombre = int(Nombre) # Conversion en entier
     print(Nombre) # Afficher le nombre
 except ValueError:
     print('Je veux un nombre entier !') # Si ce n'est pas un nombre entier

Si l'on souhaite tester un bloc d'intructions... mais ne rien faire en cas d'erreur on peut utiliser le mot-clé '''pass''' dans le bloc suivant except.

''Par la suite, on peut voir les assertions et la levée d'exceptions.''

=14. La chaîne de caractères :=

<span style="color: #0000FF;"><big>'''Les méthodes de la classe str :'''</big>

Mettre une chaîne en minuscules :

 chaîne = "JE M'APPELLE DOMINIQUE"
 chaîne = chaîne.lower() # Mettre le contenu de la variable chaîne en minuscules
 print(chaîne)

Mettre une chaîne en majuscules :

 chaîne = "je m'appelle dominique"
 chaîne = chaîne.upper() # Mettre le contenu de la variable chaîne en majuscules
 print(chaîne)  

Mettre la première lettre de la chaîne en majuscule :

 chaîne = "mémoire vive"
 chaîne = chaîne.capitalize() # Mettre la première lettre de la chaîne en majuscule
 print(chaîne)

Mettre la première lettre de chaque mot de la chaîne en majuscule :

 chaîne = "mémoire vive"
 chaîne = chaîne.title() # Mettre la première lettre de chaque mot de la chaîne en majuscule
 print(chaîne)  

Centrer une chaîne de caractères dans la longueur voulue, utiliser un caractère à la place des espaces :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive"
 chaîne = chaîne.center(20)
 print(chaîne)
 chaîne = "Mémoire Vive"
 chaîne = chaîne.center(50,"-")
 print(chaîne)

<span style="color: #0000FF;"><big>'''Méthode de parcours par while :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive"
 i = 0 # Initialisation de i
 while i < len(chaîne):
     print(chaîne[i]) # On affiche le caractère à chaque tour de boucle
     i += 1 # On incrémente i

<span style="color: #0000FF;"><big>'''Sélection de chaînes :'''</big>

<span style="color: #196f3d;">''Les indices débutent par le 0.''</span>

 chaîne[0:2] On sélectionne les deux premières lettres - Depuis 0 2 lettres

 chaîne[2:len(chaîne)] # On sélectionne la chaîne sauf les deux premières lettres - Depuis 2 jusqu'à la longueur de la chaîne

<span style="color: #0000FF;"><big>'''Remplacer un caractère dans une chaîne :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Mot = "saison"
 print(Mot)
 Mot = "m" + Mot[1:]
 print(Mot)

<span style="color: #0000FF;"><big>'''Pour les instructions conditionnelles :'''</big>

Rechercher une chaîne de caractères dans une autre :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive"
 if "Vive" in chaîne:
     print("J'ai trouvé la chaîne de caractères")
 else:
     print("Je n'ai pas trouvé la Chaîne de caractères")

Tester si une chaîne de caractères est en minuscules :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Mot = "test"
 if Mot.islower(): # Si Mot est en minuscules
     print("lower - Minuscules")
 else:
     print("upper - Majuscules")

Voir également :

.islower() .isupper is() .isalpha() .isdigit() .isdecimal() .isnumeric() .isalpha() .isidentifier() etc.

<span style="color: #0000FF;"><big>'''Rechecher une chaîne de caractères :'''</big>

Rechercher un chaîne de caractères avec .find() :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive"
 print(chaîne.find("Vive")) # Retourne l'indice du premier caractère de la chaîne recherchée
 print(chaîne.find("Niort")) # Retourne -1 si la chaîne recherchée n'est pas trouvée

On peut lever une erreur avec .index() :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 chaîne = "Mémoire Vive"
 try:
     print(chaîne.index("Vive")) # Retourne l'indice du premier caractère de la chaîne recherchée
 except ValueError:
     print("Je n'ai pas trouvé cette chaîne")

<span style="color: #0000FF;"><big>'''Transformer une chaîne de caractères en liste :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 Phrase = "Chats|Chiens|Lapin"
 print(type(Phrase))
 print(Phrase)
 Phrase = Phrase.split("|") # Transformer Phrase en liste
 print(type(Phrase))
 print(Phrase)

=15. Les listes :=

<span style="color: #196f3d;">''Les listes sont des séquences, des objets capables de regrouper d’autres objets.''</span>

<span style="color: #0000FF;"><big>'''Créer une liste :'''</big>

Créer une liste vide :

 ma_liste = list()

''ou''

 ma_liste =[]

Créer une liste avec des élément (objet) :

 ma_liste = [1, 2, 3, 4, 5]

''ou par exemple''

 ma_liste = [1, 3.5, "une chaîne", []]

Tous les types d'objets sont autorisés, ici un entier, un flottant, une chaîne de caractères et une autre liste.

<span style="color: #196f3d;">''Autres exemples de créations de listes.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = [0] * 10 # ma_liste contient 10 éléments egaux à 0
 print(ma_liste)
 ma_liste = ["A"] * 10 # ma_liste contient 10 éléments egaux à A
 print(ma_liste)
 ma_liste = range(20) # Attribut les valeurs allant de 0 à 19 aux 20 éléments de ma_liste
 print(ma_liste)
 for chiffre in ma_liste: # Parcourir ma_liste pour afficher les éléments
     print(chiffre) 

<span style="color: #0000FF;"><big>'''Effacer les éléments d'une liste :'''</big>

 ma_liste[:] = []

''ou''

 ma_liste.clear()

<span style="color: #196f3d;">''Remplacer tous les éléments d'une liste par un élément.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice', 'Patrice']
 print(ma_liste)
 # Remplacer tous les éléments de la liste par "Prénom"
 ma_liste[:] = ["Prénom"] * len(ma_liste)
 print(ma_liste)

<span style="color: #0000FF;"><big>'''Ajouter ou insérer un élément dans une liste :'''</big>

Ajouter un élément à la fin de la liste :

 ma_liste = [1, 2, 3]
 ma_liste.append(4) # On ajoute 4 à la fin de la liste

Insérer un élément dans la liste :

 ma_liste = ['a', 'b', 'd', 'e']
 ma_liste.insert(2, 'c') # On insère 'c' à l'indice 2 (les indices débute avec le 0)

<span style="color: #0000FF;"><big>'''Ajouter une liste à une autre - Concaténation :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste1 = ['a', 'b', 'c']
 print(ma_liste1)
 ma_liste2 = ['e', 'f', 'g']
 ma_liste3 = ['h', 'i', 'j']
 ma_liste = ma_liste1 + ma_liste2
 print(ma_liste)
 ma_liste += ma_liste3 # Identique à extend
 print(ma_liste)

Avec la méthode extend() :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste1 = ['a', 'b', 'c']
 print(ma_liste1)
 ma_liste2 = ['e', 'f', 'g'] 
 print(ma_liste2)
 ma_liste1.extend(ma_liste2) # ajouter ma_liste2 à ma_liste1
 print(ma_liste1)

<span style="color: #0000FF;"><big>'''Supprimer des éléments d'une liste :'''</big>

Avec les indices :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['a', 'b', 'c', 'e', 'f', 'g', 'h', 'i', 'j']
 print(ma_liste)
 del ma_liste[0] # On supprime le premier élément de la liste
 print(ma_liste)
 del ma_liste[4] # On supprime le cinquième élément de la liste
 print(ma_liste)

Avec le méthode remove :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['a', 'b', 'c', 'e', 'f', 'g', 'h', 'i', 'j']
 print(ma_liste)
 ma_liste.remove('f') # On supprime l'élément 'f' de la liste
 print(ma_liste)

<span style="color: #0000FF;"><big>'''Parcourir les listes :'''</big>

<span style="color: #196f3d;">''Première méthode avec une boucle while.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 i =0
 while i < len(ma_liste):
     print(ma_liste[i])
     i += 1

<span style="color: #196f3d;">''Cette méthode avec une boucle for est préférable à la première.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 for prénom in ma_liste:
     print(prénom)

La méthode enumerate :

<span style="color: #196f3d;">''Pour afficher l'indice et l'élément.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 for prénom in enumerate(ma_liste):
     print(prénom)

voilà le résultat dans un tuple !

(0, 'Dominique')

(1, 'Denis')

(2, 'Alain')

(3, 'Patrice')

(4, 'Maurice')

<span style="color: #196f3d;">''Autres exemples.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 print("Afficher toute la liste")
 print(ma_liste[:])
 print("Afficher l'indice 1")
 print(ma_liste[1])
 print("Afficher les deux premiers éléments")
 print(ma_liste[:2])
 print("Afficher les éléments sauf les trois premiers")
 print(ma_liste[3:])
 print("Afficher le troisième élément en partant de la fin")
 print(ma_liste[-3])
 print("Afficher le premier élément en partant de la fin")
 print(ma_liste[-1])
 print("Afficher les éléments ayant les indices 2 et 3")
 print(ma_liste[2:4])

<span style="color: #0000FF;"><big>'''Rechercher un élément dans une liste :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 if 'Patrice' in ma_liste:
     print("Patrice est dans la liste")
 else:
     print("Je n'ai pas trouvé Patrice dans la liste")

<span style="color: #196f3d;">''Afficher l'indice d'un élément.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice', 'Patrice']
 print(ma_liste)
 print("Premier indice de \"Patrice\" :", ma_liste.index("Patrice")) # Afficher l'indice du premier élément "Patrice" dans la liste

<span style="color: #0000FF;"><big>'''Trier les éléments :'''</big>

<span style="color: #196f3d;">''On peut trier des données du même type.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 print(ma_liste)
 ma_liste.sort() # Tri par ordre alphabétique ou croissant
 print(ma_liste)
 ma_liste.reverse() # Tri inverse ou décroissant
 print(ma_liste)
 ma_liste = [5, 1, 13, 6, 2600]
 print(ma_liste)
 ma_liste.sort() # Tri par ordre alphabétique ou croissant
 print(ma_liste)
 ma_liste.reverse() # Tri inverse ou décroissant
 print(ma_liste)

<span style="color: #0000FF;"><big>'''Compter un élément :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice', 'Dominique']
 print(ma_liste)
 print("Nombre de fois où je trouve Dominique :",ma_liste.count("Dominique"))

<span style="color: #0000FF;"><big>'''Copier une liste :'''</big>

<span style="color: #196f3d;">''On obtient une copie indépendante de la liste originale.''</span>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 import copy
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 ma_liste2 = copy.deepcopy(ma_liste) # On crée une copie indépendante de ma_liste
 ma_liste.append('Jonathan') # On ajoute Jonathan à la fin de ma_liste
 print(ma_liste)
 print(ma_liste2)
 # On a bien deux listes indépendantes

<span style="color: #0000FF;"><big>'''Transformer une liste en chaîne de caractères :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 ma_liste = ['Dominique', 'Denis', 'Alain', 'Patrice', 'Maurice']
 print(ma_liste)
 print(type(ma_liste))
 phrase = "-".join(ma_liste) # On transforme la liste en chaîne de caractères avec le caractère - comme séparateur 
 print(phrase)
 print(type(phrase))

=16. Les tuples :=

<span style="color: #196f3d;">''Un tuple se définit comme une liste, sauf qu’on utilise comme délimiteur des parenthèses au lieu des crochets. À la différence des listes, les tuples, une fois créés, ne sont pas modifiables.''</span>

<span style="color: #0000FF;"><big>'''Création de tuples :'''</big>

 mon_tuple = (1, 2, 3)

''ou''

 mon_tuple = 1, 2, 3

''le mieux est d'utiliser les parenthèses pour identifier le tuple.''

 mon_tuple = () # Créer un tuple vide

 mon_tuple = (1, ) # créer un tuple avec un seul élément (nécessite une virgule)

 Animateurs = ("Maurice", "Dominique", "Denis", "Alain", "Patrice")
 print(type(Animateurs)) # afficher la classe de l'objet

''Affectations multiples :''

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 # Affectations multiples ou retours multiples dans le cas d'une fonction (on peut modifier les valeurs dans ce cas.):
 (Prénom, âge) = ("Dominique", 59)
 print(Prénom)
 print(âge)
 (Prénom, âge) = ("Alexandre", 29)
 print(Prénom)
 print(âge)

<span style="color: #0000FF;"><big>'''Accès aux éléments :'''</big>

 mon_tuple = (1, 2, 3)
 print(mon_tuple[0]) # Affiche 1
 print(mon_tuple[1]) # Affiche 2
 print(mon_tuple[2]) # Affiche 3

<span style="color: #0000FF;"><big>'''Utilisation dans une fonction :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 def résultat():
     return 1, 2, 3
 a, b, c = résultat()
 print(a) # Affiche 1
 print(b) # Affiche 2
 print(c) # Affiche 3

<span style="color: #0000FF;"><big>'''Parcourir un tuple :'''</big>

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 mon_tuple = (1, 2, 3)
 for élément in mon_tuple:
     print(élément)

=17. Les dictionnaires :=

<span style="color: #196f3d;">''Les dictionnaires sont des objets qui en contiennent d'autres. Au lieu d'héberger des informations dans un ordre précis, ils associent chaque objet contenu à une clé (la plupart du temps, une chaîne de caractères).</span>

<span style="color: #0000FF;"><big>'''Créer un dictionnaire :'''</big>

Créer un dictionnaire vide :

 mon_dictionnaire = {}

 print(type(mon_dictionnaire))

 mon_dictionnaire = {"Maurice":"Atelier Linux", "Alain":"Atelier débutant Windows", "Patrice":"Atelier débutant"}

 print(mon_dictionnaire)

<span style="color: #0000FF;"><big>'''Ajout ou modification d'un élément si il existe déjà :'''</big>

 mon_dictionnaire["Denis"] = "Atelier domotique, etc."

<span style="color: #0000FF;"><big>'''Supprimer un élément :'''</big>

On peut récupérer l'élément supprimé dans une variable élément_supprimé = mon_dictionnaire.pop("Denis")

 mon_dictionnaire.pop("Denis")

Autre solution pour supprimer un élément :

 del mon_dictionnaire["Patrice"]

<span style="color: #0000FF;"><big>'''Tester si la clé "Maurice" existe :'''</big>

 if "Maurice" in mon_dictionnaire:
     print("Maurice est dans le dictionnaire")
 else:
     print("Maurice n'est pas dans le dictionnaire")

<span style="color: #0000FF;"><big>'''Parcourir un dictionnaire :'''</big>

 for clé in mon_dictionnaire.keys():
     print(clé)
 for valeur in mon_dictionnaire.values():
     print(valeur)
 for clé, valeur in mon_dictionnaire.items():
     print("Pour la clé : {} la valeur est : {}".format(clé, valeur))

<span style="color: #0000FF;"><big>'''Copier un dictionnaire :'''</big>

 mon_dictionnaire2 = mon_dictionnaire.copy()
 print(mon_dictionnaire2)

=18. Les fichiers :=

<span style="color: #0000FF;"><big>'''Les mode d'ouverture des fichiers :'''</big>

'''Modes de base'''

* '''r''' : Ouvre le fichier en mode lecture. Le fichier doit exister.
* '''w''' : Ouvre le fichier en mode écriture. Si le fichier existe déjà, il sera écrasé. Sinon, un nouveau fichier sera créé.
* '''a''' : Ouvre le fichier en mode ajout. Si le fichier n'existe pas, il sera créé. Les données seront ajoutées à la fin du fichier.

'''Modes binaires'''

* '''rb''' : Ouvre le fichier en mode lecture binaire.
* '''wb''' : Ouvre le fichier en mode écriture binaire. Si le fichier existe déjà, il sera écrasé.
* '''ab''' : Ouvre le fichier en mode ajout binaire. Si le fichier n'existe pas, il sera créé.

'''Modes combinés'''

* '''r+''' : Ouvre le fichier en mode lecture et écriture. Le fichier doit exister.
* '''w+''' : Ouvre le fichier en mode écriture et lecture. Si le fichier existe déjà, il sera écrasé.
* '''a+''' : Ouvre le fichier en mode ajout et lecture. Si le fichier n'existe pas il sera créé.

'''Modes combinés binaires'''

* '''rb+''' : Ouvre le fichier en mode lecture et écriture binaire.
* '''wb+''' : Ouvre le fichier en mode écriture et lecture binaire. Si le fichier existe déjà, il sera écrasé.
* '''ab+''' : Ouvre le fichier en mode ajout et lecture binaire. Si le fichier n'existe pas il sera créé.

<span style="color: #0000FF;"><big>'''Lire un fichier :'''</big>

Lire l'intégralité d'un fichier .txt dans une chaîne de caractère:

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 #Fichier texte en lecture
 #dossier/fichier.txt
 Fichier_MV = open("mv/animateurs.txt", "r") #Si le fichier n'existe pas FileNotFoundError
 lignes = Fichier_MV.read()
 print(lignes) #Lire et afficher tout le fichier
 print(type(lignes)) #Récupére des chaînes de caractères
 Fichier_MV.close() #Fermer le fichier
 if Fichier_MV.closed: #Tester si le fichier est fermé
     print("Fichier fermé")
 else:
     print("Fichier encore ouvert")

Autre solution, on récupère tout le fichier depuis le pointeur dans une liste :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 #Fichier texte en lecture
 #dossier/fichier.txt
 Fichier_MV = open("mv/animateurs.txt", "r") #Si le fichier n'existe pas FileNotFoundError
 lignes = Fichier_MV.readlines() #Tout le reste du fichier à partir du pointeur readlines avec un s
 print(lignes)
 print(type(lignes))#Récupére une liste
 Fichier_MV.close() #Fermer le fichier

Lire une ligne dans un fichier depuis le pointeur dans une chaîne de caractères :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 #Fichier texte en lecture
 #dossier/fichier.txt
 Fichier_MV = open("mv/animateurs.txt", "r") #Si le fichier n'existe pas FileNotFoundError
 ligne = Fichier_MV.readline() #Lire un ligne à partir du pointeur readline sans s
 print(ligne)
 print(type(ligne))#Récupére une chaîne de caractères 
 Fichier_MV.close() #Fermer le fichier

Lire tout le fichier avec with dans une chaîne de caractères :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 #Fichier texte en lecture
 #dossier/fichier.txt
 with open("mv/animateurs.txt","r") as Fichier_MV:
     lignes = Fichier_MV.read() #Lire tout le fichier
     print(lignes)
 print(type(lignes))#Récupére une chaîne de caractères 
 #Pas besoin de fermer le fichier
 if Fichier_MV.closed: #Tester si le fichier est fermé
     print("Fichier fermé")
 else:
     print("Fichier encore ouvert")

<span style="color: #0000FF;"><big>'''Écrire dans un fichier :'''</big>

Écrire dans un fichier avec with (chaîne de caractères) :

 !/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 #Fichier texte en lecture
 #dossier/fichier.txt
 with open("mv/animateurs.txt","w") as Fichier_MV:
     Fichier_MV.write(" Maurice\n")
     Fichier_MV.write(" Dominique\n")
     Fichier_MV.write(" Denis\n")
     Fichier_MV.write(" Alaine\n")
     Fichier_MV.write(" patrice\n")
     Fichier_MV.write(" Jonathan\n")
     Fichier_MV.write(" Alex\n")
 #Avec uft8 on peut utiliser les caractères accentués
 #Pas besoin de fermer le fichier
 if Fichier_MV.closed: #Tester si le fichier est fermé
     print("Fichier fermé")
 else:
     print("Fichier encore ouvert")

<span style="color: #0000FF;"><big>'''Pour les objets :'''</big>

Enregistrer l'instance d'un objet :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 import pickle
 class Animateur:
     def __init__(self, nom, atelier):
         self.nom = nom
         self.atelier = atelier
     def Afficher(self):
         print("{} : {} ".format(self.nom, self.atelier))
 animateur1 = Animateur("Maurice", "Linux")
 animateur1.Afficher()
 animateur2 = Animateur("Dominique", "Serveurs")
 animateur2.Afficher()
 with open("mv/ateliers.data", "wb") as fichier_ateliers:
     Enregistrement = pickle.Pickler(fichier_ateliers)
     Enregistrement.dump(animateur1)
     Enregistrement.dump(animateur2)

Récupérer l'instance d'un objet depuis un fichier :

 #!/usr/bin/env python3.10
 #-*- coding: utf-8 -*-
 import pickle
 class Animateur:
     def __init__(self, nom, atelier):
         self.nom = nom
         self.atelier = atelier
     def Afficher(self):
         print("{} : {} ".format(self.nom, self.atelier))
 with open("mv/ateliers.data", "rb") as fichier_ateliers:
     lire_enregistrement = pickle.Unpickler(fichier_ateliers)
     animateur1 = lire_enregistrement.load()
     animateur2 = lire_enregistrement.load()
 animateur1.Afficher()
 animateur2.Afficher()

----

=19. La programmation orientée objet (POO) :=

[[La programmation orientée objet (POO) avec le langage Python|La programmation orientée objet (POO) avec le langage Python]]