PYTHON CHAPITRE 3

GESTION DES FICHIERS ET

DOSSIERS EN PYTHON

1. LES COMMANDES DE BASE MANIPULATION DES FICHIERS ET DOSSIERS - MODULE OS

PROF : BOUTAKIOUT AYMANE
1- OBTENIR LE RÉPERTOIRE COURANT PRENONS LA FONCTION GETCWD()
(CWD=CURRENTWORKINGDIRECTORY) QUI RETOURNE L’ADRESSE DU RÉPERTOIRE DANS LEQUEL ON EST
EN TRAIN DE TRAVAILLER
2- CRÉATION D'UN DOSSIER À LA RACINE DU DISQUE
LA FONCTION MKDIR() (MAKE DIRECTORY) PERMET DE CRÉER UN RÉPERTOIRE DANS UN CHEMIN SPÉCIFIÉ.
CODE : OS.MKDIR(’TPPYTHON’)
3- TESTER SI UN RÉPERTOIRE EXISTE AVEC LA MÉTHODE OS.PATH.EXIST()
CODE : OS.PATH.EXIST(’TPPYTHON’)
4- CHANGER LE RÉPERTOIRE COURANT APRÈS LE TEST ,SI LE RÉPERTOIRE EXISTE DANS LA RACINE DU
DISQUE,LA FONCTION CHDIR()(CHANGEDIRECTORY) ()
 CODE : OS.CHDIR('TPPYTHON’)

2. LES CHEMINS
1- CHEMIN ABSOLU : LE CHEMIN ABSOLU DE NOTRE RÉPERTOIRE PRÉDÉFINI.
 CODE : import os ou avec la méthode abspath()
from pathlib import path import os
mydirectory = "." abspath= os.path.abspath("app.py")
p =path(mydirectory) print(abspath)
print(p.absolute())
2- chemin relatif : le chemin relatif, quant à lui,est la position d’un fichier à partir du dossier en cours de lecture (répertoire
courant).

 code :

import os ou la méthode .relpath()

dirname= os.path.dirname(__file__) path= "/users/krunal/desktop/code/pyt/database"

filename = os.path.join(dirname, ‘votrefichier,txt’) start = "/users/krunal"

relative_path= os.path.relpath(path, start)

print(relative_path)

3- Dossier parent du fichier :

Le dossier parent est le dossier qui contient le fichier ou dossier défini.

• Code: FROM PATHLIB IMPORT PATH

MYDIRECTORY = "/TPPYTHON/GESTIONDESFICHIERS"

P = PATH(MYDIRECTORY)

PRINT(P.PARENT)
4- CHEMIN EN ADRESSE URI
Python nous permet de convertir un chemin d’un fichier en URI (uniform resource identifier) à l’aide de la méthode as_uri();

code:

from pathlib import path

mydirectory= "/tppython/gestiondesfichiers/scraping.py"

p = path(mydirectory)

print(p.as_uri())

Le code suivant permet la même chose:

mydirectory= "scraping.py"

p = path(mydirectory)

fullpath=p.absolute()

print(fullpath.as_uri())
5- Récupération du contenu d'un dossier :
Sur python ,il y a une possibilité de récupérer le contenu d’un répertoire en appliquant la methode scandir() comme suit:

code :

from pathlib import path

import os

mydirectory="/tppython/gestiondesfichiers"

p = path(mydirectory)

for x in os.scandir(p):

print(x)

Affichage des bibliothèques .Py du répertoire'tp‘:

Pour filtrer et afficher le contenu d’un répertoire selon un type de fichier qu’on souhaite ,la méthode glob() peut servir comme suit:

code:

from pathlib import path

p = path(='/tppython/gestiondesfichiers')

for f in list(p.glob('**/*.py’)):

print(f)
6- Compresser et décompresser les fichiers 7- Déplacer ou copier un fichier

En fait ,le module "shutil« que nous venons d'utiliser est un autre outil utile pour
• Si vous êtes un expert python, aucun logiciel zip ne doit la gestion du système en python.
être installé sur votre ordinateur . Parce que quelques
Par exemple,si nous devons déplacer un fichier , la méthode shutdown.Move()
lignes de code python suffisent pour gérer la fermeture et
Code:
la décompression des fichiers.
import os
Code: from pathlib import path
import shutil
From zipfile import zipfile
source = '/users/yangsmac/pycharmprojects/pythonproject/test1.py'

With zipfile('test1.zip','w') as tz: target = '/users/yangsmac/pycharmprojects/test1.py'

tz.write(path('test1.py')) print(os.path.exists(source))

# true
Le code ci-dessus montre comment compresser un fichier
avec le module zipfile intégré. Cependant ,pour print(os.path.exists(target))

décompresser un fichier, l'utilisation est similaire: # false

shutil.move(source, target)
Code: from zipfile import zipfile
print(os.path.exists(source))
With zipfile('test1.zip') as tz:
# false
tz.extractall()
print(os.path.exists(target))

# true
8. RÉCUPÉRATION DU CONTENU D'UN DOSSIER

Le module os en python fournit des fonctions pour interagir avec les ystème d'exploitation. Le système
d'exploitation fait partie des modules utilitaires standard de python. Ce module fournit un moyen portable
d'utiliser les fonctionnalités dépendantes du système d'exploitation.

La méthode os.Scandir() en python est utilisée pour obtenir un itérateur d'objets os.Direntry
correspondant aux entrées du répertoire donné par le chemin spécifié.

Les entrées sont affichées dans un ordre arbitraire et les entrées spéciales '.'Et'..‘ Ne sont pas incluses.

CODE:

import os

path = '/home/ihritik’

obj = os.scandir(path)

print("files and directories in '% s':" % path)

for entry in obj :

if entry.is_dir() or entry.is_file():

print(entry.name)

obj.close()
 3. La gestion des threads

1- Création de threads CODE:

# import required modules
Un thread est une entité au sein d'un processus dont
l'exécution peut être planifiée. De plus, il s'agit de la plus from threading import *
petite unité de traitement pouvant être effectuée dans un # explicit function
système d'exploitation. def display() :
-Créez un thread sans utiliser de fonction explicite: for i in range(6) :

En important le module et en créant l'objet de classe print("child thread")

thread séparément ,nous pouvons facilement créer un # driver code
thread. C'est une manière orientée fonction de créer un
# create object of thread class
thread.
thread_obj= thread(target=display)
# executing child thread
thread_obj.start()
# executing main thread
for i in range(10):
print('main thread')
 exemple 2 : en utilisan les threads
exemple : programmation secontiale code

afficher bonjour 10 et bonsoir 10 fois en utilisan les threads Import time

Import threading
code:
def process_one():
import time
i=0
def process_one():
while i<10:
i=0 print(“bonjour”)

while i<10: time.sleep(0.3)

i+=1
print(“bonjour”)
def process_two():
time.sleep(0.10)
i=0
i+=1 while i<10:
def process_two(): print(“bonsoir”)

i=0 time.sleep(0.3)

i+=1
while i<10:
th1=threading.Thread(target=process_one) #cree les thread
print(“bonsoir”)
th2=threading.Thread(target=process_two)
time.sleep(0.10) th1.start() #execute les thread
i+=1 th2.start()

process_one() th1.join() #attende l execution thread 1 en suite thread 2

th2.join()
Process_two()
print(“fin du programme”)
class threads : import time

heritage et surcharge des methods import threading

import time class myprocess(threading.thread):
import threading def __init__(self):

class MyProcess(threading.Thread): threading.thread.__init__(self)

def __init__(self): def run(selfself):
threading.Thread.__init__(self) i=0

def run(self): while i<3:

i=0 letters ="abc"

while i<3: for lt in letters:

print(threading.current_thread()) print(lt)

time.sleep(0.3) time.sleep(0.3)

i +=1 i +=1

th1 = MyProcess() th1 = myprocess()

th2 = MyProcess() th2 = myprocess()

th1.start() th1.start()

th2.start() th2.start()

th1.join() th1.join()

th2.join() th2.join()

print("fin du programme") print("fin du programme")

2- Utiliser une variable globale avec plusieurs threads CODE :
• l'utilisation d'une variable globale avec plusieurs threads a=1
permet à plusieurs threads d'accéder à la même variable
def thread_1():
déclarée en dehors de la mémoire locale des threads.
global a
• Déclarez var en dehors de la mémoire des threads. Ensuite
,dans la fonction qu'un thread exécutera ,utilisez global var print(a)
pour déclarer var en tant que variable globale à la quelle le a += 1
thread aura accès.
def thread_2():
global a
print(a)
first_thread= threading.Thread(target = thread_1)
second_thread= threading.Thread(target = thread_2)
first_thread.start()
second_thread.start()

SORTIE 1 : 1
SORTIE 2 : 2
3 utiliser le verrouillage pour éviter la condition de concurrence
Une condition de concurrence se produit lorsque deux threads tentent d'accéder simultanément à une variable
partagée .Le premier thread lit la valeur de la variable partagée.

Le deuxième thread lit également la valeur de la même variable partagée . Ensuite , les deux threads tentent de
modifier la valeur de la variable partagée . Et ils se précipitent pour voir quel thread écrit une valeur dans la
variable en dernier.

La valeur du thread qui écrit en dernier dans la variable partagée est conservée car elle écrase la valeur écrite par
le thread précédent.

Pour éviter les conditions de concurrence , vous pouvez utiliser la classe lock du module de threading. Une
serrure a deux états : verrouillée et déverrouillée(lock/unlock)

Comment ça fonctionne:

1.Tout d'abord ,ajoutez un deuxième paramètre à la fonction augmentation().

2.Ensuite, créez une instance de la classe lock.

3.Troisièmement, acquérez un verrou avant d'accéder à la variable compteur et relâchez-le après la mise à jour
de la nouvelle valeur.
code: # create threads (créer des fils de discussion)

from threading import Thread, Lock t1 = thread(target=increase, args=(10, lock))

from time import sleep t2 = thread(target=increase, args=(20, lock))

counter = 0 # start the threads (lancer les discussions)

def increase(by, lock): t1.start()

global counter t2.start()
lock.acquire()
# attendre que les threads se terminent
local_counter= counter
t1.join()
local_counter+= by
t2.join()
sleep(0.1)
counter = local_counter print(f'thefinal counter is {counter}')
print(f'counter={counter}') SORTIE :
lock.release()
counter=10
lock = Lock()
counter=30

the final counter is 30

UTILISER LE VERROUILLAGE POUR ÉVITER LA CONDITION DE CONCURRENCE
Engros:
1.Une condition de concurrence se produit lorsque deux threads accèdent à une variable
partagée en même temps
2.Utilisez un objet lock pour empêcher la condition de concurrence
3.Appelez la méthode acquérir () d'un objet verrou pour acquérir un verrou
4.Appelez la méthode release() d'un objet lock pour libérer le verrou précédemment acquis
 4- LES COMMANDES SHELL DANS PYTHON
1-Exécuter des commandes shell en python

Python est un langage merveilleux pour la création de scripts et l'automatisation des flux de travail et il est doté d'outils
utiles prêts à l'emploi avec la bibliothèque standard Python. Une chose courante à faire, en particulier pour un
administrateur système, consiste à exécuter des commandes shell.

Mais ce qui se retrouvera généralement dans un fichier bash ou batch peut également être fait en Python.

2- Utilisation du module os:

La première et la plus simple approche pour exécuter une commande shell consiste à utiliser os.System():

code:

import os

os.system('ls -l')

Si vous enregistrez ceci en tant que script et que vous l'exécutez, vous verrez la sortie dans la ligne de commande. Le
problème avec cette approche réside dans sa rigidité puisque vous ne pouvez même pas obtenir la sortie résultante en
tant que variable.