Site intéressant :
https://www.w3schools.com/python/
Sommaire :
• Contenaires :
– tuple
– set
– dictionnaire
• Tableaux
• Matrices
• Fichiers
Contenaires :
• Entité en Python qui contient une collection d'autres objets.
• Déjà vus :
– Chaine de caractères
– Liste
– range
• à Voir :
– tuple
– set
– Dictionnaire,
Contenaires : Propriétés
test d'appartenance
L = [20, 10, 30]
print(10 in L)
print(11 in L)
print(31 not in L)
True
False
True
ch = "ABCD"
print('A' in ch)
print("C" in ch)
print('AB' in ch)
print('E' in ch)
print('T' not in ch)
True
True
True
False
True
r = range(10,20)
print(10 in r)
print('10' in r)
print(20 in r)
print(21 not in r)
True
False
False
True
Cardinal (longueur)
print("longuer L :",len(L))
longuer L : 3
print("longuer ch :",len(ch))
longuer ch : 4
print("longuer r :",len(r))
longuer r : 10
Tuples : (Fr : n-uplets)
mytuple = ("Apple", "orange", "Kiwi")
print(mytuple)
print(type(mytuple))
('Apple', 'orange', 'Kiwi')
<class 'tuple'>
# longueur d'un Tuple
print(len(mytuple))
print(mytuple[0])
print(mytuple[-1])
Apple
Kiwi
• Autoriser les doublons
– Les tuples étant indexés, ils peuvent comporter des éléments ayant la même
valeur :
thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple, "de longueur :", len(thistuple))
('apple', 'banana', 'cherry', 'apple', 'cherry') de longueur : 5
- Les tuples ne sont pas modifiables.
my_tuple = ("Apple", "orange", "Kiwi")
print(my_tuple)
my_tuple[0] = "Pomme"
print(my_tuple)
('Apple', 'orange', 'Kiwi')
----------------------------------------------------------------------
-----
TypeError Traceback (most recent call
last)
Cell In[13], line 4
1 my_tuple = ("Apple", "orange", "Kiwi")
2 print(my_tuple)
----> 4 my_tuple[0] = "Pomme"
5 print(my_tuple)
TypeError: 'tuple' object does not support item assignment
Mytuple = ("Apple", "orange", "Kiwi")
Mytuple.append("Melon")
----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[14], line 2
1 Mytuple = ("Apple", "orange", "Kiwi")
----> 2 Mytuple.append("Melon")
AttributeError: 'tuple' object has no attribute 'append'
Une Astuce :
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x, " - ", type(x))
('apple', 'kiwi', 'cherry') - <class 'tuple'>
Mytuple = ("Apple", "orange", "Kiwi")
print(Mytuple, " de type :",type(Mytuple))
L = list(Mytuple)
L.append("Melon")
Mytuple = tuple(L)
print(Mytuple, "de type :",type(Mytuple))
('Apple', 'orange', 'Kiwi') de type : <class 'tuple'>
('Apple', 'orange', 'Kiwi', 'Melon') de type : <class 'tuple'>
Attention : Conversion Implicite
Mytuple = ("Apple", "orange", "Kiwi")
print(Mytuple, "de type :", type(Mytuple))
print("")
tupleTrie = sorted(Mytuple)
print(tupleTrie, "de typeT :", type(tupleTrie))
print("")
print(Mytuple, "de type :", type(Mytuple))
print("")
tupleTrie.append("Melon")
print(tupleTrie, "de type :", type(tupleTrie))
('Apple', 'orange', 'Kiwi') de type : <class 'tuple'>
['Apple', 'Kiwi', 'orange'] de typeT : <class 'list'>
('Apple', 'orange', 'Kiwi') de type : <class 'tuple'>
['Apple', 'Kiwi', 'orange', 'Melon'] de type : <class 'list'>
Attention ! - Tuple avec un seul élément - Ne pas oublier la virgule
thistuple = ("apple",) # Ne pas oublier la virgule
print(type(thistuple))
#NOT a tuple
thistuple = ("apple")
print(type(thistuple))
# A tuple
Thistuple = tuple("apple")
print(type(Thistuple))
<class 'tuple'>
<class 'str'>
<class 'tuple'>
• Les éléments de tuple peuvent être de n’importe quel type de données :
tuple1 = ("apple", "orange", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)
print(tuple1)
print(tuple2)
print(tuple3)
('apple', 'orange', 'cherry')
(1, 5, 7, 9, 3)
(True, False, False)
• Un tuple peut contenir différents types de données :
TupleAnim = ("abc", 27, True, 70, "male")
print(TupleAnim)
('abc', 27, True, 70, 'male')
• Il est aussi possible d'utiliser la fonction constructeur tuple() pour créer un tuple.
thistuple = tuple(("Apple", "Orange", "cherry")) # notez les doubles
parenthèses
# thistuple = tuple("Apple", "Orange", "cherry") # notez les doubles
parenthèses
print(thistuple)
('Apple', 'Orange', 'cherry')
Copier un Tuple
mytuple = ("Apple", "orangE", "Kiwi")
othTuple = mytuple
print(mytuple, "id My: ",id(mytuple))
print(othTuple, "id Oth:",id(othTuple))
('Apple', 'orangE', 'Kiwi') id My: 1422440562368
('Apple', 'orangE', 'Kiwi') id Oth: 1422440562368
# cpTuple = mytuple.copy()
# CopTuple = tuple(list(mytuple))
LT = list(mytuple)
CopTuple = tuple(LT)
print(mytuple, "id My: ",id(mytuple))
print(othTuple, "id Cop:",id(CopTuple))
('Apple', 'orangE', 'Kiwi') id My: 1422440562368
('Apple', 'orangE', 'Kiwi') id Cop: 1422439547968
UT = ("TestT",)
DT = tuple("TestT")
# DT = tuple(("TestT"),)
print(UT, type(UT), "lg :",len(UT))
print(DT, type(DT), "lg :",len(DT))
('TestT',) <class 'tuple'> lg : 1
('T', 'e', 's', 't', 'T') <class 'tuple'> lg : 5
Parcours d'un Tuple
thistuple = ("apple", "orange", "cherry")
for x in thistuple:
print(x)
apple
orange
cherry
Sets :
• Un set est une collection de donnée qui ne permet pas de duplication.
thisSet = {"apple", "banana", "cherry", "apple"}
print(thisSet, "de longueur :", len(thisSet))
{'cherry', 'apple', 'banana'} de longueur : 3
• Remarque :
– True et 1 sont considérés comme identiques
– False et 0 sont considérés comme identiques
UnSet = {"apple", False, "banana", "cherry", True, 0, 1, 2}
print(UnSet, "de longueur :", len(UnSet) )
{False, 'cherry', 'apple', 2, True, 'banana'} de longueur : 6
Ls = ["apple", False, "banana", "cherry", True, 0, 1, 2]
print(Ls)
SetConv = set(Ls)
print(SetConv)
# Constructeur
IniSet = set(("appLe", "banNana", "cherry")) # noter la double
parenthèse
print(IniSet)
['apple', False, 'banana', 'cherry', True, 0, 1, 2]
{False, 'cherry', 'apple', True, 2, 'banana'}
{'appLe', 'cherry', 'banNana'}
- Un set est une collection non indexée
myset = {"apple", "OranGe", "cherry" , "Fruit"}
print(myset[O])
# myL = ["apple", "OranGe", "cherry"]
# print(myL, "Type : ",type(myL))
----------------------------------------------------------------------
-----
NameError Traceback (most recent call
last)
Cell In[29], line 3
1 myset = {"apple", "OranGe", "cherry" , "Fruit"}
----> 3 print(myset[O])
NameError: name 'O' is not defined
- Les ensembles (set) ne sont pas ordonnés, l'ordre d'apparition des
éléments est imprévisible
myset = {"apple", "OranGe", "cherry" , "Fruit"}
print(myset, "Type : ",type(myset))
{'cherry', 'apple', 'Fruit', 'OranGe'} Type : <class 'set'>
Cependant, on peut supprimer des éléments et en ajouter de nouveaux.
- Ajouter un élément à un Ensemble Set
thisset = {"apple", "banana", "cherry"}
print("id av set : ", id(thisset))
thisset.add("orange")
print(thisset)
print("id ap set : ", id(thisset))
id av set : 1422453575680
{'cherry', 'apple', 'banana', 'orange'}
id ap set : 1422453575680
- Supprimer un élément d'un Ensemble Set
thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)
{'cherry', 'apple'}
Parcourir les éléments d'un Set :
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)
cherry
apple
banana
UNset = {"apple"}
print(UNset, type(UNset))
{'apple'} <class 'set'>
Dictionnaires :
• Entité de correspondance (mapping),
• Non séquentiels (comme les listes ou chaînes de caractères),
• Permet d’associer une valeur (simple, ou composée) à une clé: (clé , val)
– Appelés tableaux associatifs
– Analogie avec un dictionnaire linguistique : accéder à une définition / mot
Créer un dictionnaire python :
a = {}
print(type(a))
<class 'dict'>
b = dict()
print(type(b))
<class 'dict'>
Opérations sur dictionnaires (Exemples):
• Aj / Supp / Rempl / vérifier existence (clé , val)
• Trouver une Val / clé
Ajouter des valeurs dans un dictionnaire python :
• indiquer une clé ainsi qu'une valeur:
a = dict()
a["nom"] = "Benahmed"
a["prenom"] = "Amine"
print(a)
{'nom': 'Benahmed', 'prenom': 'Amine'}
# autrement
b = {}
b = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille":
1.73}
print(b)
{'nom': 'BenAhmed', 'prenom': 'Nabil', 'poids': 70, 'taille': 1.73}
Doublons non autorisés !
• Les dictionnaires ne peuvent pas avoir deux éléments avec la même clé :
MyDict = {
"brand": "Hyundai",
"model": "Accent",
"model": "Elantra",
"year": 2024
}
print(MyDict)
{'brand': 'Hyundai', 'model': 'Elantra', 'year': 2024}
• Conclusion : La dernière utilisation écrase la valeur de la première utilisation
Récupérer une valeur / clé : méthode get()
print(b)
name = b.get("nom")
print(name)
{'nom': 'BenAhmed', 'prenom': 'Nabil', 'poids': 70, 'taille': 1.73}
BenAhmed
Si clé Introuvale : donner une valeur à retourner par défaut
# RechAdr = b.get("Adresse")
# print(RechAdr)
# Solution donner une valeur à retourner par défaut:
RechAdrPr = b.get("Adresse", "Champ 'Adresse' Intouvale !")
print(RechAdrPr)
champ = "age"
# champ = "salaire"
RechGen = b.get(champ, f"Champ '{champ}' Intouvale !")
print(RechGen)
Champ 'Adresse' Intouvale !
Champ 'age' Intouvale !
Vérifier la présence d'une clé dans un dictionnaire :
print(a)
cle = "nom"
print(cle in a)
# ------------------ Sensible à la casse
cle = "Nom"
print(cle in a)
{'nom': 'Benahmed', 'prenom': 'Amine'}
True
False
Supprimer une entrée dans un dictionnaire python :
• indiquer sa clé (comme pour les listes)
a = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille":
1.73}
print("Av : ", a)
del a["nom"]
print("Ap : ", a)
Av : {'nom': 'BenAhmed', 'prenom': 'Nabil', 'poids': 70, 'taille':
1.73}
Ap : {'prenom': 'Nabil', 'poids': 70, 'taille': 1.73}
Récupérer les clés d'un dictionnaire python par une boucle
• Utiliser la méthode .keys()
Fiche = {"nom":" Benahmed", "prenom":"Amine"}
for UneCle in Fiche.keys():
print(UneCle)
nom
prenom
Récupérer les valeurs d'un dictionnaire python par une boucle
• Utiliser la méthode .values()
fichE = {"nom":"Benahmed", "prenom":"Amine"}
for UneVal in fichE.values():
print(UneVal)
Benahmed
Amine
Récupérer les clés et les valeurs d'un dictionnaire python par une
boucle
• Utiliser la méthode .items() retourne un tuple
FichE = {"nom":"Benahmed", "prenom":"Amine"}
for CleVal in FichE.items():
print(CleVal)
('nom', 'Benahmed')
('prenom', 'Amine')
Combinaison Dictionnaire / Tuple
• Utilisation des tuples comme clé :
– Exemple : Coordonnées d'un point dans un plan comme clé
b = {}
b[(3,2)]=12
b[(4,5)]=13
print("Dicrtionnaire b :", b)
coord = (3,2)
print(f"Verifier presence {coord} in b :", coord in b)
val = 12
print(f"Verifier presence {val} in b :", val in b)
print(f"Verifier presence {val} in b.values() :", val in b.values())
Dicrtionnaire b : {(3, 2): 12, (4, 5): 13}
Verifier presence (3, 2) in b : True
Verifier presence 12 in b : False
Verifier presence 12 in b.values() : True
Copie de dictionnaire
• Créer une copie indépendante :
• à ne pas faire !!
– dic1 = dic2
d = {"k1":"Bensadik", "k2":"Ali"}
e = d
d["k2"] = "ZAID"
print(e)
{'k1': 'Bensadik', 'k2': 'ZAID'}
méthode .copy()
d = {"k1":"Bensadik", "k2":"Nabil"}
e = d.copy()
d["k1"] = "ZAID"
print("d :", d)
print("e :" , e)
d : {'k1': 'ZAID', 'k2': 'Nabil'}
e : {'k1': 'Bensadik', 'k2': 'Nabil'}
Fusionner des dictionnaires python :
• méthode .update()
a = {'nom': 'Ali'}
b = {'prenom': 'Bensadik'}
a.update(b)
print("Dict a : ", a)
print("Dict b : ", b)
Dict a : {'nom': 'Ali', 'prenom': 'Bensadik'}
Dict b : {'prenom': 'Bensadik'}
Tableaux :
- Python ne prend pas en charge les tableaux, mais les listes Python
peuvent être utilisées à la place.
• Ci-dessous :
– comment utiliser les LISTES comme TABLEAUX,
– cependant, pour travailler avec des tableaux en Python, il faut importer une
bibliothèque, comme la bibliothèque NumPy.
- from array import array
from array import array
t = array("i", [10, 20, 30, 40])
# t = array("f", [10, 20, 30, 40])
# t = array("i", [1, 2, 3, 4, "7", 6])
# t = array("i", [10, 20, 30, 40.0])
# t = array([10, 20, 30, 40.0])
print(t, type(t))
print("Len :", len(t))
# print(t[0])
# print(t[-1])
for i in t:
print(i)
array('i', [10, 20, 30, 40]) <class 'array.array'>
Len : 4
10
20
30
40
- import numpy as np
import numpy as np
tab = np.array([10, 12, 8])
# tab = np.array([10, 12, 8, 11.5])
# tab = np.array([10, 12, 8, 11.5 , "a"])
print(tab)
[10 12 8]
• Parcourir un tableau :
tab = np.array([10, 12, 8])
for elem in tab:
print(elem)
10
12
8
• Conversion Implicite (Upcasting)
timp = np.array([1, 2.0, 3])
print(timp)
[1. 2. 3.]
• Dimensions minimales 2 :
Tmin = np.array([21, 32, 13], ndmin=2)
print(Tmin, type(Tmin))
print(Tmin[0][2])
[[21 32 13]] <class 'numpy.ndarray'>
13
• Expliciter le type
TC = np.array([1, 2, 3], dtype=complex)
print(TC)
[1.+0.j 2.+0.j 3.+0.j]
Produit terme à terme
a = np.array([[1, 2, 3],
[4, 5, 6]])
b = np.array([[2, 1, 3],
[3, 2, 1]])
prod = a*b
print(prod)
[[ 2 2 9]
[12 10 6]]
a = np.array([1, 2, 4])
b = np.array([20, 10, 30])
print("Produit Scalaire : \n")
# ps = np.dot(a ,b)
# # ps = np.dot(a.transpose() ,b)
# print(ps)
aps = a@b
print(aps)
Produit Scalaire :
160
Matrices : Tableaux de plus d'une dimension
import numpy as np
tm = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
Lm = ([[10, 200], [30, 40], [50, 60]])
# print(tm)
# print("size :", np.size(tm) , " # Nombre d'elements")
# print("shape :", np.shape(tm))
# print("len :", len(tm) , " # Nombre de lignes")
# print("\nPOur la liste aussi :\n")
# print(Lm)
# print("size :", np.size(Lm), " # Nombre d'elements")
# print("shape :", np.shape(Lm))
# print("len :", len(Lm), " # Nombre de lignes")
# print("")
# print(tm[0])
# sl = tm[3] # ≠ Langage C
# print(sl)
# x = tm[0][1]
# print(x)
# y = tm[0,0]
# print(y)
# tm[0,0] = 99
# print(tm)
Afficher une Matrice:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
print(Mat)
[[ 10 20 70]
[ 30 40 90]
[100 200 300]]
# Méthode Ligne:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
for Lg in Mat:
print(Lg)
[10 20 70]
[30 40 90]
[100 200 300]
# Méthode 1:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
for Lg in Mat:
for j in Lg:
print(f"{j:3d}", end = " ")
print("")
10 20 70
30 40 90
100 200 300
# Méthode 2:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
m,n = np.shape(Mat)
for i in range(m):
for j in range(n):
print(f"{Mat[i][j]:3d}" , end = " ")
print("")
10 20 70
30 40 90
100 200 300
Modifier les éléments d'une matrice
# Méthode 1:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
for Lg in Mat:
for j in Lg:
j = j+1
print(f"{j:3d}", end = " ")
print("")
11 21 71
31 41 91
101 201 301
# Méthode 2:
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
m,n = np.shape(Mat)
for i in range(m):
for j in range(n):
Mat[i][j] += 1
print(f"{Mat[i][j]:3d}" , end = " ")
print("")
11 21 71
31 41 91
101 201 301
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
B = Mat + 1
print(B)
[[ 11 21 71]
[ 31 41 91]
[101 201 301]]
Produits matriciels de A et B:
- A@B
- np.dot(A,B)
- A*B : Element By Element
A = np.array([[10, 20, 70], [30, 40, 90], [100, 200, 300]])
B = np.array([[1, 2, 3], [6, 5, 4], [7, 9, 8]])
# B = np.array([[10, 20], [30, 40], [100, 200]])
print(f"\nA {np.shape(A)}: \n", A)
print(f"\nB {np.shape(B)}: \n", B)
C = A@B
print(f"\nA@B : {np.shape(C)}: \n", C)
D = np.dot(A,B)
print(f"\ndot : {np.shape(D)}: \n", D)
PL = A*B
print(f"\nElem By Elem : {np.shape(PL)}: \n", PL)
A (3, 3):
[[ 10 20 70]
[ 30 40 90]
[100 200 300]]
B (3, 3):
[[1 2 3]
[6 5 4]
[7 9 8]]
A@B : (3, 3):
[[ 620 750 670]
[ 900 1070 970]
[3400 3900 3500]]
dot : (3, 3):
[[ 620 750 670]
[ 900 1070 970]
[3400 3900 3500]]
Elem By Elem : (3, 3):
[[ 10 40 210]
[ 180 200 360]
[ 700 1800 2400]]
Transposée d'une Matrice
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90]])
TrMat = Mat.transpose()
print(f"Matrice Transpose : {np.shape(TrMat)}\n",TrMat)
TrsMat = Mat.T
print(f"Matrice 2 Transpose : {np.shape(TrsMat)}\n",TrsMat)
Matrice Transpose : (3, 2)
[[10 30]
[20 40]
[70 90]]
Matrice 2 Transpose : (3, 2)
[[10 30]
[20 40]
[70 90]]
Matrice Complexe conjugué - numpy.conj()
u = np.array([[ 2j, 4+3j],
[2+5j, 5 ],
[ 3, 6+2j]])
print("u :\n",u)
print("")
uConj = np.conj(u)
print("Conj u :\n",uConj)
u :
[[0.+2.j 4.+3.j]
[2.+5.j 5.+0.j]
[3.+0.j 6.+2.j]]
Conj u :
[[0.-2.j 4.-3.j]
[2.-5.j 5.-0.j]
[3.-0.j 6.-2.j]]
Déterminant - numpy.linalg.det()
from numpy.linalg import det
mt = np.array([[1, 2],
[3, 4]])
print(det(mt))
print(round(det(mt)))
-2.0000000000000004
-2
def deter(a):
return a[0][0]*a[1][1] - a[1][0]*a[0][1]
print(deter(mt))
-2
Inverse - numpy.linalg.inv()
from numpy.linalg import inv
a = np.array([[1, 3, 3],
[1, 4, 3],
[1, 3, 4]])
print(inv(a))
print("\nVerif a * inv(a) :")
c = a@inv(a)
print(c)
[[ 7. -3. -3.]
[-1. 1. 0.]
[-1. 0. 1.]]
Verif a * inv(a) :
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
Redimensionner une matrice
a = np.arange(12).reshape((3, 4))
print(a)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
import numpy as np
Mat = np.array([[10, 20, 70], [30, 40, 90]])
print(np.shape(Mat))
print("")
NouvMat = Mat.reshape(3,2)
print(np.shape(NouvMat))
print("\n")
print(f"Matrice : {np.shape(Mat)}\n",Mat)
print("\n")
print(f"Matrice R: {np.shape(NouvMat)}\n",NouvMat)
(2, 3)
(3, 2)
Matrice : (2, 3)
[[10 20 70]
[30 40 90]]
Matrice R: (3, 2)
[[10 20]
[70 30]
[40 90]]
a = np.arange(12).reshape((3, 4))
print("A :\n", a)
print("")
b = a.reshape(4,3)
print("B :\n", b)
print("")
c = b.reshape(6,2)
print("C :\n", c)
A :
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
B :
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
C :
[[ 0 1]
[ 2 3]
[ 4 5]
[ 6 7]
[ 8 9]
[10 11]]
Fichiers :
• Python dispose de plusieurs fonctions pour créer, lire et mettre à jour des fichiers.
• La fonction clé pour travailler avec des fichiers en Python est la fonction open().
• La fonction open() prend deux paramètres : le nom du fichier et le mode.
• Il existe quatre méthodes différentes (modes) pour ouvrir un fichier :
– "r" - Read - Valeur par défaut. Ouvre un fichier en lecture, erreur si le fichier
n'existe pas.
– "a" - Append - Ouvre un fichier pour l'ajouter, crée le fichier s'il n'existe pas.
– "w" - Write - Ouvre un fichier pour l'écriture, crée le fichier s'il n'existe pas.
– "x" - Create - Crée le fichier spécifié, renvoie une erreur si le fichier existe.
• En outre, vous pouvez spécifier si le fichier doit être traité en mode binaire ou en
mode texte
– "t" - Texte - Valeur par défaut. Mode texte
– "b" - Binaire - Mode binaire (par exemple, images)
ATTENTION : à chaque open() il faut associer
automatiquement un close()
Ouverture en lecture "r"
Lire tout le fichier d'un seul coup
f = open("E:\\etudiants.txt")
# f = open("demofile.txt", "rt")
print("Deb")
print(f.read()) # affiche tout le fichier
print("Fin")
f.close()
----------------------------------------------------------------------
-----
FileNotFoundError Traceback (most recent call
last)
Cell In[82], line 1
----> 1 f = open("E:\\etudiants.txt")
2 # f = open("demofile.txt", "rt")
4 print("Deb")
File ~\anaconda3\Lib\site-packages\IPython\core\
interactiveshell.py:310, in _modified_open(file, *args, **kwargs)
303 if file in {0, 1, 2}:
304 raise ValueError(
305 f"IPython won't let you open fd={file} by default "
306 "as it is likely to crash IPython. If you know what
you are doing, "
307 "you can use builtins' open."
308 )
--> 310 return io_open(file, *args, **kwargs)
FileNotFoundError: [Errno 2] No such file or directory: 'E:\\
etudiants.txt'
Lire le fichier Ligne par Ligne
f = open("E:\\etudiants.txt", "rt")
for x in f:
print("New Line : ", end = "")
print(x)
f.close()
----------------------------------------------------------------------
-----
FileNotFoundError Traceback (most recent call
last)
Cell In[81], line 1
----> 1 f = open("E:\\etudiants.txt", "rt")
3 for x in f:
4 print("New Line : ", end = "")
File ~\anaconda3\Lib\site-packages\IPython\core\
interactiveshell.py:310, in _modified_open(file, *args, **kwargs)
303 if file in {0, 1, 2}:
304 raise ValueError(
305 f"IPython won't let you open fd={file} by default "
306 "as it is likely to crash IPython. If you know what
you are doing, "
307 "you can use builtins' open."
308 )
--> 310 return io_open(file, *args, **kwargs)
FileNotFoundError: [Errno 2] No such file or directory: 'E:\\
etudiants.txt'
f = open("E:\\etudiants.txt")
x = f.readline()
while(x):
print(x)
x = f.readline()
f.close()
----------------------------------------------------------------------
-----
FileNotFoundError Traceback (most recent call
last)
Cell In[83], line 1
----> 1 f = open("E:\\etudiants.txt")
3 x = f.readline()
4 while(x):
File ~\anaconda3\Lib\site-packages\IPython\core\
interactiveshell.py:310, in _modified_open(file, *args, **kwargs)
303 if file in {0, 1, 2}:
304 raise ValueError(
305 f"IPython won't let you open fd={file} by default "
306 "as it is likely to crash IPython. If you know what
you are doing, "
307 "you can use builtins' open."
308 )
--> 310 return io_open(file, *args, **kwargs)
FileNotFoundError: [Errno 2] No such file or directory: 'E:\\
etudiants.txt'
Ouverture en ajout "a"
f = open("E:\\etudiants.txt" , "a")
f.write("\nHind:23:F:5:Oujda")
f.close()
f = open("E:\\etudiants.txt")
print(f.read()) # affiche tout le fichier
f.close()
----------------------------------------------------------------------
-----
FileNotFoundError Traceback (most recent call
last)
Cell In[84], line 1
----> 1 f = open("E:\\etudiants.txt" , "a")
2 f.write("\nHind:23:F:5:Oujda")
3 f.close()
File ~\anaconda3\Lib\site-packages\IPython\core\
interactiveshell.py:310, in _modified_open(file, *args, **kwargs)
303 if file in {0, 1, 2}:
304 raise ValueError(
305 f"IPython won't let you open fd={file} by default "
306 "as it is likely to crash IPython. If you know what
you are doing, "
307 "you can use builtins' open."
308 )
--> 310 return io_open(file, *args, **kwargs)
FileNotFoundError: [Errno 2] No such file or directory: 'E:\\
etudiants.txt'
Ouverture en écriture "w" (écrase l'existant)
f = open("E:\\etudiants.txt", "w")
f.write("Fatal Error ! I have deleted the content !")
f.close()
f = open("E:\\etudiants.txt")
print(f.read()) # affiche tout le fichier
f.close()
Fatal Error ! I have deleted the content !
Ouverture en écriture "x" (Erreur si le fichier existe)
f = open("E:\\etudiants.txt", "x")
f.write("Fatal Error 2 ! I have deleted the content !")
f.close()
f = open("E:\\etudiants.txt")
print(f.read()) # affiche tout le fichier
f.close()
----------------------------------------------------------------------
-----
FileExistsError Traceback (most recent call
last)
Cell In[7], line 1
----> 1 f = open("E:\\etudiants.txt", "x")
2 f.write("Fatal Error 2 ! I have deleted the content !")
3 f.close()
File ~\anaconda3\lib\site-packages\IPython\core\
interactiveshell.py:286, in _modified_open(file, *args, **kwargs)
279 if file in {0, 1, 2}:
280 raise ValueError(
281 f"IPython won't let you open fd={file} by default "
282 "as it is likely to crash IPython. If you know what
you are doing, "
283 "you can use builtins' open."
284 )
--> 286 return io_open(file, *args, **kwargs)
FileExistsError: [Errno 17] File exists: 'E:\\etudiants.txt'
Fin
