Résumé du contenu associé aux opérations sur les fichiers en python (avec exemples)

Cet article vous apporte un résumé du contenu pertinent sur les opérations sur les fichiers en Python (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Introduction aux opérations sur les fichiers

Quand il s'agit d'exploiter des fichiers, nous penserons certainement aux flux. Les opérations sur les fichiers sont toutes effectuées via des flux. Le fonctionnement des fichiers en python est très simple Contrairement à d'autres langages comme Java, qui disposent de diverses opérations de flux, nous pouvons directement utiliser la fonction open pour ouvrir un fichier puis effectuer diverses opérations, cependant, en fonction de la manière d'ouvrir. , Les opérations qui peuvent être effectuées sont également différentes. Les manières d'ouvrir les fichiers sont : r, w, a, r+, w+, a+, rb, wb, ab, r+b, w+b, a+b, etc.

Regardons d'abord une opération de lecture de fichier :

In [2]: f = open(file='a.txt', mode='r', encoding='utf-8')

In [3]: f.read()
Out[3]: '每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'
In [4]:

Utilisez la fonction open pour ouvrir le fichier et renvoyer un objet fichier Plusieurs paramètres courants de la fonction open sont file (to be. opéré sur le nom du fichier), le mode (dans quel mode ouvrir) et l'encodage (spécifier un encodage pour lire le fichier), selon le mode, le fichier renvoyé aura diverses opérations. Jetons un coup d'œil à plusieurs opérations sur les fichiers.

2. Plusieurs façons d'utiliser les fichiers

(1) Opération en lecture seule

Pour une opération en lecture seule, spécifiez simplement le mode comme r :

In [5]: f = open(file='a.txt', mode='r', encoding='utf-8')
 
In [6]: f.read()
Out[6]: '每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'
 
In [7]: f.readable()                # 判断文件是否可读
Out[7]: True
 
In [8]: f.writable()                # 判断文件是否可写
Out[8]: False                       # 此处是以只读模式打开的文件，所以返回False不可写
 
In [9]: f1 = open(file='单分支结构.eddx', mode='rb')        # 使用‘rb’可以打开存储为二进制的数据，图片、视频等
 
In [10]: f1.read(20)
Out[10]: b'PK\x03\x04\x14\x00\x08\x00\x08\x00mN\xe3H\xa9\x95\xb3\x9eW\x01'

(2) Opération en écriture seule

mode='w'

                                                                             
In [13]: f = open(file='a.txt', mode='w', encoding='utf-8')                  
                                                                             
In [14]: f.read()                       # 此时尝试读取文件会报错                                            
---------------------------------------------------------------------------  
UnsupportedOperation                      Traceback (most recent call last)  
<ipython-input-14-571e9fb02258> in <module>                                  
----> 1 f.read()                                                             
                                                                             
UnsupportedOperation: not readable                                           
                                                                             
In [15]: f.write(&#39;葫芦娃&#39;)                                                      
Out[15]: 3                                                                   
                                                                             
In [16]: f.close()                                                           
                                                                             
In [17]: !cat a.txt                     # 此时查看文件之前那的内容已经被覆盖了                             
葫芦娃                                                                          
In [18]:

Lors de l'utilisation de mode='w' pour faire fonctionner un fichier, le fichier sera ouvert en premier. Effacez d'abord le fichier, puis écrivez le contenu dans le fichier selon l'opération. Le mode lecture seule a les caractéristiques suivantes :

• Lorsque le fichier ne s'ouvre pas. existe, le fichier sera automatiquement créé, puis le fichier sera ouvert pour l'opération

• Lors de l'ouverture d'un fichier, le contenu du fichier sera d'abord effacé, puis écrit à partir de zéro

• Le fichier est ouvert en mode écriture seule et ne peut pas être lu

(3) Opération d'ajout

mode. ='a'

In [18]: f = open(file='a.txt', mode='a', encoding='utf-8')
 
In [19]: f.write('每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n')
Out[19]: 42
 
In [20]: f.close()
 
In [21]:
 
In [21]: !cat a.txt
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大
 
In [22]:

Fonctionnement en mode ajout :

• Lors de l'ouverture d'un fichier, si le fichier n'existe pas, le fichier sera créé en premier

• Lors de l'écriture du contenu dans le fichier écrivez toujours à la fin du fichier, quel que soit l'endroit où se trouve le curseur

• L'ouverture le fichier ne peut être qu'écrit, pas lu

(4) mode r+

r+Le mode est une opération de lecture améliorée, c'est-à-dire qu'il peut lire et écrire :

In [22]: f = open(file='a.txt', mode='r+', encoding='utf-8')

In [23]: f.readable()
Out[23]: True

In [24]: f.writable()
Out[24]: True

In [25]: f.read()
Out[25]: '葫芦娃每天坚持一点，\n每天努力一点，\n每天多思考一点，\n慢慢你会发现，\n你的进步越来越大\n'

In [26]: f.write('\n哈哈哈哈哈哈哈')
Out[26]: 8

In [27]: f.close()

In [28]: !cat a.txt         # 查看写入的文件并没有异常
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大

哈哈哈哈哈哈哈
In [29]: f = open(file='a.txt', mode='r+', encoding='utf-8')

In [30]: f.seek(0, 2)       # seek可以调整光标位置
Out[30]: 153

In [31]: f.write('你的进步越来越大')
Out[31]: 8

In [32]: f.read()           # 先写后读会读出空字符
Out[32]: ''

In [33]:

Résumé : L'opération de lecture améliorée peut lire et écrire des fichiers, mais l'ordre doit être de lire d'abord, puis d'y écrire. Si vous lisez d'abord, puis écrivez et relisez ensuite, vous pouvez lire. une chaîne vide

fosse en mode r+ Attention : en mode r+, quel que soit le contenu lu Combien est affiché par le curseur. fichier, l'opération est effectuée à la fin

(5) modes w+ et a+

Le mode w+ et le mode a+ ont moins de scénarios d'utilisation réels. Voici une brève introduction :

• w+ : mode w amélioré, qui peut écrire et lire des opérations, mais c'est aussi la même chose que r+ Si vous d'abord, il y aura des pièges lors des opérations de lecture puis d'écriture, et le fichier le sera. être effacé en premier à chaque ouverture, il y a donc moins de scénarios d'utilisation

• a+ : Un mode amélioré, également disponible Effectuer des opérations de lecture et d'écriture, mais lors de l'écriture, vous ne pouvez écrire que dans la fin du fichier. Peu importe la façon dont vous déplacez le curseur, vous ne pouvez écrire qu'à la fin du fichier

3. méthodes

(1) Lecture et écriture de fichiers

Écriture de fichiers : principalement la méthode write et la méthode writelines

• méthode write : écrivez simplement la chaîne directement. L'exemple ci-dessus utilise également la méthode

• writelines : paramètres passés Itérables si nécessaire (comme les listes et les tuples, etc.)

Lecture de fichiers :

• méthode read : La méthode read reçoit un paramètre de type int, indiquant combien de caractères sont lus à une heure (l'unité de recherche est l'octet). Si elle n'est pas fournie, la valeur par défaut est de lire tout le contenu du fichier

• méthode readline : lire une ligne du fichier. est très utile lorsque le fichier est très volumineux. Le fichier entier ne sera pas lu en une seule fois

• méthode readlines : lisez le fichier entier et divisez chaque ligne en une liste et renvoyez-la. list

In [34]: f = open(file='a.txt', mode='r', encoding='utf-8')
# 葫芦娃每天坚持一点，
# 每天努力一点，
# 每天多思考一点，
# 慢慢你会发现，
# 你的进步越来越大
 
# 哈哈哈哈哈哈哈你的进步越来越大
In [35]: f.read(10)                 # 这里时一次读取10个字符
Out[35]: '葫芦娃每天坚持一点，'
 
In [36]: f.readline()
Out[36]: '\n'
 
In [37]: f.readline()               # 每次读取一行
Out[37]: '每天努力一点，\n'
 
In [38]: f.readlines()              # 返回的是一个列表
Out[38]: ['每天多思考一点，\n', '慢慢你会发现，\n', '你的进步越来越大\n', '\n', '哈哈哈哈哈哈哈你的进步越来越大']
 
In [39]:

La différence entre readline (descripteur de fichier) et readlines

Le descripteur de fichier est un objet itérable, qui est parcouru à chaque fois pendant le parcours de boucle Prendre un line ne le lira pas en entier lors de la lecture du fichier

Le résultat renvoyé par readlines est une liste Il lira le contenu de l'intégralité du fichier en une seule fois et renverra une liste lors du traitement de fichiers volumineux. beaucoup de ressources

Vous pouvez également utiliser une boucle pour parcourir le descripteur de fichier et afficher le contenu du fichier :

In [39]: f.seek(0)
Out[39]: 0

In [40]: for line in f:
    ...:     print(line.strip())
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大

哈哈哈哈哈哈哈你的进步越来越大

In [41]:

(2) Autres méthodes d'exploitation de fichier

• fermer : fermer le fichier

• lisible : déterminer si le fichier est lisible

• rechercher : déplacer le curseur et recevez d'abord deux données. Le premier paramètre indique la position de décalage (l'unité de mouvement est l'octet. Donc, s'il s'agit de la partie chinoise d'UTF-8, elle doit être un multiple de 3), et le deuxième paramètre indique le décalage par rapport à cela. position (0, représente le début, 1 représente la position actuelle, 2 représente la fin)

• seekable：判断当前文件的光标是否可移动

• tell：返回当前光标所在的位置

• truncate：截断数据（谨慎操作），默认截断光标后所有字符

• writable：判断文件是否可写

（3）打开文件的另一种方式

在打开一个文件后，要记得在文件使用结束狗使用close方法关闭文件句柄，但有时在中间进行大量的操作后可能会忘了关闭，下面介绍的这种方法可以不用自己手动关闭文件了，他会在您操作解说后（代码块的语句执行完毕）自动关闭文件句柄，这种方法就是使用context上下文管理，使用with语句实现：

In [43]: with open('a.txt', mode='r', encoding='utf-8') as f:   # 使用with管理上下文，最后退出时会自己执行close动作
    ...:     for line in f:
    ...:         print(line.strip())
葫芦娃每天坚持一点，
每天努力一点，
每天多思考一点，
慢慢你会发现，
你的进步越来越大
哈哈哈哈哈哈哈你的进步越来越大

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!