Comment vérifier si un fichier est accessible en écriture en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un fichier est accessible en écriture en Python. Le laboratoire se concentre sur la compréhension des autorisations d'écriture des fichiers dans un environnement Linux et présente deux méthodes pour vérifier l'accès en écriture.

Tout d'abord, vous explorerez les autorisations de fichiers Linux, y compris les concepts de propriétaire, de groupe et d'autres utilisateurs, ainsi que les autorisations de lecture, d'écriture et d'exécution. Vous créerez un fichier, examinerez ses autorisations par défaut à l'aide de la commande ls -l et interpréterez la sortie. Ensuite, vous apprendrez à utiliser os.access() avec os.W_OK et tenterez d'ouvrir le fichier en écriture pour déterminer s'il est accessible en écriture en Python.

Skills Graph

Apprenez les autorisations d'écriture

Dans cette étape, nous allons explorer le concept des autorisations d'écriture dans l'environnement Linux. Comprendre les autorisations de fichiers est essentiel pour contrôler l'accès à vos fichiers et répertoires. L'autorisation d'écriture, en particulier, détermine si vous pouvez modifier un fichier ou un répertoire.

En Linux, chaque fichier et répertoire a un ensemble d'autorisations pour trois catégories d'utilisateurs :

• Propriétaire : L'utilisateur qui possède le fichier ou le répertoire.
• Groupe : Le groupe auquel le fichier ou le répertoire appartient.
• Autres : Tous les autres utilisateurs du système.

Pour chaque catégorie, il existe trois types d'autorisations :

• Lecture (r) : Vous permet de visualiser le contenu d'un fichier ou de lister le contenu d'un répertoire.
• Écriture (w) : Vous permet de modifier un fichier ou de créer, supprimer ou renommer des fichiers dans un répertoire.
• Exécution (x) : Vous permet d'exécuter un fichier (s'il s'agit d'un programme) ou d'entrer dans un répertoire.

Commençons par créer un fichier et examiner ses autorisations par défaut. Ouvrez l'éditeur VS Code et créez un nouveau fichier nommé my_file.txt dans le répertoire ~/project. Vous pouvez laisser le fichier vide pour l'instant.

Ensuite, ouvrez le terminal et accédez au répertoire ~/project :

cd ~/project

Maintenant, utilisons la commande ls -l pour afficher les autorisations du fichier :

ls -l my_file.txt

Vous verrez une sortie similaire à celle-ci :

-rw-rw-r-- 1 labex labex 0 Oct 26 14:35 my_file.txt

Décortiquons cette sortie :

• Le premier caractère (-) indique qu'il s'agit d'un fichier (contrairement à un répertoire, qui serait indiqué par d).
• Les neuf caractères suivants (rw-rw-r--) représentent les autorisations.
  • Les trois premiers (rw-) sont les autorisations du propriétaire (lecture et écriture).
  • Les trois suivants (rw-) sont les autorisations du groupe (lecture et écriture).
  • Les trois derniers (r--) sont les autorisations pour les autres (lecture seule).
• 1 indique le nombre de liens physiques (hard links) vers le fichier.
• labex labex sont respectivement le nom du propriétaire et du groupe.
• 0 est la taille du fichier en octets.
• Oct 26 14:35 est la date et l'heure de la dernière modification.
• my_file.txt est le nom du fichier.

Actuellement, le propriétaire (vous, en tant que labex) et le groupe ont des autorisations de lecture et d'écriture, tandis que les autres ont seulement des autorisations de lecture. Cela signifie que vous pouvez modifier le fichier, mais que les autres utilisateurs du système ne peuvent que le visualiser.

Maintenant, essayons de supprimer l'autorisation d'écriture pour le propriétaire en utilisant la commande chmod. chmod est utilisée pour modifier les autorisations de fichiers.

chmod u-w my_file.txt

Ici, u-w signifie "supprimer l'autorisation d'écriture pour le propriétaire".

Maintenant, vérifions les autorisations à nouveau :

ls -l my_file.txt

La sortie devrait maintenant ressembler à ceci :

-r--rw-r-- 1 labex labex 0 Oct 26 14:35 my_file.txt

Notez que les autorisations du propriétaire sont maintenant r--, indiquant un accès en lecture seule.

Dans les étapes suivantes, nous verrons comment utiliser Python pour vérifier les autorisations d'écriture et gérer les situations où elles ne sont pas disponibles.

Utilisez os.access() avec os.W_OK

Dans l'étape précédente, nous avons appris les autorisations de fichiers et comment les modifier à l'aide de la commande chmod. Maintenant, explorons comment utiliser Python pour vérifier de manière programmée si un fichier a des autorisations d'écriture. La fonction os.access() associée à la constante os.W_OK nous permet de faire exactement cela.

La fonction os.access() prend deux arguments :

• path : Le chemin du fichier ou du répertoire que vous souhaitez vérifier.
• mode : Un entier représentant l'autorisation (ou les autorisations) que vous souhaitez vérifier.

La constante os.W_OK représente l'autorisation d'écriture. Lorsqu'elle est utilisée avec os.access(), elle vérifie si le fichier ou le répertoire spécifié est accessible en écriture par l'utilisateur actuel.

