Explication détaillée des exemples de gestion de fichiers Python

Les exemples de cet article décrivent la méthode de gestion des fichiers Python. Partagez-le avec tout le monde pour référence, comme suit :

1. Gestion de fichiers en Python

La gestion de fichiers est une fonction de base et un composant important de nombreuses applications. Python peut rendre la gestion des fichiers extrêmement simple, surtout par rapport à d'autres langages.
Ci-dessous, Peyton McCullough explique les bases de la gestion de fichiers.

Introduction

Les jeux auxquels vous avez joué utilisent des fichiers pour sauvegarder des archives ; les commandes que vous avez passées sont enregistrées dans des fichiers évidemment, le rapport que vous avez rédigé le matin est également enregistré dans des fichiers ;

La gestion de fichiers est une partie importante des nombreuses applications écrites dans presque toutes les langues. Python ne fait certainement pas exception. Dans cet article, nous explorerons comment utiliser certains modules pour manipuler des fichiers. Nous terminerons les opérations de lecture de fichiers, d'écriture de fichiers, d'ajout de contenu de fichier et quelques utilisations alternatives. OK, commençons.

Lire et écrire des fichiers

L'opération de fichier la plus élémentaire est bien sûr la lecture et l'écriture de données dans le fichier. C'est également très facile à maîtriser. Ouvrez maintenant un fichier en écriture :

fileHandle = open ( 'test.txt', 'w' )

'w' signifie que le fichier sera écrit avec des données, le reste de l'instruction est facile à comprendre. L'étape suivante consiste à écrire les données dans le fichier :

fileHandle.write ( 'This is a test.\nReally, it is.' )

Cette déclaration écrit "Ceci est un test." sur la première ligne du fichier et "Vraiment, c'est le cas sur la seconde". ligne du fichier. Enfin, nous devons nettoyer et fermer le fichier :

fileHandle.close()

Comme vous pouvez le voir, c'est vraiment simple avec le mécanisme orienté objet de Python. Il convient de noter que lorsque vous utilisez la méthode « w » pour réécrire des données dans le fichier, tout le contenu original sera supprimé. Si vous souhaitez conserver le contenu original, vous pouvez utiliser la méthode "a" pour ajouter des données à la fin du fichier :

fileHandle = open ( 'test.txt', 'a' ) 
fileHandle.write ( '\n\nBottom line.' ) 
fileHandle.close()

Ensuite, nous lisons test.txt et afficher le contenu :

fileHandle = open ( 'test.txt' ) 
print fileHandle.read() 
fileHandle.close()

L'instruction ci-dessus lira l'intégralité du fichier et affichera les données qu'il contient. On peut également lire une ligne dans le fichier :

fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close()

En même temps, on peut également enregistrer le contenu du fichier dans une liste :

fileHandle = open ( 'test.txt' ) 
fileList = fileHandle.readlines()<DIV></DIV> 
for fileLine in fileList: 
  print &#39;>>&#39;, fileLine 
fileHandle.close()

Lorsque Python lit un fichier, il se souviendra de sa position dans le fichier, comme indiqué ci-dessous :

fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.readline() # "Really, it is."fileHandle.close()

Comme vous pouvez le voir, seule la deuxième ligne est affiché. Cependant, nous pouvons résoudre ce problème en demandant à Python de lire depuis le début :

fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.seek ( 0 ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close()

Dans l'exemple ci-dessus, nous demandons à Python de lire les données en commençant par le premier octet du déposer. Ainsi, la première ligne de texte s'affiche. Bien sûr, on peut aussi obtenir l'emplacement de Python dans le fichier :

fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
print fileHandle.tell() # "17" 
print fileHandle.readline() # "Really, it is."

ou lire quelques octets à la fois dans le fichier :

fileHandle = open ( 'test.txt' ) 
print fileHandle.read ( 1 ) # "T" 
fileHandle.seek ( 4 ) 
print FileHandle.read ( 1 ) # " "(原文有错)

Dans les environnements Windows et Macintosh, vous devrez parfois lire et écrire des fichiers en mode binaire, tels que des images et des fichiers exécutables. À ce stade, ajoutez simplement un "b" au paramètre de méthode d'ouverture du fichier :

fileHandle = open ( 'testBinary.txt', 'wb' )
fileHandle.write ( 'There is no spoon.' )
fileHandle.close()
fileHandle = open ( 'testBinary.txt', 'rb' )
print fileHandle.read()
fileHandle.close()

2. Obtenez des informations à partir des fichiers existants

Utiliser le module dans Python qui peut obtenir des informations à partir de fichiers existants. Vous pouvez utiliser le module "os" et le module "stat" pour obtenir des informations de base sur les fichiers :

import os 
import stat 
import time<DIV></DIV> 
fileStats = os.stat ( &#39;test.txt&#39; ) 
fileInfo = { 
  &#39;Size&#39; : fileStats [ stat.ST_SIZE ], 
  &#39;LastModified&#39; : time.ctime ( fileStats [ stat.ST_MTIME ] ), 
  &#39;LastAccessed&#39; : time.ctime ( fileStats [ stat.ST_ATIME ] ), 
  &#39;CreationTime&#39; : time.ctime ( fileStats [ stat.ST_CTIME ] ), 
  &#39;Mode&#39; : fileStats [ stat.ST_MODE ] 
} 
for infoField, infoValue in fileInfo: 
  print infoField, &#39;:&#39; + infoValue 
if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ): 
  print &#39;Directory. &#39;
else: 
  print &#39;Non-directory.&#39;

L'exemple ci-dessus crée un dictionnaire contenant des informations de base sur les fichiers. Ensuite, les informations pertinentes s'affichent et nous indiquent si le répertoire ouvert est un répertoire. On peut aussi essayer de voir si les types ouverts sont d'autres types :

import os 
import stat 
fileStats = os.stat ( 'test.txt' ) 
fileMode = fileStats [ stat.ST_MODE ] 
if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ): 
  print 'Regular file.'
elif stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ): 
  print 'Directory.'
elif stat.S_ISLNK ( fileStats [ stat.ST_MODE ] ): 
  print 'Shortcut.'
elif stat.S_ISSOCK ( fileStats [ stat.ST_MODE ] ): 
  print 'Socket.'
elif stat.S_ISFIFO ( fileStats [ stat.ST_MODE ] ): 
  print 'Named pipe.'
elif stat.S_ISBLK ( fileStats [ stat.ST_MODE ] ): 
  print 'Block special device.'
elif stat.S_ISCHR ( fileStats [ stat.ST_MODE ] ):

De plus, on peut utiliser "os.path" pour obtenir des informations de base :

import os.path 
fileStats = 'test.txt'
if os.path.isdir ( fileStats ): 
  print 'Directory.'
elif os.path.isfile ( fileStats ): 
  print 'File.'
elif os.path.islink ( fileStats ): 
  print 'Shortcut.'
elif os.path.ismount ( fileStats ): 
  print 'Mount point.'
import os 
for fileName in os.listdir ( '/' ): 
  print fileName

Comme vous pouvez le constater, cela est très simple et peut se faire en trois lignes de code.

Créer un répertoire est également très simple :

import os 
os.mkdir ( 'testDirectory' )

Supprimer le répertoire qui vient d'être créé :

import os 
os.rmdir ( 'testDirectory )

Vous pouvez également créer des répertoires à plusieurs niveaux :

import os
os.makedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' )
    os.makedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' )

Si vous n'ajoutez rien aux dossiers créés, vous pouvez les supprimer tous en même temps (c'est-à-dire supprimer tous les fichiers vides répertoriés dossier) :

import os
os.removedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes'

Lorsque nous devons opérer sur un type de fichier spécifique, nous pouvons choisir le module "fnmatch". Voici le contenu du fichier « .txt » et le nom du fichier « .exe » :

import fnmatch
import os
for fileName in os.listdir ( '/' ):
  if fnmatch.fnmath ( fileName, '*.txt' ):
    print open ( fileName ).read()
  elif fnmatch.fnmatch ( fileName, '*.exe' ):
    print fileName

les caractères peuvent représenter n'importe quelle longueur de caractères. Si vous souhaitez faire correspondre un caractère, utilisez le symbole "?" :

