Aide-mémoire Python 3

Types, Variables, Valeurs et Opérateurs

Déclaration de variables et types de base

1 # Déclaration de variables
2 a = 42 # entier
3 b = 3.14 # flottant
4 c = "Bonjour" # chaı̂ne de caractères
5 d = True # booléen
6

7 print(type(a)) # <class 'int'>

8 print(type(b)) # <class 'float'>
9 print(type(c)) # <class 'str'>
10 print(type(d)) # <class 'bool'>

Opérations arithmétiques

1 # Opérations de base
2 x = 10
3 y = 3
4

5 print(x + y) # Addition: 13
6 print(x - y) # Soustraction: 7
7 print(x * y) # Multiplication: 30
8 print(x / y) # Division: 3.333...
9 print(x // y) # Division entière: 3
10 print(x % y) # Modulo: 1
11 print(x ** y) # Puissance: 1000

1
 Opérateurs de comparaison

1 # Comparaison
2 a = 5
3 b = 10
4

5 print(a < b) # True

6 print(a > b) # False
7 print(a == b) # False
8 print(a != b) # True
9 print(a <= b) # True
10 print(a >= b) # False

Opérateurs logiques

1 # Logique booléenne
2 x = True
3 y = False
4

5 print(x and y) # False

6 print(x or y) # True
7 print(not x) # False

Conversion de types

1 # Conversion de types
2 a = "42"
3 b = int(a) # Conversion en entier
4 c = float(a) # Conversion en flottant
5 d = str(b) # Conversion en chaı̂ne
6

7 print(b) # 42
8 print(c) # 42.0
9 print(d) # "42"

2
 Fonctions : Définition, Appel et Flot d’Exécution

1 # Définition d'une fonction simple

2 def saluer(nom):
3 """Affiche un message de salutation."""
4 print(f"Bonjour, {nom}!")
5

6 # Appel de la fonction
7 saluer("Alice") # Bonjour, Alice!
8

9 # Fonction avec retour de valeur

10 def addition(a, b):
11 """Retourne la somme de deux nombres."""
12 return a + b
13

14 resultat = addition(10, 5)
15 print(resultat) # 15

Flot d’exécution entre plusieurs fonctions

1 # Exemple pour suivre le flot d'exécution entre différentes fonctions

2

3 def fonction_principale():
4 """Fonction principale appelée en premier."""
5 print("Début de fonction_principale")
6 fonction_secondaire() # Appel de fonction_secondaire
7 print("Retour dans fonction_principale après fonction_secondaire")
8 fonction_finale() # Appel de fonction_finale
9 print("Fin de fonction_principale")
10

11 def fonction_secondaire():
12 """Fonction appelée par fonction_principale."""
13 print("Début de fonction_secondaire")
14 fonction_intermediaire() # Appel de fonction_intermediaire
15 print("Retour dans fonction_secondaire après fonction_intermediaire")
16

17 def fonction_intermediaire():
18 """Fonction appelée par fonction_secondaire."""
19 print("Exécution de fonction_intermediaire")
20

3
21 def fonction_finale():
22 """Dernière fonction appelée par fonction_principale."""
23 print("Exécution de fonction_finale")
24

25 # Suivi du flot d'exécution

26 fonction_principale()
27

28 # Résultat attendu :
29 # Début de fonction_principale
30 # Début de fonction_secondaire
31 # Exécution de fonction_intermediaire
32 # Retour dans fonction_secondaire après fonction_intermediaire
33 # Retour dans fonction_principale après fonction_secondaire
34 # Exécution de fonction_finale
35 # Fin de fonction_principale

Instructions conditionnelles

1 # Exemples d'instructions conditionnelles

2

3 x = 10
4

5 # Condition simple
6 if x > 0:
7 print("x est positif") # x est positif
8

9 # Condition avec else

10 if x < 0:
11 print("x est négatif")
12 else:
13 print("x n'est pas négatif") # x n'est pas négatif
14

15 # Condition avec elif

16 if x < 0:
17 print("x est négatif")
18 elif x == 0:
19 print("x est nul")
20 else:
21 print("x est positif") # x est positif

4
 Expressions booléennes et opérateurs logiques

1 # Exemples d'expressions booléennes et opérateurs logiques

2

3 a = True
4 b = False
5

6 # Opérateur AND
7 print(a and b) # False
8

9 # Opérateur OR
10 print(a or b) # True
11

12 # Opérateur NOT
13 print(not a) # False
14

15 # Combinaison logique
16 x = 10
17 y = 5
18 print((x > 0) and (y < 10)) # True
19 print((x < 0) or (y == 5)) # True

Instructions imbriquées

1 # Exemples d'instructions imbriquées

2

3 age = 20
4 revenu = 50000
5

6 if age >= 18: # Première condition

7 if revenu > 40000: # Condition imbriquée
8 print("Adulte avec revenu élevé") # Adulte avec revenu élevé
9 else:
10 print("Adulte avec revenu faible")
11 else:
12 print("Mineur")
13

14 # Instruction imbriquée avec elif

15 if age < 18:
16 print("Mineur")

5
17 elif age >= 18 and revenu > 40000:
18 print("Adulte avec revenu élevé") # Adulte avec revenu élevé
19 else:
20 print("Adulte avec revenu faible")

Flot d’exécution pour instructions imbriquées

1 # Suivi du flot d'exécution d'instructions imbriquées

2

3 x = 5
4 y = 10
5

6 if x < 10: # Première condition

7 print("x est inférieur à 10") # x est inférieur à 10
8 if y > x: # Condition imbriquée
9 print("y est supérieur à x") # y est supérieur à x
10 else:
11 print("x est 10 ou plus")
12

13 # Résultat :
14 # x est inférieur à 10
15 # y est supérieur à x

Entrées clavier et conversion de types

1 # Exemple de base pour une entrée clavier

2 nom = input("Quel est votre nom ? ")
3 print(f"Bonjour, {nom}!") # Affiche le nom saisi
4

5 # Entrée et conversion en entier

6 age = input("Quel est votre âge ? ")
7 age = int(age) # Conversion de la chaı̂ne en entier
8 print(f"Vous avez {age} ans.")
9

10 # Entrée et conversion en flottant

11 note = input("Entrez une note sur 20 : ")
12 note = float(note) # Conversion de la chaı̂ne en flottant
13 print(f"Votre note est {note}/20.")

6
 Gestion des erreurs lors des conversions

1 # Gestion des erreurs avec try-except

2 try:
3 temperature = input("Entrez la température actuelle (en °C) : ")
4 temperature = float(temperature) # Tentative de conversion en flottant
5 print(f"La température est {temperature} °C.")
6 except ValueError:
7 print("Erreur : vous devez entrer un nombre.")

Flot d’exécution avec plusieurs entrées clavier

1 # Exemple avec plusieurs entrées et conversions

2 try:
3 # Entrée pour le prénom
4 prenom = input("Entrez votre prénom : ")
5

6 # Entrée pour l'âge avec conversion

7 age = int(input("Entrez votre âge : "))
8

9 # Entrée pour le poids avec conversion

10 poids = float(input("Entrez votre poids (en kg) : "))
11

12 # Affichage des résultats

13 print(f"Bonjour {prenom}, vous avez {age} ans et vous pesez {poids} kg.
14

15 except ValueError:
16 print("Erreur : Veuillez entrer des données valides.")

Boucles : while et for

Boucle while

1 # Exemple d'utilisation de while

2 i = 0
3 while i < 5: # La condition est évaluée à chaque itération
4 print(f"i vaut {i}")
5 i += 1 # Incrémentation
6

7
 7 # Résultat :
8 # i vaut 0
9 # i vaut 1
10 # i vaut 2
11 # i vaut 3
12 # i vaut 4

Boucle for

1 # Exemple d'utilisation de for avec une séquence

2 for nombre in range(5): # Parcours de 0 à 4
3 print(f"nombre vaut {nombre}")
4

5 # Résultat :
6 # nombre vaut 0
7 # nombre vaut 1
8 # nombre vaut 2
9 # nombre vaut 3
10 # nombre vaut 4
11

12 # Parcours d'une liste

13 noms = ["Alice", "Bob", "Charlie"]
14 for nom in noms:
15 print(f"Bonjour, {nom}!")
16

17 # Résultat :
18 # Bonjour, Alice!
19 # Bonjour, Bob!
20 # Bonjour, Charlie!

Boucle imbriquée

1 # Exemple de boucles imbriquées

2 for i in range(3): # Première boucle
3 for j in range(2): # Deuxième boucle
4 print(f"i = {i}, j = {j}")
5

6 # Résultat :
7 # i = 0, j = 0

8
 8 # i = 0, j = 1
9 # i = 1, j = 0
10 # i = 1, j = 1
11 # i = 2, j = 0
12 # i = 2, j = 1

Quand utiliser while ou for ?

• Utiliser une boucle while :

– Lorsque le nombre d’itérations n’est pas connu à l’avance.

– Exemple : attendre une condition spécifique, comme une entrée
utilisateur.

• Utiliser une boucle for :

– Lorsque vous parcourez une séquence (liste, chaı̂ne, plage de nom-

bres).
– Exemple : parcourir une liste d’éléments ou effectuer un nombre
fixe d’itérations.

Exemple pratique avec while

1 # Exemple : attente d'une entrée valide

2 mot_de_passe = ""
3 while mot_de_passe != "python123":
4 mot_de_passe = input("Entrez le mot de passe : ")
5 if mot_de_passe != "python123":
6 print("Mot de passe incorrect. Réessayez.")
7 print("Accès autorisé.")

Exemple pratique avec for

1 # Exemple : calcul de la somme des nombres dans une liste

2 nombres = [1, 2, 3, 4, 5]
3 somme = 0
4 for nombre in nombres:
5 somme += nombre
6 print(f"La somme des nombres est {somme}")

9
 7

8 # Résultat :
9 # La somme des nombres est 15

Chaı̂nes de caractères et leurs spécificités

Définition et manipulation de chaı̂nes

1 # Définition d'une chaı̂ne

2 texte = "Bonjour, Python!"
3

4 # Affichage d'une chaı̂ne

5 print(texte) # Bonjour, Python!
6

7 # Accéder à un caractère spécifique (indexation)

8 print(texte[0]) # B
9 print(texte[-1]) # !
10

11 # Slicing : extraction d'une sous-chaı̂ne

12 print(texte[0:7]) # Bonjour
13 print(texte[8:]) # Python!

Méthodes utiles pour les chaı̂nes

1 # Méthodes pour manipuler les chaı̂nes

2

3 # Conversion en majuscules ou minuscules

4 texte = "bonjour"
5 print(texte.upper()) # BONJOUR
6 print(texte.lower()) # bonjour
7

8 # Vérification du début ou de la fin de la chaı̂ne

9 print(texte.startswith("b")) # True
10 print(texte.endswith("r")) # False
11

12 # Remplacement d'une sous-chaı̂ne

13 texte = "J'aime le Python"
14 texte_modifie = texte.replace("Python", "programmation")
15 print(texte_modifie) # J'aime le programmation

10
16

17 # Suppression des espaces (ou autres caractères) au début et à la fin

18 chaine = " Bonjour "
19 print(chaine.strip()) # Bonjour
20

21 # Trouver la position d'un caractère ou d'une sous-chaı̂ne

22 index = texte.find("le")
23 print(index) # 6
24

25 # Comptage du nombre d'occurrences d'un caractère

26 print(texte.count("e")) # 2

Concatenation et répétition de chaı̂nes

1 # Concatenation (concaténation) de chaı̂nes

2 salutation = "Bonjour"
3 nom = "Alice"
4 message = salutation + " " + nom
5 print(message) # Bonjour Alice
6

7 # Répétition d'une chaı̂ne

8 exclamation = "Wow! "
9 print(exclamation * 3) # Wow! Wow! Wow!

Formatage des chaı̂nes

1 # Utilisation de f-strings (formatage moderne)

2 nom = "Alice"
3 age = 25
4 print(f"Nom: {nom}, Âge: {age}") # Nom: Alice, Âge: 25
5

6 # Formatage classique avec % (méthode plus ancienne)

7 print("Nom: %s, Âge: %d" % (nom, age)) # Nom: Alice, Âge: 25
8

9 # Méthode format()
10 print("Nom: {}, Âge: {}".format(nom, age)) # Nom: Alice, Âge: 25

11
 Chaı̂nes multilignes et échappement de caractères

1 # Chaı̂nes multilignes avec triple guillemets

2 chaine_multiligne = """Bonjour,
3 comment ça va ?
4 Merci de votre retour."""
5 print(chaine_multiligne)
6 # Résultat :
7 # Bonjour,
8 # comment ça va ?
9 # Merci de votre retour.
10

11 # Échappement de caractères spéciaux avec \

12 texte = "C'est un \"exemple\" d'échappement."
13 print(texte) # C'est un "exemple" d'échappement.

Rappel : Spécificités des chaı̂nes en Python

• Les chaı̂nes sont immuables : Une fois créées, elles ne peuvent
pas être modifiées. Les méthodes comme ‘replace()‘ retournent une
nouvelle chaı̂ne modifiée.

• Les chaı̂nes peuvent contenir des caractères spéciaux : Comme

les retours à la ligne “, les tabulations ‘‘, et les guillemets échappés avec
‘¨‘ ou ‘´‘.

• La concaténation et la répétition : Vous pouvez concaténer des

chaı̂nes avec ‘+‘ et les répéter avec ‘*‘.

Listes en Python
Création et Accès aux Éléments

1 # Création d'une liste

2 fruits = ["pomme", "banane", "cerise"]
3

4 # Accès aux éléments par index

5 print(fruits[0]) # pomme
6 print(fruits[1]) # banane
7 print(fruits[-1]) # cerise
8

12
 9 # Modification d'un élément de la liste
10 fruits[1] = "orange"
11 print(fruits) # ['pomme', 'orange', 'cerise']

Slicing (Tranchage)

1 # Slicing : Extraction d'une sous-liste

2 print(fruits[0:2]) # ['pomme', 'orange']
3 print(fruits[1:]) # ['orange', 'cerise']
4 print(fruits[:2]) # ['pomme', 'orange']
5 print(fruits[-2:]) # ['orange', 'cerise']
6

7 # Slicing avec un pas (step)

8 print(fruits[::2]) # ['pomme', 'cerise']

Boucle For sur les Listes

1 # Boucle for pour parcourir une liste

2 for fruit in fruits:
3 print(fruit)
4 # Résultat :
5 # pomme
6 # orange
7 # cerise
8

9 # Boucle avec index (en utilisant enumerate)

10 for index, fruit in enumerate(fruits):
11 print(f"Index {index}: {fruit}")
12 # Résultat :
13 # Index 0: pomme
14 # Index 1: orange
15 # Index 2: cerise

Opérateurs et Fonctions Globales sur les Listes

1 # Vérifier la longueur d'une liste

2 print(len(fruits)) # 3

13
 3

4 # Vérifier si un élément existe dans la liste

5 print("pomme" in fruits) # True
6 print("kiwi" in fruits) # False
7

8 # Fusionner des listes (opérateur +)

9 autres_fruits = ["kiwi", "mangue"]
10 fusion = fruits + autres_fruits
11 print(fusion) # ['pomme', 'orange', 'cerise', 'kiwi', 'mangue']
12

13 # Répéter une liste (opérateur *)

14 repetition = fruits * 2
15 print(repetition) # ['pomme', 'orange', 'cerise', 'pomme', 'orange', 'ceri

Méthodes Essentielles des Listes

1 # Ajouter un élément à la fin de la liste

2 fruits.append("melon")
3 print(fruits) # ['pomme', 'orange', 'cerise', 'melon']
4

5 # Insérer un élément à une position spécifique

6 fruits.insert(1, "raisin")
7 print(fruits) # ['pomme', 'raisin', 'orange', 'cerise', 'melon']
8

9 # Supprimer un élément par valeur

10 fruits.remove("orange")
11 print(fruits) # ['pomme', 'raisin', 'cerise', 'melon']
12

13 # Supprimer un élément par index

14 del fruits[2]
15 print(fruits) # ['pomme', 'raisin', 'melon']
16

17 # Trier la liste
18 fruits.sort()
19 print(fruits) # ['melon', 'pomme', 'raisin']
20

21 # Inverser la liste
22 fruits.reverse()
23 print(fruits) # ['raisin', 'pomme', 'melon']
24

25 # Obtenir une copie de la liste

14
26 fruits_copy = fruits.copy()
27 print(fruits_copy) # ['raisin', 'pomme', 'melon']
28

29 # Ajouter plusieurs éléments à la fin de la liste (extend)

30 fruits.extend(["kiwi", "mangue"])
31 print(fruits) # ['raisin', 'pomme', 'melon', 'kiwi', 'mangue']
32

33 # Retirer et retourner un élément par index (pop)

34 element = fruits.pop(1) # Retire l'élément à l'index 1 (ici 'pomme')
35 print(element) # pomme
36 print(fruits) # ['raisin', 'melon', 'kiwi', 'mangue']
37

38 # Trouver l'index d'un élément

39 index = fruits.index("kiwi")
40 print(index) # 2
41

42 # Effacer tous les éléments de la liste

43 fruits.clear()
44 print(fruits) # []

Différences entre Listes et Chaı̂nes de Caractères

• Les listes sont des collections mutables, ce qui signifie que vous pouvez
modifier leurs éléments après leur création.

• Les chaı̂nes de caractères sont immuables : une fois créées, vous ne

pouvez pas modifier directement leurs caractères.

• Les listes peuvent contenir des éléments de types différents, tandis que
les chaı̂nes de caractères contiennent uniquement des caractères.

• Les listes supportent l’indexation et le slicing, tout comme les chaı̂nes

de caractères, mais elles offrent des méthodes supplémentaires pour
ajouter, supprimer ou modifier des éléments.

Opérations Fréquentes sur les Listes

1 # Ajouter des éléments

2 fruits.append("kiwi") # Ajoute à la fin
3 fruits.insert(2, "ananas") # Insère à un index spécifique
4 print(fruits) # ['raisin', 'pomme', 'ananas', 'melon', 'kiwi']

15
 5

6 # Supprimer des éléments

7 fruits.remove("melon") # Supprime la première occurrence
8 del fruits[1] # Supprime l'élément à l'index 1
9 print(fruits) # ['raisin', 'ananas', 'kiwi']

Méthodes Supplémentaires pour les Listes

• **‘extend()‘** : Permet d’ajouter plusieurs éléments à la fin de la liste.

• **‘pop()‘** : Permet de retirer et de retourner un élément à un index

spécifique. Si aucun index n’est spécifié, il retire et retourne le dernier
élément.

• **‘index()‘** : Retourne l’index du premier élément trouvé dans la

liste qui correspond à la valeur donnée.

• **‘clear()‘** : Vide la liste de tous ses éléments.

• **‘count()‘** : Compte le nombre d’occurrences d’un élément donné

dans la liste.

• **‘reverse()‘** : Inverse l’ordre des éléments dans la liste.

• **‘sort()‘** : Trie la liste en place (par défaut dans l’ordre croissant).

Matrices en Python
Matrices avec Listes de Listes

1 # Création d'une matrice 2x3 (liste de listes)

2 matrice = [
3 [1, 2, 3],
4 [4, 5, 6]
5 ]
6

7 # Accéder à un élément spécifique de la matrice

8 print(matrice[0][1]) # 2 (première ligne, deuxième colonne)
9

10 # Modifier un élément de la matrice

11 matrice[1][2] = 10
12 print(matrice) # [[1, 2, 3], [4, 5, 10]]

16
13

14 # Transposer la matrice (échange des lignes et des colonnes)

15 matrice_transposee = [
16 [matrice[j][i] for j in range(len(matrice))]
17 for i in range(len(matrice[0]))
18 ]
19 print(matrice_transposee) # [[1, 4], [2, 5], [3, 10]]

Opérations sur les Matrices avec Listes de Listes

1 # Addition de matrices
2 matrice1 = [[1, 2], [3, 4]]
3 matrice2 = [[5, 6], [7, 8]]
4

5 # Addition des matrices (élément par élément)

6 addition = [
7 [matrice1[i][j] + matrice2[i][j] for j in range(len(matrice1[0]))]
8 for i in range(len(matrice1))
9 ]
10 print(addition) # [[6, 8], [10, 12]]
11

12 # Multiplication de matrices (produit scalaire)

13 produit = [
14 [sum(a * b for a, b in zip(matrice1_row, matrice2_col))
15 for matrice2_col in zip(*matrice2)]
16 for matrice1_row in matrice1
17 ]
18 print(produit) # [[19, 22], [43, 50]]

Matrices avec NumPy

1 import numpy as np
2

3 # Création d'une matrice 2x3 avec NumPy

4 matrice_np = np.array([[1, 2, 3], [4, 5, 6]])
5

6 # Affichage de la matrice
7 print(matrice_np) # [[1 2 3] [4 5 6]]
8

17
 9 # Transposer la matrice
10 matrice_transposee_np = matrice_np.T
11 print(matrice_transposee_np) # [[1 4] [2 5] [3 6]]
12

13 # Addition de matrices avec NumPy

14 matrice1_np = np.array([[1, 2], [3, 4]])
15 matrice2_np = np.array([[5, 6], [7, 8]])
16 addition_np = matrice1_np + matrice2_np
17 print(addition_np) # [[ 6 8] [10 12]]
18

19 # Multiplication de matrices avec NumPy

20 produit_np = np.dot(matrice1_np, matrice2_np)
21 print(produit_np) # [[19 22] [43 50]]

Explications et Détails
• **Matrices avec Listes de Listes** :

– Une matrice peut être représentée comme une liste de listes, chaque
sous-liste représentant une ligne de la matrice.
– Pour accéder à un élément, utilisez deux indices : un pour la ligne
et un pour la colonne, par exemple matrice[0][1] pour obtenir
l’élément de la première ligne et de la deuxième colonne.
– La **transposition** consiste à échanger les lignes et les colonnes
de la matrice. En Python, cela peut être fait avec une double
boucle.

• **Matrices avec NumPy** :

– NumPy est une bibliothèque qui rend le travail avec des matrices
plus simple et plus rapide. Vous pouvez créer des matrices avec
np.array().
– **Addition** : Utilisez l’opérateur + pour additionner deux ma-
trices élément par élément.
– **Multiplication** : La multiplication de matrices se fait avec la
fonction np.dot(). Cette fonction effectue le produit matriciel.
– **Transposition** : La transposition d’une matrice NumPy est
obtenue avec .T.

• **Opérations Matricielles** :

18
 – Pour l’**addition**, les matrices doivent avoir les mêmes dimen-
sions.
– Pour la **multiplication**, le nombre de colonnes de la première
matrice doit être égal au nombre de lignes de la deuxième matrice.
– La **transposition** inverse les lignes et les colonnes d’une ma-
trice.

Manipulation de Fichiers en Python

Ouverture d’un Fichier

1 # Ouverture d'un fichier en mode lecture ('r')

2 # Ce mode permet de lire un fichier, mais ne permet pas d'écrire dedans.
3 fichier = open("exemple.txt", "r")
4 print(fichier.read()) # Affiche tout le contenu du fichier
5 fichier.close() # N'oubliez pas de fermer le fichier après l'avoir utilisé
6

7 # Ouverture d'un fichier en mode écriture ('w')

8 # Si le fichier n'existe pas, il sera créé. Si le fichier existe, son conte
9 fichier = open("exemple.txt", "w")
10 fichier.write("Bonjour, ceci est un test.\n") # Écrit dans le fichier
11 fichier.close()
12

13 # Ouverture d'un fichier en mode ajout ('a')

14 # Ce mode permet d'ajouter du texte à la fin du fichier sans effacer son co
15 fichier = open("exemple.txt", "a")
16 fichier.write("Ceci est ajouté à la fin du fichier.\n")
17 fichier.close()
18

19 # Ouverture d'un fichier en mode lecture binaire ('rb')

20 # Ce mode est utilisé pour lire un fichier binaire (comme une image).
21 fichier = open("exemple_image.png", "rb")
22 print(fichier.read()) # Affiche les données binaires du fichier
23 fichier.close()

Lecture et Écriture de Fichiers

1 # Lecture ligne par ligne d'un fichier

2 fichier = open("exemple.txt", "r")

19
 3 for ligne in fichier:
4 print(ligne.strip()) # Affiche chaque ligne sans les sauts de ligne
5 fichier.close()
6

7 # Lecture d'un fichier en une seule fois avec read()

8 fichier = open("exemple.txt", "r")
9 contenu = fichier.read()
10 print(contenu) # Affiche tout le contenu du fichier en une seule fois
11 fichier.close()
12

13 # Écriture multiple dans un fichier (en mode 'w' ou 'a')

14 fichier = open("exemple.txt", "w")
15 lignes = ["Première ligne.\n", "Deuxième ligne.\n", "Troisième ligne.\n"]
16 fichier.writelines(lignes) # Écrit plusieurs lignes dans le fichier
17 fichier.close()
18

19 # Lecture et écriture dans le même fichier (mode 'r+' ou 'w+')

20 fichier = open("exemple.txt", "r+")
21 contenu = fichier.read() # Lit le contenu existant
22 print(contenu)
23 fichier.seek(0) # Repositionne le curseur au début du fichier
24 fichier.write("Modification du contenu.") # Écrit dans le fichier
25 fichier.close()

Utilisation de ‘with‘ pour gérer les fichiers

1 # Utilisation de 'with' pour gérer automatiquement la fermeture du fichier

2 # Pas besoin d'appeler explicitement 'fichier.close()'
3

4 # Lecture d'un fichier avec 'with'

5 with open("exemple.txt", "r") as fichier:
6 contenu = fichier.read()
7 print(contenu)
8

9 # Écriture dans un fichier avec 'with'

10 with open("exemple.txt", "w") as fichier:
11 fichier.write("Ceci est un test avec 'with'.\n")
12

13 # Ajout à un fichier avec 'with'

14 with open("exemple.txt", "a") as fichier:
15 fichier.write("Ajout avec 'with'.\n")

20