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 :

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

Pour rendre le script exécutable :

chmod +x fichier.py

Pour exécuter le script depuis le dossier où il se trouve :

./fichier.py

Commandes Shell Linux pour connaître ses versions de Python :

python2 --version

python3 --version

Éditeur de fichiers :

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

Mettre un programme en pause :

#!/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 \.

Afficher le contenu d'une variable :

variable = 'test'
print(variable)

age = '5'
print('Bonjour, j\'ai', age, 'ans.')

On peut utiliser les simple quote ' ou les double quote ".

Les chaînes de caractères formatées :

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 :

Les différents types de variables.

Types de Base :

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.

Types Composés :

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}

Types Spéciaux :

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

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

Connaître le type d'une variable :

type(variable)

Supprimer une variable :

del variable

Conversion entre Type de Variables :

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

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

Plus d'informations :

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 :

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 :

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 :

Les opérateurs logiques

Opérateurs	Légendes
and	Et logique
or	Ou logique
is	Affirmation
not	Négation
in	Appartient

10. Les boucles :

La boucle while - Tant qu'une condition est vraie :

#!/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 !')

La boucle for - On parcourt une chaîne de caractères :

#!/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)

Le mot-clé continue

#!/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

Le mot-clé break

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 :

La méthode import :

#!/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

La méthode from... import... :

#!/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 :

Les méthodes de la classe str :

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)

Méthode de parcours par while :

#!/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

Sélection de chaînes :

Les indices débutent par le 0.

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

Remplacer un caractère dans une chaîne :

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

Pour les instructions conditionnelles :

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.

Rechecher une chaîne de caractères :

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")

Transformer une chaîne de caractères en liste :

#!/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 :

Les listes sont des séquences, des objets capables de regrouper d’autres objets.

Créer une liste :

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.

Autres exemples de créations de listes.

#!/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) 

Effacer les éléments d'une liste :

ma_liste[:] = []

ou

ma_liste.clear()

Remplacer tous les éléments d'une liste par un élément.

#!/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)

Ajouter ou insérer un élément dans une liste :

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)

Ajouter une liste à une autre - Concaténation :

#!/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)

Supprimer des éléments d'une liste :

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)

Parcourir les listes :

Première méthode avec une boucle while.

#!/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

Cette méthode avec une boucle for est préférable à la première.

#!/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 :

Pour afficher l'indice et l'élément.

#!/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')

Autres exemples.

#!/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])

Rechercher un élément dans une liste :

#!/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")

Afficher l'indice d'un élément.

#!/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

Trier les éléments :

On peut trier des données du même type.

#!/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)

Compter un élément :

#!/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"))

Copier une liste :

On obtient une copie indépendante de la liste originale.

#!/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

Transformer une liste en chaîne de caractères :

#!/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 :

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.

Création de tuples :

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)

Accès aux éléments :

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

Utilisation dans une fonction :

#!/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

Parcourir un tuple :

#!/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 :

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).

Créer un dictionnaire :

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)

Ajout ou modification d'un élément si il existe déjà :

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

Supprimer un élément :

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"]

Tester si la clé "Maurice" existe :

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

Parcourir un dictionnaire :

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))

Copier un dictionnaire :

mon_dictionnaire2 = mon_dictionnaire.copy()
print(mon_dictionnaire2)

18. Les fichiers :

Les mode d'ouverture des fichiers :

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éé.

Lire un fichier :

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")

Écrire dans un fichier :

É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")

Pour les objets :

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