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/
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 :
+ Addition
- 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 :
== Égalité
< Inférieur
> Supérieur
<= Inférieur ou égal
>= supérieur ou égal
!= Différent
9. Les opérateurs logiques :
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 :
Lire l'intégralité d'un fichier .txt :
#!/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 :
- !/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) print(type(lignes))#Récupére des chaînes de caractères Fichier_MV.close() #Fermer le fichier
19. La programmation orientée objet (POO) :
La programmation orientée objet (POO) avec le langage Python