Créons un script Python pour illustrer cela. Ouvrez l'éditeur VS Code et créez un nouveau fichier nommé check_write_permission.py dans le répertoire ~/project.

Ajoutez le code suivant au fichier :

import os

file_path = "my_file.txt"

if os.access(file_path, os.W_OK):
    print(f"The file '{file_path}' is writable.")
else:
    print(f"The file '{file_path}' is not writable.")

Voici ce que le code fait :

1. Il importe le module os, qui fournit des fonctions pour interagir avec le système d'exploitation.
2. Il définit une variable file_path qui stocke le nom du fichier que nous voulons vérifier (qui est my_file.txt créé dans l'étape précédente).
3. Il utilise os.access(file_path, os.W_OK) pour vérifier si le fichier est accessible en écriture.
4. Il affiche un message indiquant si le fichier est accessible en écriture ou non.

Maintenant, exécutons le script. Ouvrez le terminal et accédez au répertoire ~/project (si vous n'y êtes pas déjà) :

cd ~/project

Ensuite, exécutez le script Python :

python check_write_permission.py

Étant donné que nous avons supprimé les autorisations d'écriture pour le propriétaire dans l'étape précédente, la sortie devrait être :

The file 'my_file.txt' is not writable.

Maintenant, donnons au propriétaire les autorisations d'écriture pour le fichier :

chmod u+w my_file.txt

Et exécutons le script Python à nouveau :

python check_write_permission.py

Cette fois, la sortie devrait être :

The file 'my_file.txt' is writable.

Cela montre comment vous pouvez utiliser os.access() et os.W_OK pour vérifier de manière programmée les autorisations d'écriture en Python. Cela est utile pour écrire des programmes qui ont besoin de modifier des fichiers, mais qui doivent d'abord s'assurer qu'ils ont les autorisations nécessaires.

Tenter d'ouvrir un fichier en écriture

Dans cette étape, nous allons voir ce qui se passe lorsque nous essayons d'ouvrir un fichier en écriture sans avoir les autorisations nécessaires. Cela nous aidera à comprendre comment Python gère les erreurs d'autorisation.

Tout d'abord, supprimons à nouveau l'autorisation d'écriture de my_file.txt :

chmod u-w my_file.txt

Maintenant, créons un script Python qui tente d'ouvrir le fichier en écriture. Ouvrez l'éditeur VS Code et créez un nouveau fichier nommé attempt_write.py dans le répertoire ~/project.

Ajoutez le code suivant au fichier :

file_path = "my_file.txt"

try:
    with open(file_path, "w") as f:
        f.write("This is a test.")
    print("File written successfully.")
except Exception as e:
    print(f"Error writing to file: {e}")

Voici ce que le code fait :

1. Il définit une variable file_path qui stocke le nom du fichier dans lequel nous voulons écrire.
2. Il utilise un bloc try...except pour gérer les erreurs potentielles.
3. À l'intérieur du bloc try, il tente d'ouvrir le fichier en mode écriture ("w").
4. Si le fichier est ouvert avec succès, il écrit la chaîne de caractères "This is a test." dans le fichier.
5. Si une erreur se produit (par exemple, en raison du manque d'autorisations d'écriture), le bloc except intercepte l'exception et affiche un message d'erreur.

Maintenant, exécutons le script :

python attempt_write.py

Étant donné que nous avons supprimé les autorisations d'écriture, vous devriez voir une sortie similaire à celle-ci :

Error writing to file: [Errno 13] Permission denied: 'my_file.txt'

Cela confirme que Python lève une PermissionError (plus précisément, Errno 13) lorsque nous essayons d'ouvrir un fichier en écriture sans les autorisations nécessaires.

Maintenant, restaurons les autorisations d'écriture :

chmod u+w my_file.txt

Et exécutons le script à nouveau :

python attempt_write.py

Cette fois, la sortie devrait être :

File written successfully.

Et si vous vérifiez le contenu de my_file.txt, vous verrez qu'il contient maintenant le texte "This is a test." :

cat my_file.txt

This is a test.

Cela montre comment Python gère les erreurs d'autorisation lorsqu'il tente d'ouvrir un fichier en écriture. Il est important d'utiliser des blocs try...except pour intercepter ces erreurs et les gérer de manière appropriée dans vos programmes.

Résumé

Dans ce laboratoire (lab), nous avons commencé par explorer le concept des autorisations d'écriture sous Linux, en comprenant que ces autorisations contrôlent la capacité de modifier des fichiers et des répertoires. Nous avons appris les trois catégories d'utilisateurs (propriétaire, groupe, autres) et les trois types d'autorisations (lecture, écriture, exécution).

Ensuite, nous avons créé un fichier nommé my_file.txt et utilisé la commande ls -l pour examiner ses autorisations par défaut, en analysant la sortie pour comprendre comment les autorisations sont représentées pour chaque catégorie d'utilisateurs. Cela a fourni une base pour comprendre comment vérifier de manière programmée les autorisations d'écriture en Python.