import fnmatch
import os
for fileName in os.listdir ( '/' ):
  if fnmatch.fnmatch ( fileName, '?.txt' ):
    print 'Text file.'

Le module "fnmatch" prend en charge les expressions régulières :

import fnmatch 
import os 
import re 
filePattern = fnmatch.translate ( '*.txt' ) 
for fileName in os.listdir ( '/' ): 
  if re.match ( filePattern, fileName ): 
    print 'Text file.'

Si vous n'avez besoin de faire correspondre qu'un seul type de fichier, une meilleure façon est d'utiliser le module "glob". Le format de ce module est similaire à "fnmatch" :

import glob 
for fileName in glob.glob ( '*.txt' ): 
  print 'Text file.'

Il est également possible de faire correspondre une plage de caractères, comme dans une expression régulière. Supposons que vous souhaitiez afficher le nom d'un fichier avec un seul chiffre avant l'extension :

import glob 
for fileName in glob.glob ( '[0-9].txt' ): 
  print filename

Le module "glob" utilise le module "fnmatch" pour y parvenir.

4. Marshaling des données

En utilisant le module présenté dans la section précédente, vous pouvez lire et écrire des chaînes dans des fichiers.

Cependant, vous devrez parfois transmettre d'autres types de données, tels qu'une liste, un tuple, un dictionnaire et d'autres objets. En Python, vous pouvez le faire en utilisant Pickling. Vous pouvez effectuer le marshalling des données à l'aide du module "pickle" de la bibliothèque standard Python.

Ensuite, regroupons une liste contenant des chaînes et des nombres :

import pickle 
fileHandle = open ( 'pickleFile.txt', 'w' ) 
testList = [ 'This', 2, 'is', 1, 'a', 0, 'test.' ] 
pickle.dump ( testList, fileHandle ) 
fileHandle.close()

Il n'est pas non plus difficile de diviser le groupe :

import pickle 
fileHandle = open ( 'pickleFile.txt' ) 
testList = pickle.load ( fileHandle ) 
fileHandle.close()

Essayez maintenant de stocker des données plus complexes :

import pickle 
fileHandle = open ( 'pickleFile.txt', 'w' ) 
testList = [ 123, { 'Calories' : 190 }, 'Mr. Anderson', [ 1, 2, 7 ] ] 
pickle.dump ( testList, fileHandle ) 
fileHandle.close()
import pickle 
fileHandle = open ( 'pickleFile.txt' ) 
testList = pickle.load ( fileHandle ) 
fileHandle.close()

如上所述，使用Python的"pickle"模块编组确实很简单。众多对象可以通过它来存储到文件中。如果可以的话，"cPickle"同样胜任这个工作。它和"pickle"模块一样，但是速度更快：

import cPickle 
fileHandle = open ( 'pickleFile.txt', 'w' ) 
cPickle.dump ( 1776, fileHandle ) 
fileHandle.close()

五、创建"虚拟"文件

你用到的许多模块包含需要文件对象作为参数的方法。但是，有时创建并使用一个真实的文件并让人感到有些麻烦。所幸的是，在Python中，你可以使用"StringIO"模块来创建文件并将其保存在内存中：

import StringIO 
fileHandle = StringIO.StringIO ( "Let freedom ring" ) 
print fileHandle.read() # "Let freedom ring." 
fileHandle.close()

cStringIO"模块同样有效。它的使用方法和"StringIO"一样，但就像"cPickle"之于"pickle"，它速度更快：

import cStringIO 
fileHandle = cStringIO.cStringIO ( "To Kill a Mockingbird" ) 
print fileHandle.read() # "To Kill a Mockingbid" 
fileHandle.close()

结论

文件管理，是众多编程语言的程序员在编写应用程序是经常遇到的问题。幸好，和其它语言相比，Python使其出乎意料地容易。Python的标准库中提供了许多相关的模块帮助程序员解决这方面的问题，而它的面向对象的机制也简化了操作。

好了，现在你已经了解了Python中文件管理的基本知识，可以在今后的应用程序中很好地使用了。

希望本文所述对大家Python程序设计有所帮助。

更多Python 文件管理实例详解相关文章请关注PHP中文网！